Crypto-View

Documentation

160 rules across 5 languages, plus formats that carry cryptography in any language. Every list here is generated from the scanner's own rule catalogue.

Describes Crypto-View 5.19.0, the current release. Last updated: 28 October 2026.

Supported languages

Each file is read as text with comments masked out, after a first pass over the repository collects the names files share. Each finding carries a confidence showing how specific the match was.

Open a language for its libraries and the functions each rule looks for.

Java

7 libraries · 31 rules · .java

Apache Milagro

  • Pairing-based cryptography through Apache Milagro

In scope 3

  • PAIR.ate()
  • PAIR.fexp()
  • new HASH256()

BouncyCastle

  • RSA through the BouncyCastle low-level API
  • Elliptic-curve cryptography through BouncyCastle
  • Edwards-curve signatures through BouncyCastle
  • Symmetric cipher through BouncyCastle
  • Digest through BouncyCastle
  • Message authentication code through BouncyCastle
  • Classical public-key algorithm through BouncyCastle
  • Post-quantum algorithm through BouncyCastle
  • Private key read or written as PEM

In scope 77

  • RSAEngine
  • RSABlindedEngine
  • RSAKeyPairGenerator
  • RSADigestSigner
  • RSAKeyParameters
  • PKCS1Encoding
  • OAEPEncoding
  • ECDSASigner
  • ECKeyPairGenerator
  • ECNamedCurveTable
  • X9ECParameters
  • ECDHBasicAgreement
  • ECDHCBasicAgreement
  • ECPrivateKeyParameters
  • ECPublicKeyParameters
  • ECIESEngine
  • Ed25519Signer
  • Ed448Signer
  • Ed25519KeyPairGenerator
  • Ed448KeyPairGenerator
  • X25519Agreement
  • X448Agreement
  • AESEngine
  • AESFastEngine
  • AESLightEngine
  • Salsa20Engine
  • XSalsa20Engine
  • ChaCha7539Engine
  • ChaChaEngine
  • DESEngine
  • DESedeEngine
  • RC4Engine
  • BlowfishEngine
  • SEEDEngine
  • CamelliaEngine
  • GCMBlockCipher
  • CCMBlockCipher
  • EAXBlockCipher
  • OCBBlockCipher
  • CBCBlockCipher
  • SICBlockCipher
  • MD5Digest
  • SHA1Digest
  • SHA224Digest
  • SHA256Digest
  • SHA384Digest
  • SHA512Digest
  • SHA3Digest
  • Blake2bDigest
  • Blake2sDigest
  • RIPEMD160Digest
  • SM3Digest
  • KeccakDigest
  • new HMac()
  • new CMac()
  • new GMac()
  • new Poly1305()
  • new SipHash()
  • new KMAC()
  • new DSASigner()
  • new DSAKeyPairGenerator()
  • new DHBasicAgreement()
  • new DHKeyPairGenerator()
  • new ElGamalEngine()
  • new ElGamalKeyPairGenerator()
  • MLKEMKeyPairGenerator
  • MLKEMGenerator
  • MLDSASigner
  • SLHDSASigner
  • KyberKeyPairGenerator
  • DilithiumSigner
  • SPHINCSPlusSigner
  • LMSKeyPairGenerator
  • XMSSKeyPairGenerator
  • new JcaPEMKeyConverter().getPrivateKey()
  • (PEMKeyPair) parser.readObject()
  • new JcaPKCS8Generator()

HTTP authentication

  • HTTP Digest authentication

In scope 2

  • DigestScheme
  • DigestSchemeFactory

JCA/JCE

  • Classical key pair generated through the JCA
  • Algorithm chosen at runtime
  • Classical public-key cipher through the JCA
  • Classical signature algorithm through the JCA
  • Classical key agreement through the JCA
  • Classical key material handled through the JCA
  • Hash algorithm through the JCA
  • Message authentication code through the JCA
  • Key store holding classical key material
  • TLS context created in code
  • Cipher transformation named away from the call
  • Key material constructed for a named algorithm
  • Mask-generation digest named for RSA padding
  • Named elliptic curve requested
  • Non-cryptographic randomness near key material
  • Random number generation
  • Password hashing or key derivation

In scope 46

  • KeyPairGenerator.getInstance()
  • KeyPairGenerator.initialize()
  • KeyPairGenerator.getInstance(name)
  • Cipher.getInstance(name)
  • Signature.getInstance(name)
  • KeyAgreement.getInstance(name)
  • KeyFactory.getInstance(name)
  • KeyGenerator.getInstance(name)
  • Mac.getInstance(name)
  • MessageDigest.getInstance(name)
  • SecretKeyFactory.getInstance(name)
  • Cipher.getInstance()
  • KeyGenerator.getInstance()
  • SecretKeyFactory.getInstance()
  • Signature.getInstance()
  • KeyAgreement.getInstance()
  • KeyFactory.getInstance()
  • AlgorithmParameterGenerator.getInstance()
  • MessageDigest.getInstance()
  • Mac.getInstance()
  • KeyStore.getInstance("JKS")
  • KeyStore.getInstance("PKCS12")
  • KeyStore.getInstance("JCEKS")
  • KeyStore.getInstance("BCFKS")
  • KeyStore.getInstance("BKS")
  • SSLContext.getInstance("TLS")
  • encrypt(bytes, iv, key, "AES/CBC/PKCS7Padding")
  • private static final String T = "AES/GCM/NoPadding"
  • new SecretKeySpec(bytes, "AES")
  • new PBEKeySpec()
  • new DESKeySpec()
  • MGF1ParameterSpec.SHA256
  • new MGF1ParameterSpec("SHA-256")
  • ECGenParameterSpec("secp256r1")
  • new Random()
  • Math.random()
  • new SecureRandom()
  • SecureRandom.getInstance()
  • SecureRandom.getInstanceStrong()
  • PBKDF2WithHmacSHA256
  • PBKDF2WithHmacSHA1
  • Argon2BytesGenerator
  • SCrypt
  • BCrypt
  • OpenBSDBCrypt
  • PKCS5S2ParametersGenerator

JGSS / Kerberos

  • Kerberos or SPNEGO authentication

In scope 6

  • GSSManager
  • GSSContext
  • KerberosTicket
  • KerberosPrincipal
  • KerberosScheme
  • SPNegoScheme

Module and package imports

  • Cryptographic library imported

Modules recognised 9

  • com.nimbusds.jose
  • io.jsonwebtoken
  • java.security
  • javax.crypto
  • javax.net.ssl
  • javax.security.auth.kerberos
  • org.bouncycastle
  • org.bouncycastle.pqc
  • org.ietf.jgss

NTLM

  • NTLM authentication

In scope 5

  • NTLMEngine
  • NTLMEngineImpl
  • NTLMScheme
  • NTCredentials
  • NTLMv2

Python

12 libraries · 25 rules · .py, .pyi

bcrypt / argon2 / passlib

  • Password hashing or key derivation

In scope 6

  • PBKDF2HMAC()
  • Scrypt()
  • Argon2id()
  • bcrypt.hashpw()
  • bcrypt.checkpw()
  • kdf.pbkdf2()

hashlib

  • Broken hash function
  • Hash function in use

In scope 12

  • hashlib.md5()
  • hashlib.sha1()
  • hashlib.new("md5")
  • hashlib.new("sha1")
  • hashlib.sha224()
  • hashlib.sha256()
  • hashlib.sha384()
  • hashlib.sha512()
  • hashlib.sha3_256()
  • hashlib.sha3_512()
  • hashlib.blake2b()
  • hashlib.blake2s()

hmac

  • Keyed hash in use

In scope 3

  • hmac.new()
  • hmac.digest()
  • hmac.HMAC()

Module and package imports

  • Cryptographic library imported

Modules recognised 20

  • Crypto
  • Cryptodome
  • OpenSSL
  • argon2
  • bcrypt
  • cryptography
  • ecdsa
  • hashlib
  • hmac
  • jose
  • jwt
  • nacl
  • oqs
  • paramiko
  • passlib
  • pqcrypto
  • pyasn1
  • scrypt
  • secrets
  • ssl

paramiko

  • SSH key handled by paramiko

In scope 4

  • paramiko.RSAKey
  • paramiko.ECDSAKey
  • paramiko.Ed25519Key
  • paramiko.DSSKey

pyca/cryptography

  • RSA key generated with pyca/cryptography
  • Elliptic-curve key generated with pyca/cryptography
  • ECDH key agreement
  • X25519 key agreement
  • Ed25519 signing key
  • Finite-field Diffie-Hellman
  • DSA signing key
  • RSA-OAEP encryption padding
  • PKCS#1 v1.5 padding
  • AES block cipher
  • Withdrawn symmetric cipher

In scope 25

  • rsa.generate_private_key()
  • rsa.RSAPublicNumbers()
  • rsa.RSAPrivateNumbers()
  • ec.generate_private_key()
  • ec.ECDH()
  • .exchange(ec.ECDH())
  • X25519PrivateKey.generate()
  • X448PrivateKey.generate()
  • Ed25519PrivateKey.generate()
  • Ed448PrivateKey.generate()
  • dh.generate_parameters()
  • dh.DHParameterNumbers()
  • dsa.generate_private_key()
  • dsa.DSAPrivateNumbers()
  • padding.OAEP()
  • padding.PKCS1v15()
  • algorithms.AES()
  • AESGCM()
  • AESOCB3()
  • algorithms.TripleDES
  • algorithms.Blowfish
  • algorithms.ARC4
  • algorithms.CAST5
  • algorithms.IDEA
  • algorithms.SEED

pyca/cryptography, liboqs, pqcrypto

  • Post-quantum algorithm in use

In scope 9

  • mlkem.MLKEM768PrivateKey.generate()
  • MLKEM768PublicKey.from_public_bytes()
  • mldsa.MLDSA65PrivateKey.generate()
  • oqs.KeyEncapsulation()
  • oqs.Signature()
  • pqcrypto.kem
  • ML_KEM
  • Kyber768
  • Dilithium3

PyCryptodome

  • RSA through PyCryptodome
  • Elliptic curves through PyCryptodome
  • Signature scheme through PyCryptodome

In scope 8

  • RSA.generate()
  • RSA.import_key()
  • RSA.importKey()
  • RSA.construct()
  • ECC.generate()
  • pkcs1_15.new()
  • pss.new()
  • DSS.new()

PyJWT

  • JWT signed with a classical algorithm

In scope 2

  • jwt.encode(payload, key, algorithm="RS256")
  • jwt.decode(token, key, algorithms=["RS256"])

pyOpenSSL

  • Key generated through pyOpenSSL

In scope 4

  • crypto.TYPE_RSA
  • crypto.TYPE_DSA
  • crypto.TYPE_EC
  • OpenSSL.crypto.PKey()

secrets / os

  • Random number generation

In scope 6

  • secrets.token_bytes()
  • secrets.token_hex()
  • secrets.token_urlsafe()
  • secrets.randbits()
  • secrets.choice()
  • os.urandom()

ssl

  • TLS protocol version pinned in code

In scope 3

  • ssl.SSLContext()
  • ssl.PROTOCOL_TLS_CLIENT
  • ssl.PROTOCOL_TLSv1_2

JavaScript and TypeScript

15 libraries · 23 rules · .js, .mjs, .cjs, .jsx, .ts, .tsx

@noble

  • Noble cryptography library in use

In scope 10

  • secp256k1.sign()
  • secp256k1.verify()
  • secp256k1.getPublicKey()
  • secp256k1.getSharedSecret()
  • ed25519.sign()
  • ed25519.verify()
  • ed25519.getPublicKey()
  • p256.sign()
  • p256.verify()
  • p256.getPublicKey()

@oslojs/otp / otplib

  • One-time passwords (HOTP / TOTP)

In scope 4

  • generateHOTP()
  • verifyTOTP()
  • createTOTPKeyURI()
  • authenticator.generate()

@simplewebauthn/server

  • WebAuthn passkeys registered or verified

In scope 3

  • verifyRegistrationResponse()
  • verifyAuthenticationResponse()
  • generateRegistrationOptions()

AWS SDK / Stripe

  • Signed URL or webhook signature

In scope 3

  • getSignedUrl()
  • getSignedCookies()
  • stripe.webhooks.constructEvent()

bcrypt / argon2 / scrypt

  • Password hashing or key derivation

In scope 6

  • pbkdf2()
  • pbkdf2Sync()
  • scrypt()
  • scryptSync()
  • hashSync()
  • compareSync()

bip32 / ecpair / bitcoinjs

  • Cryptocurrency key derivation

In scope 16

  • bip32.fromSeed()
  • bip32.fromBase58()
  • bip32.fromPublicKey()
  • bip32.fromPrivateKey()
  • bip39.mnemonicToSeed()
  • ECPair.fromPrivateKey()
  • ECPair.fromWIF()
  • ECPair.makeRandom()
  • ecc.sign()
  • ecc.signSchnorr()
  • ecc.verify()
  • ecc.pointFromScalar()
  • bitcoin.Psbt
  • bitcoin.payments
  • bitcoin.Transaction
  • .derivePath()

elliptic

  • Elliptic-curve library in use

In scope 2

  • new elliptic.ec("secp256k1")
  • new EC("p256")

jsonwebtoken / jose

  • JWT signed with a classical algorithm

In scope 3

  • jwt.sign(payload, key, { algorithm: "RS256" })
  • jwt.verify(token, key, { algorithms: ["RS256"] })
  • new SignJWT().setProtectedHeader({ alg: "ES256" })

Module and package imports

  • Cryptographic library imported

Modules recognised 42

  • @noble/ciphers
  • @noble/curves
  • @noble/ed25519
  • @noble/hashes
  • @noble/post-quantum
  • @noble/secp256k1
  • @node-rs/argon2
  • @node-rs/bcrypt
  • @oslojs/crypto
  • @scure/bip32
  • @scure/bip39
  • @signpdf/signpdf
  • aes-js
  • argon2
  • bcrypt
  • bcryptjs
  • bip32
  • bip39
  • bitcoinjs-lib
  • browserify-aes
  • create-hash
  • create-hmac
  • crypto
  • crypto-js
  • ecpair
  • elliptic
  • jose
  • jsonwebtoken
  • node-forge
  • node-rsa
  • node-signpdf
  • node:crypto
  • oslo
  • otpauth
  • otplib
  • pdf-lib
  • ripemd160
  • secp256k1
  • speakeasy
  • sshpk
  • tiny-secp256k1
  • tweetnacl

noble-post-quantum / liboqs

  • Post-quantum algorithm in use

In scope 5

  • ml_kem768
  • ml_dsa65
  • slh_dsa
  • mlkem768
  • mldsa65

Node crypto

  • Classical key pair generated with Node crypto
  • Key pair algorithm chosen at runtime
  • Signing or verification with a classical key
  • Diffie-Hellman key agreement
  • Withdrawn symmetric cipher
  • One-shot signing or public-key encryption
  • Keyed hash in use
  • Symmetric cipher in use

In scope 21

  • crypto.generateKeyPair("rsa")
  • crypto.generateKeyPairSync("ec")
  • promisify(crypto.generateKeyPair)
  • import { generateKeyPair as gen }
  • generateKeyPair(kind)
  • generateKeyPairSync(kind)
  • crypto.createSign("RSA-SHA256")
  • crypto.createVerify("SHA256")
  • crypto.createDiffieHellman()
  • crypto.createECDH("secp256k1")
  • createCipheriv("des-ede3-cbc")
  • createCipheriv("rc4")
  • crypto.sign()
  • crypto.verify()
  • publicEncrypt()
  • privateDecrypt()
  • privateEncrypt()
  • publicDecrypt()
  • createHmac("sha256")
  • createCipheriv("aes-256-gcm")
  • createCipheriv("chacha20-poly1305")

Node crypto / WebCrypto

  • Hash function in use
  • Random number generation

In scope 6

  • createHash("sha256")
  • subtle.digest("SHA-256")
  • crypto.randomBytes()
  • crypto.randomUUID()
  • crypto.randomInt()
  • crypto.getRandomValues()

node-forge

  • Cryptography through node-forge

In scope 4

  • forge.pki.rsa.generateKeyPair()
  • forge.pki.privateKey
  • forge.pki.publicKey
  • forge.pki.createCertificate()

tweetnacl

  • NaCl primitives in use

In scope 4

  • nacl.box
  • nacl.sign
  • nacl.scalarMult
  • nacl.secretbox

WebCrypto

  • Classical key generated with WebCrypto

In scope 4

  • subtle.generateKey({ name: "RSA-OAEP" })
  • subtle.generateKey({ name: "ECDSA" })
  • subtle.generateKey({ name: "ECDH" })
  • subtle.generateKey({ name: "Ed25519" })

Go

20 libraries · 21 rules · .go

crypto/aes

  • AES block cipher

In scope 5

  • aes.NewCipher()
  • cipher.NewGCM()
  • cipher.NewCBCEncrypter()
  • cipher.NewCBCDecrypter()
  • cipher.NewCTR()

crypto/des, crypto/rc4

  • Withdrawn symmetric cipher

In scope 3

  • des.NewCipher()
  • des.NewTripleDESCipher()
  • rc4.NewCipher()

crypto/dsa

  • DSA in the Go standard library

In scope 4

  • dsa.GenerateKey()
  • dsa.GenerateParameters()
  • dsa.Sign()
  • dsa.Verify()

crypto/ecdh

  • Key agreement in Go

In scope 5

  • ecdh.P256()
  • ecdh.P384()
  • ecdh.P521()
  • ecdh.X25519()
  • curve25519.X25519()

crypto/ecdsa

  • ECDSA in the Go standard library

In scope 5

  • ecdsa.GenerateKey(elliptic.P256())
  • ecdsa.Sign()
  • ecdsa.Verify()
  • ecdsa.SignASN1()
  • ecdsa.VerifyASN1()

crypto/ed25519

  • Ed25519 in the Go standard library

In scope 4

  • ed25519.GenerateKey()
  • ed25519.Sign()
  • ed25519.Verify()
  • ed25519.NewKeyFromSeed()

crypto/hmac

  • Keyed hash in use

In scope 2

  • hmac.New()
  • hmac.Equal()

crypto/md5, crypto/sha1

  • Broken hash function

In scope 5

  • md5.New()
  • md5.Sum()
  • sha1.New()
  • sha1.Sum()
  • md4.New()

crypto/mlkem, crypto/mldsa

  • Post-quantum algorithm in use

In scope 2

  • mlkem768.GenerateKey()
  • mldsa65.Sign()

crypto/rand

  • Random number generation

In scope 4

  • rand.Read()
  • rand.Int()
  • rand.Prime()
  • io.ReadFull(rand.Reader, b)

crypto/rsa

  • RSA in the Go standard library

In scope 9

  • rsa.GenerateKey()
  • rsa.SignPKCS1v15()
  • rsa.VerifyPKCS1v15()
  • rsa.SignPSS()
  • rsa.VerifyPSS()
  • rsa.EncryptOAEP()
  • rsa.DecryptOAEP()
  • rsa.EncryptPKCS1v15()
  • rsa.DecryptPKCS1v15()

crypto/sha256, crypto/sha512, crypto/sha3

  • Hash function in Go

In scope 9

  • sha256.Sum256()
  • sha256.New()
  • sha512.Sum512()
  • sha512.New384()
  • sha3.Sum256()
  • sha3.NewLegacyKeccak256()
  • blake2b.Sum256()
  • ripemd160.New()
  • keyutil.Fingerprint()

crypto/tls

  • TLS configuration in code

In scope 3

  • tls.Config{}
  • CipherSuites:
  • CurvePreferences:

crypto/x509

  • Public key parsed or encoded
  • Private key parsed or encoded

In scope 10

  • x509.ParsePKIXPublicKey()
  • x509.MarshalPKIXPublicKey()
  • x509.ParsePKCS1PublicKey()
  • x509.MarshalPKCS1PublicKey()
  • x509.ParsePKCS1PrivateKey()
  • x509.MarshalPKCS1PrivateKey()
  • x509.ParseECPrivateKey()
  • x509.MarshalECPrivateKey()
  • x509.ParsePKCS8PrivateKey()
  • x509.MarshalPKCS8PrivateKey()

go.mozilla.org/pkcs7

  • PKCS#7 / CMS enveloped data in Go

In scope 3

  • pkcs7.Encrypt()
  • p7.Decrypt(cert, key)
  • pkcs7.EncryptionAlgorithmDESCBC

golang.org/x/crypto

  • Password hashing or key derivation

In scope 7

  • bcrypt.GenerateFromPassword()
  • bcrypt.CompareHashAndPassword()
  • scrypt.Key()
  • argon2.IDKey()
  • argon2.Key()
  • pbkdf2.Key()
  • hkdf.New()

golang.org/x/crypto/chacha20poly1305

  • ChaCha20 in Go

In scope 3

  • chacha20poly1305.New()
  • chacha20poly1305.NewX()
  • chacha20.NewUnauthenticatedCipher()

golang.org/x/crypto/ssh

  • SSH implementation in use

In scope 8

  • ssh.NewSignerFromKey()
  • ssh.ParsePrivateKey()
  • ssh.ParsePublicKey()
  • ssh.ParseAuthorizedKey()
  • ssh.PublicKeys()
  • ssh.NewPublicKey()
  • signer.Sign(rand.Reader, data)
  • key.Verify(data, sig)

Module and package imports

  • Cryptographic library imported

Modules recognised 33

  • crypto/aes
  • crypto/cipher
  • crypto/des
  • crypto/dsa
  • crypto/ecdh
  • crypto/ecdsa
  • crypto/ed25519
  • crypto/elliptic
  • crypto/hmac
  • crypto/md5
  • crypto/mldsa
  • crypto/mlkem
  • crypto/rand
  • crypto/rc4
  • crypto/rsa
  • crypto/sha1
  • crypto/sha256
  • crypto/sha3
  • crypto/sha512
  • crypto/tls
  • crypto/x509
  • github.com/btcsuite/btcd
  • github.com/cloudflare/circl
  • golang.org/x/crypto/argon2
  • golang.org/x/crypto/bcrypt
  • golang.org/x/crypto/blake2b
  • golang.org/x/crypto/chacha20poly1305
  • golang.org/x/crypto/curve25519
  • golang.org/x/crypto/hkdf
  • golang.org/x/crypto/openpgp
  • golang.org/x/crypto/pbkdf2
  • golang.org/x/crypto/scrypt
  • golang.org/x/crypto/ssh

smallstep/pkcs7, google/go-attestation

  • Signature with whatever key the code holds, in Go

In scope 2

  • signedData.AddSigner(cert, signer, config)
  • certificationParameters.Verify(opts)

C and C++

14 libraries · 26 rules · .c, .h, .cc, .cpp, .cxx, .hpp, .hh, .hxx, .ipp, .inl

Botan

  • Cryptography through Botan

In scope 11

  • Cipher_Mode::create()
  • HashFunction::create()
  • MessageAuthenticationCode::create()
  • RSA_PrivateKey
  • ECDSA_PrivateKey
  • X25519_PrivateKey
  • ML_KEM_PrivateKey
  • create_private_key()
  • PK_Signer
  • PK_Encryptor_EME
  • PK_Key_Agreement

Crypto++

  • Cryptography through Crypto++

In scope 10

  • GCM<AES>::Encryption
  • CBC_Mode<AES>::Decryption
  • SHA256
  • HMAC<SHA256>
  • RSASS<PSS, SHA256>::Signer
  • RSAES_OAEP_SHA_Encryptor
  • ECDSA<ECP, SHA256>::Signer
  • ECDH<ECP>::Domain
  • x25519
  • StreamTransformationFilter()

CryptoAPI

  • Cryptography through the legacy Windows CryptoAPI

In scope 7

  • CryptCreateHash()
  • CryptGenKey()
  • CryptDeriveKey()
  • CryptEncrypt()
  • CryptSignHash()
  • CryptGenRandom()
  • CryptProtectData()

GnuTLS

  • Cryptography through GnuTLS

In scope 7

  • gnutls_cipher_init()
  • gnutls_hash_fast()
  • gnutls_hmac_init()
  • gnutls_pbkdf2()
  • gnutls_privkey_generate()
  • gnutls_pubkey_verify_data2()
  • gnutls_priority_set_direct()

libgcrypt

  • Cryptography through libgcrypt

In scope 8

  • gcry_cipher_open()
  • gcry_cipher_encrypt()
  • gcry_md_open()
  • gcry_md_hash_buffer()
  • gcry_mac_open()
  • gcry_kdf_derive()
  • gcry_pk_genkey()
  • gcry_pk_sign()

liboqs

  • Post-quantum algorithm through liboqs

In scope 5

  • OQS_KEM_new()
  • OQS_KEM_encaps()
  • OQS_SIG_new()
  • OQS_SIG_sign()
  • OQS_KEM_ml_kem_768_keypair()

Mbed TLS

  • Cryptography through Mbed TLS
  • Private key parsed by Mbed TLS

In scope 14

  • mbedtls_cipher_info_from_type()
  • mbedtls_md_info_from_type()
  • mbedtls_aes_setkey_enc()
  • mbedtls_gcm_setkey()
  • mbedtls_sha256()
  • mbedtls_md_hmac()
  • mbedtls_rsa_gen_key()
  • mbedtls_rsa_pkcs1_encrypt()
  • mbedtls_ecdsa_genkey()
  • mbedtls_ecdh_calc_secret()
  • mbedtls_pk_sign()
  • mbedtls_ctr_drbg_seed()
  • mbedtls_pk_parse_key()
  • mbedtls_pk_parse_keyfile()

Module and package imports

  • Cryptographic library imported

Modules recognised 120

  • bcrypt.h
  • botan/cipher_mode.h
  • botan/dilithium.h
  • botan/ecdh.h
  • botan/ecdsa.h
  • botan/ed25519.h
  • botan/hash.h
  • botan/kyber.h
  • botan/ml_dsa.h
  • botan/ml_kem.h
  • botan/pubkey.h
  • botan/rsa.h
  • botan/tls.h
  • botan/x25519.h
  • crypto++/eccrypto.h
  • crypto++/rsa.h
  • cryptoki.h
  • cryptopp/aes.h
  • cryptopp/des.h
  • cryptopp/dh.h
  • cryptopp/dsa.h
  • cryptopp/eccrypto.h
  • cryptopp/hmac.h
  • cryptopp/md5.h
  • cryptopp/osrng.h
  • cryptopp/rsa.h
  • cryptopp/sha.h
  • cryptopp/xed25519.h
  • gcrypt.h
  • gnutls/abstract.h
  • gnutls/crypto.h
  • gnutls/gnutls.h
  • gnutls/x509.h
  • mbedtls/aes.h
  • mbedtls/ccm.h
  • mbedtls/chachapoly.h
  • mbedtls/cipher.h
  • mbedtls/ctr_drbg.h
  • mbedtls/des.h
  • mbedtls/dhm.h
  • mbedtls/ecdh.h
  • mbedtls/ecdsa.h
  • mbedtls/gcm.h
  • mbedtls/hkdf.h
  • mbedtls/md.h
  • mbedtls/md5.h
  • mbedtls/pk.h
  • mbedtls/pkcs5.h
  • mbedtls/rsa.h
  • mbedtls/sha1.h
  • mbedtls/sha256.h
  • mbedtls/sha512.h
  • mbedtls/ssl.h
  • mbedtls/x509_crt.h
  • ncrypt.h
  • nettle
  • nettle/aes.h
  • nettle/curve25519.h
  • nettle/des.h
  • nettle/dsa.h
  • nettle/ecdsa.h
  • nettle/eddsa.h
  • nettle/gcm.h
  • nettle/md4.h
  • nettle/md5.h
  • nettle/rsa.h
  • nettle/sha1.h
  • nettle/sha2.h
  • openssl/aes.h
  • openssl/blowfish.h
  • openssl/camellia.h
  • openssl/cast.h
  • openssl/cmac.h
  • openssl/cms.h
  • openssl/des.h
  • openssl/dh.h
  • openssl/dsa.h
  • openssl/ec.h
  • openssl/ecdh.h
  • openssl/ecdsa.h
  • openssl/evp.h
  • openssl/hmac.h
  • openssl/idea.h
  • openssl/kdf.h
  • openssl/md4.h
  • openssl/md5.h
  • openssl/pkcs12.h
  • openssl/pkcs7.h
  • openssl/rand.h
  • openssl/rc2.h
  • openssl/rc4.h
  • openssl/ripemd.h
  • openssl/rsa.h
  • openssl/sha.h
  • openssl/ssl.h
  • openssl/x509.h
  • openssl/x509v3.h
  • oqs/oqs.h
  • pk11pub.h
  • pkcs11.h
  • psa/crypto.h
  • sodium
  • sodium.h
  • wincrypt.h
  • wolfssl/openssl
  • wolfssl/ssl.h
  • wolfssl/wolfcrypt/aes.h
  • wolfssl/wolfcrypt/curve25519.h
  • wolfssl/wolfcrypt/des3.h
  • wolfssl/wolfcrypt/dh.h
  • wolfssl/wolfcrypt/dilithium.h
  • wolfssl/wolfcrypt/ecc.h
  • wolfssl/wolfcrypt/ed25519.h
  • wolfssl/wolfcrypt/hmac.h
  • wolfssl/wolfcrypt/kyber.h
  • wolfssl/wolfcrypt/md5.h
  • wolfssl/wolfcrypt/rsa.h
  • wolfssl/wolfcrypt/sha.h
  • wolfssl/wolfcrypt/sha256.h
  • wolfssl/wolfcrypt/wc_mlkem.h

OpenSSL

  • Symmetric cipher through OpenSSL
  • Hash function through OpenSSL
  • Message authentication through OpenSSL
  • Key derivation through OpenSSL
  • RSA through OpenSSL
  • Elliptic-curve and DSA signatures and keys through OpenSSL
  • Key agreement through OpenSSL
  • Post-quantum algorithm through OpenSSL
  • Public-key operation with a key chosen elsewhere
  • Algorithm chosen at run time through OpenSSL
  • Random number generation through OpenSSL
  • Private key read or written through OpenSSL

In scope 78

  • EVP_aes_256_gcm()
  • EVP_EncryptInit_ex()
  • EVP_DecryptInit_ex()
  • EVP_CipherInit_ex()
  • EVP_CIPHER_fetch()
  • EVP_get_cipherbyname()
  • EVP_EncryptFinal_ex()
  • AES_set_encrypt_key()
  • DES_ecb_encrypt()
  • RC4_set_key()
  • BF_cbc_encrypt()
  • EVP_sha256()
  • EVP_DigestInit_ex()
  • EVP_MD_fetch()
  • EVP_get_digestbyname()
  • EVP_DigestFinal_ex()
  • EVP_Q_digest()
  • SHA256()
  • SHA1()
  • MD5()
  • MD5_Init()
  • HMAC()
  • HMAC_Init_ex()
  • HMAC_Final()
  • EVP_MAC_fetch()
  • EVP_MAC_final()
  • EVP_Q_mac()
  • CMAC_Init()
  • EVP_PKEY_new_mac_key()
  • PKCS5_PBKDF2_HMAC()
  • EVP_KDF_fetch()
  • EVP_KDF_derive()
  • EVP_PBE_scrypt()
  • EVP_BytesToKey()
  • EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)
  • EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)
  • EVP_RSA_gen()
  • EVP_PKEY_CTX_set_rsa_keygen_bits()
  • EVP_PKEY_CTX_set_rsa_padding()
  • EVP_PKEY_encrypt()
  • EVP_SealInit()
  • CMS_encrypt()
  • RSA_generate_key_ex()
  • RSA_public_encrypt()
  • RSA_sign()
  • EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)
  • EVP_EC_gen()
  • EVP_PKEY_CTX_set_ec_paramgen_curve_nid()
  • EVP_DigestSignInit()
  • EC_KEY_new_by_curve_name()
  • ECDSA_sign()
  • ECDSA_do_verify()
  • DSA_sign()
  • EVP_PKEY_derive_init()
  • EVP_PKEY_derive()
  • EVP_PKEY_CTX_new_id(EVP_PKEY_X25519, NULL)
  • EVP_PKEY_Q_keygen(NULL, NULL, "X25519")
  • ECDH_compute_key()
  • DH_generate_key()
  • DH_compute_key()
  • EVP_PKEY_Q_keygen(NULL, NULL, "ML-KEM-768")
  • EVP_PKEY_CTX_new_from_name(NULL, "ML-DSA-65", NULL)
  • EVP_PKEY_encapsulate()
  • EVP_PKEY_decapsulate()
  • EVP_PKEY_CTX_new(pkey, NULL)
  • EVP_PKEY_sign_init()
  • EVP_DigestSignInit(ctx, NULL, md, NULL, pkey)
  • EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv)
  • EVP_DigestInit_ex(ctx, md, NULL)
  • EVP_CIPHER_fetch(NULL, name, NULL)
  • RAND_bytes()
  • RAND_priv_bytes()
  • EVP_RAND_fetch()
  • PEM_read_bio_PrivateKey()
  • d2i_PrivateKey()
  • PEM_read_bio_RSAPrivateKey()
  • SSL_CTX_use_PrivateKey_file()
  • PEM_write_bio_PrivateKey()

PKCS#11

  • Mechanism used through PKCS#11

In scope 8

  • CKM_RSA_PKCS_KEY_PAIR_GEN
  • CKM_ECDH1_DERIVE
  • CKM_AES_GCM
  • CKM_SHA256_RSA_PKCS
  • C_EncryptInit()
  • C_SignInit()
  • C_GenerateKeyPair()
  • CKM_ML_KEM

PSA Crypto API

  • Cryptography through the PSA Crypto API

In scope 10

  • psa_aead_encrypt()
  • psa_cipher_encrypt()
  • psa_hash_compute()
  • psa_mac_compute()
  • psa_sign_hash()
  • psa_verify_hash()
  • psa_asymmetric_encrypt()
  • psa_raw_key_agreement()
  • psa_key_derivation_setup()
  • psa_generate_key()

Windows CNG

  • Cryptography through Windows CNG

In scope 11

  • BCryptOpenAlgorithmProvider()
  • BCryptGenerateKeyPair()
  • BCryptEncrypt()
  • BCryptSignHash()
  • BCryptSecretAgreement()
  • BCryptCreateHash()
  • BCryptFinishHash()
  • BCryptDeriveKeyPBKDF2()
  • BCryptEncapsulate()
  • NCryptCreatePersistedKey()
  • NCryptSignHash()

Windows SSPI

  • Authentication through Windows SSPI

In scope 4

  • AcquireCredentialsHandle(NULL, NTLMSP_NAME, ..)
  • MICROSOFT_KERBEROS_NAME
  • NEGOSSP_NAME
  • SP_PROT_TLS1_2_CLIENT

wolfSSL

  • Cryptography through wolfCrypt

In scope 13

  • wc_AesSetKey()
  • wc_AesGcmEncrypt()
  • wc_Sha256Hash()
  • wc_HmacSetKey()
  • wc_PBKDF2()
  • wc_MakeRsaKey()
  • wc_RsaPublicEncrypt()
  • wc_ecc_make_key_ex()
  • wc_ecc_shared_secret()
  • wc_curve25519_shared_secret()
  • wc_ed25519_sign_msg()
  • wc_MlKemKey_Encapsulate()
  • wolfSSL_UseKeyShare()

Formats and configuration

14 libraries · 34 rules · any readable text file

  • Release signed by the build
  • Algorithm named in a setting

In scope 14

  • apksigner sign
  • jarsigner -keystore
  • codesign --sign
  • signtool sign
  • gpg --detach-sign
  • signatureAlgorithm = "SHA256withRSA"
  • withOaepPaddingDigestAlgorithm("SHA-512")
  • "digestAlgorithm": "SHA-256"
  • SYMMETRIC_KEY_TYPE = "AES"
  • defaultProperty(HASH_ALGORITHM, "SHA2")
  • "SHA-256".equals(algorithm)
  • setProperty("crypto.hash_algorithm", "SHA2")
  • const digest = 'sha256'
  • getAlgorithm() { return "SM2"

COSE / WebAuthn

  • COSE algorithm identifier

In scope 4

  • COSEAlgorithmIdentifier.ES256
  • COSEAlgorithmIdentifier.EdDSA
  • alg: -7
  • alg: -257

Dependency manifests

  • Cryptographic library in the dependency manifest

Packages recognised 31

  • @noble/curves
  • @noble/post-quantum
  • bcpkix
  • bcprov
  • bcprov-jdk18on
  • bctls
  • bitcoinjs-lib
  • cryptography
  • elliptic
  • github.com/btcsuite/btcd
  • github.com/cloudflare/circl
  • golang.org/x/crypto
  • jjwt
  • jose
  • jsonwebtoken
  • nimbus-jose-jwt
  • node-forge
  • node-rsa
  • oqs
  • paramiko
  • pqcrypto
  • pycryptodome
  • pycryptodomex
  • pyjwt
  • pyopenssl
  • python-jose
  • secp256k1
  • sshpk
  • tink
  • tiny-secp256k1
  • tweetnacl

JOSE

  • JOSE algorithm declared in configuration
  • Public key declared as a JSON Web Key
  • Signed token created or verified

In scope 14

  • "alg": "RS256"
  • "algorithm": "ES256"
  • alg: RS512
  • "kty": "RSA"
  • "kty": "EC", "crv": "P-256"
  • "kty": "OKP", "crv": "Ed25519"
  • jose.NewSigner()
  • jose.Signed()
  • jws.Verify()
  • jwt.Claims(key, &claims)
  • JWS.sign()
  • new SignJWT()
  • jwtVerify()
  • compactVerify()

NaCl / libsodium

  • Ed25519 signatures through NaCl or libsodium
  • X25519 key agreement through NaCl or libsodium
  • Authenticated encryption through NaCl or libsodium
  • Hashing and key derivation through NaCl or libsodium
  • Random bytes through NaCl or libsodium

In scope 19

  • crypto_sign()
  • crypto_sign_open()
  • crypto_sign_keypair()
  • crypto_sign_detached()
  • crypto_box()
  • crypto_box_open()
  • crypto_box_keypair()
  • crypto_box_seal()
  • crypto_box_easy()
  • crypto_scalarmult()
  • crypto_secretbox()
  • secretbox()
  • secretbox_open()
  • crypto_onetimeauth()
  • crypto_hash()
  • crypto_generichash()
  • crypto_pwhash()
  • randombytes()
  • randombytes_buf()

Named algorithm constants

  • Algorithm named by a constant
  • Algorithm named by its object identifier
  • Key type chosen by a setting
  • Call to code named for an algorithm
  • Algorithm implemented in the repository

In scope 22

  • JavaAlgorithm.SHA256
  • XMLCipher.AES_128
  • crypto.SHA256
  • x509.SHA256WithRSA
  • SignatureMethod.RSA_SHA256
  • DigestMethod.SHA256
  • '1.2.840.113549.1.1.11'
  • '2.16.840.1.101.3.4.2.1'
  • '1.2.840.10045.3.1.7'
  • elliptic_curve="secp256r1"
  • "P-384"
  • rsa_key_size=2048
  • Hash.sha256()
  • hmacSha256()
  • getMD5()
  • new ScryptGenerator()
  • new Ed25519PublicKey()
  • sha256.digest()
  • class MD4
  • class Sha256
  • class SCrypt
  • class HMACMD5

nginx / Apache

  • TLS versions pinned in configuration

In scope 2

  • ssl_protocols
  • SSLProtocol

nginx / Apache / HAProxy

  • TLS cipher suites pinned in configuration
  • TLS key-exchange groups pinned in configuration

In scope 8

  • ssl_ciphers
  • SSLCipherSuite
  • ssl-default-bind-ciphers
  • ssl_ecdh_curve
  • SSLOpenSSLConfCmd Curves
  • ssl-default-bind-curves
  • tls.CurveP256
  • tls.X25519MLKEM768

OpenSSH

  • SSH public key
  • SSH algorithms pinned in configuration

In scope 12

  • ssh-rsa
  • ssh-dss
  • ssh-ed25519
  • ecdsa-sha2-nistp256
  • ecdsa-sha2-nistp384
  • ecdsa-sha2-nistp521
  • sk-ssh-ed25519@openssh.com
  • KexAlgorithms
  • HostKeyAlgorithms
  • Ciphers
  • MACs
  • PubkeyAcceptedAlgorithms

PEM

  • Private key committed to the repository
  • Certificate signing request
  • X.509 certificate
  • Public key file

In scope 12

  • -----BEGIN PRIVATE KEY-----
  • -----BEGIN RSA PRIVATE KEY-----
  • -----BEGIN EC PRIVATE KEY-----
  • -----BEGIN DSA PRIVATE KEY-----
  • -----BEGIN OPENSSH PRIVATE KEY-----
  • -----BEGIN ENCRYPTED PRIVATE KEY-----
  • -----BEGIN CERTIFICATE REQUEST-----
  • -----BEGIN NEW CERTIFICATE REQUEST-----
  • -----BEGIN CERTIFICATE-----
  • -----BEGIN TRUSTED CERTIFICATE-----
  • -----BEGIN PUBLIC KEY-----
  • -----BEGIN RSA PUBLIC KEY-----

PKCS#12

  • Key store loaded

In scope 1

  • P12Signer.create(p12, passphrase)

TLS

  • TLS used in code
  • TLS cipher suite named in source
  • Weak algorithm inside a TLS cipher suite

In scope 16

  • SSLContexts.createDefault()
  • SSLSocketFactory.getDefault()
  • setEnabledProtocols()
  • setEnabledCipherSuites()
  • startHandshake()
  • tls.VersionTLS12
  • tls.Dial()
  • ssl.create_default_context()
  • tls.connect()
  • "TLSv1.2"
  • TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
  • ECDHE-RSA-AES128-GCM-SHA256
  • TLS_AES_256_GCM_SHA384
  • TLS_RSA_WITH_AES_128_CBC_SHA
  • TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
  • TLS_ECDHE_ECDSA_WITH_RC4_128_SHA

X.509

  • X.509 certificate handled in code
  • Certificate signed or verified
  • Certificate verification disabled

In scope 32

  • x509.load_pem_x509_certificate()
  • x509.load_der_x509_csr()
  • crypto.load_certificate()
  • x509.ParseCertificate()
  • x509.ParseCertificateRequest()
  • pemutil.ReadCertificate()
  • tls.LoadX509KeyPair()
  • CertificateFactory.getInstance("X.509")
  • generateCertificate()
  • new X509Certificate()
  • forge.pki.certificateFromPem()
  • x509.CreateCertificate()
  • x509.CreateCertificateRequest()
  • x509.CreateRevocationList()
  • csr.CheckSignature()
  • cert.Verify(x509.VerifyOptions{})
  • builder.sign(private_key, hashes.SHA256())
  • csr.is_signature_valid
  • CertPathValidator.getInstance()
  • CertPathBuilder.getInstance()
  • cert.verify(issuer.getPublicKey())
  • certBuilder.build(contentSigner)
  • isSignatureValid()
  • InsecureSkipVerify: true
  • rejectUnauthorized: false
  • verify=False
  • ssl.CERT_NONE
  • check_hostname = False
  • NoopHostnameVerifier
  • TrustAllStrategy
  • InsecureTrustManagerFactory
  • NODE_TLS_REJECT_UNAUTHORIZED

XML-DSig / SAML

  • XML signature or encryption algorithm

In scope 2

  • http://www.w3.org/2000/09/xmldsig#rsa-sha1
  • http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256

Renamed imports are resolved

A function renamed on import is still recognised. Each local alias is rewritten to the name it was bound to before matching; line numbers stay the same, and such a finding is marked Renamed import.

from cryptography.hazmat.primitives.asymmetric import rsa as r key = r.generate_private_key(public_exponent=65537, key_size=2048) # found
LanguageForms resolved
Pythonimport x.y as z, from x.y import z as w
JavaScript and TypeScriptimport { a as b } from 'm', import * as m from 'm', const { a: b } = require('m'), promisify(generateKeyPair)
Goimport alias "crypto/rsa", also in a grouped import block
Javaimport static java.security.MessageDigest.getInstance (Java's only aliasing)

Imports and call sites

An import says what the codebase could reach, not what it does, so the report keeps imports apart from the locations.

KindWhat it isCounted as
Call siteA call, or an algorithm named in a string passed to oneA location, under its posture
Key materialA private key, public key or certificate in the treeA location; a committed private key is the most serious finding
ConfigurationA TLS cipher list, an SSH algorithm line, a JOSE algA location
ImportA module or package import, once per library per fileInventory, never a location
DependencyA manifest entry (pom.xml, package.json)Inventory, never a location

How a use is read

The scanner follows an object from the line that chooses the algorithm to the lines that use it, and reports each line with what it does there: encrypt, decrypt, sign, verify, digest, tag, keygen, keyderive, encapsulate, decapsulate (key transport) or generate (random numbers).

Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); // RSA-OAEP-SHA256, decapsulate cipher.init(Cipher.UNWRAP_MODE, privateKey); Key key = cipher.unwrap(wrapped, "AES", Cipher.SECRET_KEY); // RSA-OAEP-SHA256, decapsulate

Direction. A two-way algorithm named where nothing is done with it (case Algorithm.AES:, alg = RS256) reports both directions, narrowed by the operations in the same method, then the method's name (decrypt(..)), then the uses of a private constant, then the file.

Values fixed elsewhere. A name is resolved to the literals the code fixes, also across files:

The algorithm isExample
A constant in the fileCipher.getInstance(TRANSFORMATION)
Another file's constantproviders.put(CryptoConstants.RSA_OAEP, ..)
A field every construction setsCipher.getInstance(jcaAlgorithmName), with new Provider("RSA/ECB/PKCS1Padding") elsewhere
A parameter its callers pass literalsgetInstance(algorithm), called as getInstance("SHA-256")
A method that only returns literalsCipher.getInstance(getWrapAlgorithm(alg))
An option of the calljwtVerify(token, key, { algorithms: ['ES256'] })

What a key, a header or a configuration decides at run time is still reported, with the algorithm not determined. A token, certificate or SSH signature whose algorithm is the key's is JWS, JWE, X.509 or SSH. A bundled implementation (class Blake2bDigest) is reported once, where it is defined; a wrapper around a library is not reported again.

Quantum posture

Shor's algorithm breaks every public-key algorithm in wide use; Grover's algorithm halves a symmetric key's strength. The first needs a replacement, the second a parameter change.

StateContainsWhat it means
Quantum-vulnerable RSA, DH, DSA, ECDSA, ECDH, EdDSA, X25519, X448, ECIES, ElGamal, secp256k1 A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. A larger key does not help.
Reduced margin AES-128, AES-192, SHA-224, SHA-256, SHA3-256 A quantum computer weakens this but does not break it. Increasing the key or digest size restores the margin.
Quantum-safe ML-KEM, ML-DSA, SLH-DSA, HQC, LMS, XMSS, AES-256, SHA-384, SHA-512, SHA-3, ChaCha20-Poly1305, HMAC No known quantum attack changes how strong this is.
Already broken MD5, SHA-1, DES, 3DES, RC4, Blowfish, PKCS#1 v1.5 encryption This is already unsafe today, with no quantum computer involved. These need fixing now.
Could not be determined getInstance(key.getAlgorithm()), generateKeyPair(kind) The algorithm could not be established from the source. Usually it is selected while the program runs, but it may equally be that the call gives no clue, or that it is decided somewhere this scan does not reach. Somebody has to check.

HNDL is set for key establishment only. Key agreement and public-key encryption expose traffic recorded today; a forged signature does not reveal anything recorded earlier. It follows the use: RS256 and an X.509 certificate are not marked, though both are RSA, and a key pair that could feed either keeps the mark.

Key sizes and curves

A key size is reported where the call, a PEM block or a named curve establishes it (secp384r1 is a 384-bit key), and never borrowed from a neighbouring line. An RSA modulus below the 2048-bit floor of NIST SP 800-57 is reported as already broken.

What the report counts

NumberWhat it counts
Cryptographic locationsEvery call site, key, certificate and configuration entry, by posture. The inventory.
To addressThe locations that need a decision.
Key establishmentLocations that expose traffic recorded today. These come first.
Imported librariesWhat the codebase can reach, held apart from the locations.

There is no readiness score: one was published until 5.9.0 and withdrawn, because readiness depends on what the data is worth and how long it must stay secret, which the source does not show.

CBOM output

CycloneDX 1.7 (ECMA-424, second edition), checked against the official 1.7 JSON schema: specification, release notes.

FieldWhat Crypto-View puts there
metadata.componentThe repository. On this site with a vcs reference to the exact commit and the branch, commit, subject and date as properties; from the command line, the folder's name.
components[]One cryptographic-asset per algorithm, curve, key size and set of operations: algorithm, certificate, protocol or related-crypto-material.
cryptoFunctionsWhat the code does at that component's locations. RSA used to generate keys, to sign and to decrypt is three components.
algorithmFamily, ellipticCurveValues from the 1.7 registries (RSAES-OAEP, secg/secp256r1); 1.6's free-text curve is kept alongside.
nistQuantumSecurityLevelThe NIST post-quantum category, 1 to 5, or 0.
evidence.occurrences[]Every location: file, line, rule and CWE.
properties[]Under qcomply:: posture, HNDL, rule, confidence and the plain explanation.

Each bom-ref is derived from the asset it names, so two scans of the same commit can be compared line by line.

Command-line tool

A single Python file that needs Python 3.9 or newer and nothing else. The scan itself makes no external call.

curl -fsSL https://cryptoview.qcomply.tech/install.sh | sh

Installs to ~/.local/bin (/usr/local/bin as root; CRYPTO_VIEW_INSTALL_DIR to change it) after checking the published SHA-256. Or download crypto-view.pyz and run python3 crypto-view.pyz.

What uses the network

WhatWhen
ScanningNever. No telemetry, no rule fetching, no call home.
Reporting to a QComply accountOnly with a token (QCOMPLY_TOKEN or --token); --no-report skips it for one run.
crypto-view updateOnly when you type it. The download is checked against the published SHA-256.

Options

CommandWhat it does
crypto-view [PATH]Scan a directory (default: the current one) and print the findings.
--versionThe installed version.
crypto-view update
crypto-view update --check
Replace the installed copy with the current release, or only say whether one exists. A download that does not match its SHA-256 replaces nothing. (Added in 5.4.0; on an older copy, run the installer again.)
--json FILEWrite the CycloneDX 1.7 CBOM; - for stdout.
--sarif FILEWrite SARIF 2.1.0, for code-scanning dashboards and editors.
--codequality FILEWrite a Code Quality report (Code Climate format), for merge request reviews.
--markdown FILEWrite a Markdown summary, for a CI job summary.
--fail-on SELECTORExit 1 when a finding matches, e.g. "hndl posture=vulnerable". Repeat for alternatives.
--policy FILENamed gates from a policy file (below).
--newShow, and gate on, only what is new since the last --new run here, or since --baseline (below).
--state-dir DIR
--no-state
Where --new keeps its record (default .crypto-view), or compare without recording.
crypto-view historyThe posture over the recorded runs; --json for a script.
--baseline FILE
--write-baseline FILE
Fail only on findings absent from the baseline; record one.
--custom-rules FILE
--no-custom-rules
Your own cryptographic functions (default: crypto-view.custom.json in the scan root, below), or ignore that file.
--include GLOB
--exclude GLOB
Narrow the walk. Repeatable.
--follow-symlinksFollow symbolic links. Off by default.
--include-testsAlso scan test, fixture and example files, skipped by default.
--include-commentsAlso report algorithms named only in comments and prose, marked as such.
--allPrint every finding rather than the first 60.
--quietOne summary line.
--explain RULE
--define TERM
One rule in full, or the explanation of a term.
--list-rules
--languages
The catalogue, and the supported languages and libraries.
--no-colorNo ANSI colour (also NO_COLOR, or a non-terminal stdout).
--token TOKEN
--qcomply-url URL
Report to a QComply account. Prefer QCOMPLY_TOKEN: a token on the command line shows in the process table and CI logs.
--no-reportDo not report on this run, even with a token.
--no-snippets
--host NAME
--path-label PATH
When reporting: leave out the source lines, or file the codebase under another host or folder.

Exit codes: 0 completed, 1 a gate failed, 2 the scan could not run, 3 the report to QComply could not be delivered.

Only what is new

crypto-view . --new Since 2026-10-27 09:12:40 UTC (commit 4f1c2a9e): 2 new, 1 fixed, 120 unchanged. quantum-vulnerable +1, key establishment +1.

Each --new run compares with the previous one in .crypto-view/ (never committed: it holds a .gitignore) and lists only the new findings. A finding that moved down the file is not new, and an engine update does not make old findings look new. The terminal, the Markdown summary and the gate take the new findings; the CBOM, SARIF and Code Quality reports stay complete, and SARIF marks each result new or unchanged. In CI, compare with a baseline the default branch wrote: --write-baseline, then --new --baseline FILE.

Selectors, policy file and baseline

SelectorMatches
hndlKey establishment and public-key encryption
posture=broken,vulnerableBy posture
primitive=key-agree,kemBy primitive
algorithm=RSA,ECDHBy algorithm
kind=call, language=javaCall sites only; by language

Terms in one selector must all match the same finding.

{ "version": 1, "gates": [ {"name": "No quantum-vulnerable key exchange", "when": ["hndl", "posture=vulnerable"], "message": "Recorded traffic is exposed retrospectively."}, {"name": "No broken primitives", "when": ["posture=broken"]} ] }

A baseline lets an existing codebase adopt the gate: record today's findings with --write-baseline crypto-view-baseline.json, commit it, and pass --baseline; only new findings then fail the build.

Your own cryptographic functions

{ "version": 1, "functions": [ {"id": "my-own-crypto", "name": "my_own_crypto", "language": "python", "quantum_safe": false, "primitive": "kem", "symbols": ["my_own_crypto", "crypto_utils.wrap_key"], "remediation": "Use ML-KEM-768 through the platform crypto service."} ] }

Required: id (rule custom.<id>), and quantum_safe or posture. Optional: name, symbols, patterns, primitive (a kem counts as key establishment), language, hndl, description, remediation. Each call site is reported like a catalogue finding.

Visual Studio Code

The extension runs the same engine on the developer's machine, with nothing leaving it: findings in the Problems panel, the posture in the side bar, a hover that explains each finding, a quick fix that suppresses one with a reason, and only what is new since a recorded baseline. It is delivered as a VSIX with QComply and needs Python 3.9 or newer.

Suppressing a finding

A reviewed finding is suppressed with a comment on its line or the line above. Suppressed findings are still counted in the summary.

// crypto-view: ignore[java.cipher] legacy partner interop, tracked in SEC-4127 Cipher.getInstance("RSA/ECB/PKCS1Padding");

Limits