Crypto-View

smallstep/certificates

Cryptographic posture

536 cryptographic locations: 54 already broken, 225 quantum-vulnerable, 51 reduced-margin, 187 undetermined, 19 quantum-safe

88 establish keys, so traffic protected by them and recorded today becomes readable once the algorithm falls. 1 imported cryptographic library is listed separately. 215 files analysed.

Quantum-vulnerable 225 Already broken 54 Reduced margin 51 Could not be determined 187 Quantum-safe 19
To address310
Key establishment88
Inventory only1
Total findings537
What was analysed
Branch master
Commit d47c967ac9699e691dedcc2e437baf84bec13e4b Merge pull request #2807 from smallstep/dependabot/go_modules/go.step.sm/crypto-0.91.0
Committed 2026-10-23 09:40 UTC
Scanned 2026-10-23 11:21 UTC 27 days ago
Coverage 215 files, 183 go
265 test files not scanned

Earlier scans of this repository

4 scans · compare any two
0 to 1000 locations Already broken 87 → 54 (down 33) Quantum-vulnerable 948 → 225 (down 723) Reduced margin 23 → 51 (up 28) Could not be determined 181 → 187 (up 6) Quantum-safe 43 → 19 (down 24) The filled point is the scan you are reading.
Scanned Commit To address Key establishment
27 days ago this scan d47c967ac969 master 310 88
28 days ago edc665053e58 master 303 88 Compare
28 days ago edc665053e58 master 285 83 Compare
29 days ago b4518162981a 904 239 Compare

A repository is scanned again when someone asks: Run a fresh scan.

List of cryptographic assets

RSA-10241024-bit Already broken 33 places See details

X.509 certificate

A PEM certificate. The subject public-key algorithm and key size are read from the SubjectPublicKeyInfo structure, and the not-after date is reported so certificates that outlive the migration window are visible.

This is a digital identity document. Its expiry date matters: one valid for many years locks in today's algorithms for that long.

What to do. Shorten certificate lifetimes so re-issuing with a post-quantum key is routine.

  1. authority/provisioner/aws_certificates.pem:6 -----BEGIN CERTIFICATE-----
  2. authority/provisioner/aws_certificates.pem:27 -----BEGIN CERTIFICATE-----
  3. authority/provisioner/aws_certificates.pem:48 -----BEGIN CERTIFICATE-----
  4. authority/provisioner/aws_certificates.pem:69 -----BEGIN CERTIFICATE-----
  5. authority/provisioner/aws_certificates.pem:90 -----BEGIN CERTIFICATE-----
  6. authority/provisioner/aws_certificates.pem:106 -----BEGIN CERTIFICATE-----
  7. authority/provisioner/aws_certificates.pem:123 -----BEGIN CERTIFICATE-----
  8. authority/provisioner/aws_certificates.pem:139 -----BEGIN CERTIFICATE-----
  9. authority/provisioner/aws_certificates.pem:161 -----BEGIN CERTIFICATE-----
  10. authority/provisioner/aws_certificates.pem:182 -----BEGIN CERTIFICATE-----
  11. authority/provisioner/aws_certificates.pem:203 -----BEGIN CERTIFICATE-----
  12. authority/provisioner/aws_certificates.pem:224 -----BEGIN CERTIFICATE-----
  13. authority/provisioner/aws_certificates.pem:240 -----BEGIN CERTIFICATE-----
  14. authority/provisioner/aws_certificates.pem:261 -----BEGIN CERTIFICATE-----
  15. authority/provisioner/aws_certificates.pem:277 -----BEGIN CERTIFICATE-----
  16. authority/provisioner/aws_certificates.pem:298 -----BEGIN CERTIFICATE-----
  17. authority/provisioner/aws_certificates.pem:319 -----BEGIN CERTIFICATE-----
  18. authority/provisioner/aws_certificates.pem:335 -----BEGIN CERTIFICATE-----
  19. authority/provisioner/aws_certificates.pem:351 -----BEGIN CERTIFICATE-----
  20. authority/provisioner/aws_certificates.pem:367 -----BEGIN CERTIFICATE-----
  21. authority/provisioner/aws_certificates.pem:383 -----BEGIN CERTIFICATE-----
  22. authority/provisioner/aws_certificates.pem:399 -----BEGIN CERTIFICATE-----
  23. authority/provisioner/aws_certificates.pem:420 -----BEGIN CERTIFICATE-----
  24. authority/provisioner/aws_certificates.pem:441 -----BEGIN CERTIFICATE-----
  25. authority/provisioner/aws_certificates.pem:457 -----BEGIN CERTIFICATE-----
  26. authority/provisioner/aws_certificates.pem:478 -----BEGIN CERTIFICATE-----
  27. authority/provisioner/aws_certificates.pem:499 -----BEGIN CERTIFICATE-----
  28. authority/provisioner/aws_certificates.pem:515 -----BEGIN CERTIFICATE-----
  29. authority/provisioner/aws_certificates.pem:536 -----BEGIN CERTIFICATE-----
  30. authority/provisioner/aws_certificates.pem:557 -----BEGIN CERTIFICATE-----
  31. authority/provisioner/aws_certificates.pem:578 -----BEGIN CERTIFICATE-----
  32. authority/provisioner/aws_certificates.pem:599 -----BEGIN CERTIFICATE-----
  33. authority/provisioner/aws_certificates.pem:620 -----BEGIN CERTIFICATE-----
pem.certificate
RSAES-PKCS1v15 Already broken Recorded traffic 7 places See details

Weak algorithm inside a TLS cipher suite

A suite whose key exchange is RSA key transport (`TLS_RSA_WITH_*`: no forward secrecy, so one key decrypts every recorded session) or whose bulk cipher is broken today - 3DES, RC4, DES, RC2, NULL or an export cipher.

This connection may use a cipher that is already unsafe, or a key exchange that lets one stolen key decrypt every recorded conversation.

What to do. Remove the suite. ECDHE suites with AES-GCM or ChaCha20-Poly1305, or TLS 1.3, replace it.

  1. authority/config/tls_options.go:121 "TLS_RSA_WITH_RC4_128_SHA": tls.TLS_RSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  2. authority/config/tls_options.go:122 "TLS_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
  3. authority/config/tls_options.go:123 "TLS_RSA_WITH_AES_128_CBC_SHA": tls.TLS_RSA_WITH_AES_128_CBC_SHA,
  4. authority/config/tls_options.go:124 "TLS_RSA_WITH_AES_256_CBC_SHA": tls.TLS_RSA_WITH_AES_256_CBC_SHA,
  5. authority/config/tls_options.go:125 "TLS_RSA_WITH_AES_128_CBC_SHA256": tls.TLS_RSA_WITH_AES_128_CBC_SHA256, // lgtm[go/insecure-tls]
  6. authority/config/tls_options.go:126 "TLS_RSA_WITH_AES_128_GCM_SHA256": tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
  7. authority/config/tls_options.go:127 "TLS_RSA_WITH_AES_256_GCM_SHA384": tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
config.cipher-suite.weak · CWE-757
RC4 Already broken 3 places See details

Weak algorithm inside a TLS cipher suite

A suite whose key exchange is RSA key transport (`TLS_RSA_WITH_*`: no forward secrecy, so one key decrypts every recorded session) or whose bulk cipher is broken today - 3DES, RC4, DES, RC2, NULL or an export cipher.

This connection may use a cipher that is already unsafe, or a key exchange that lets one stolen key decrypt every recorded conversation.

What to do. Remove the suite. ECDHE suites with AES-GCM or ChaCha20-Poly1305, or TLS 1.3, replace it.

  1. authority/config/tls_options.go:121 "TLS_RSA_WITH_RC4_128_SHA": tls.TLS_RSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  2. authority/config/tls_options.go:128 "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  3. authority/config/tls_options.go:131 "TLS_ECDHE_RSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
config.cipher-suite.weak · CWE-757
3DES Already broken 2 places See details

Weak algorithm inside a TLS cipher suite

A suite whose key exchange is RSA key transport (`TLS_RSA_WITH_*`: no forward secrecy, so one key decrypts every recorded session) or whose bulk cipher is broken today - 3DES, RC4, DES, RC2, NULL or an export cipher.

This connection may use a cipher that is already unsafe, or a key exchange that lets one stolen key decrypt every recorded conversation.

What to do. Remove the suite. ECDHE suites with AES-GCM or ChaCha20-Poly1305, or TLS 1.3, replace it.

  1. authority/config/tls_options.go:122 "TLS_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
  2. authority/config/tls_options.go:132 "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
config.cipher-suite.weak · CWE-757
DES-CBC Already broken 2 places See details

PKCS#7 / CMS enveloped data in Go

`pkcs7.Encrypt()` and a parsed message's `Decrypt(cert, key)`: the content key travels under RSA PKCS#1 v1.5, and the content is DES-CBC unless the code sets `pkcs7.ContentEncryptionAlgorithm` to an AES mode. SCEP servers use exactly this.

This code encrypts or opens a PKCS#7 envelope, the format certificate enrolment uses. Its key exchange is RSA, which a quantum computer breaks.

What to do. Set the content cipher to AES-256-GCM, and plan the RSA key transport as part of the migration: recorded enrolments are exposed by it.

  1. scep/authority.go:201 envelope, err := p7c.Decrypt(cert, decrypter)
  2. scep/authority.go:417 e7, err := pkcs7.Encrypt(content, recipients)
go.pkcs7 · CWE-327
RSAES-PKCS1v15 Already broken Recorded traffic 2 places See details

PKCS#7 / CMS enveloped data in Go

`pkcs7.Encrypt()` and a parsed message's `Decrypt(cert, key)`: the content key travels under RSA PKCS#1 v1.5, and the content is DES-CBC unless the code sets `pkcs7.ContentEncryptionAlgorithm` to an AES mode. SCEP servers use exactly this.

This code encrypts or opens a PKCS#7 envelope, the format certificate enrolment uses. Its key exchange is RSA, which a quantum computer breaks.

What to do. Set the content cipher to AES-256-GCM, and plan the RSA key transport as part of the migration: recorded enrolments are exposed by it.

  1. scep/authority.go:201 envelope, err := p7c.Decrypt(cert, decrypter)
  2. scep/authority.go:417 e7, err := pkcs7.Encrypt(content, recipients)
go.pkcs7 · CWE-327
3DES-CBC Already broken 1 place See details

PKCS#7 / CMS enveloped data in Go

`pkcs7.Encrypt()` and a parsed message's `Decrypt(cert, key)`: the content key travels under RSA PKCS#1 v1.5, and the content is DES-CBC unless the code sets `pkcs7.ContentEncryptionAlgorithm` to an AES mode. SCEP servers use exactly this.

This code encrypts or opens a PKCS#7 envelope, the format certificate enrolment uses. Its key exchange is RSA, which a quantum computer breaks.

What to do. Set the content cipher to AES-256-GCM, and plan the RSA key transport as part of the migration: recorded enrolments are exposed by it.

  1. scep/authority.go:201 envelope, err := p7c.Decrypt(cert, decrypter)
go.pkcs7 · CWE-327
SHA-1 Already broken 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. acme/challenge.go:1146 hash = crypto.SHA1
code.algorithm-constant
SHA-1 Already broken 1 place See details

Broken hash function

An import of `crypto/md5` or `crypto/sha1`, or a call to `New()` on either.

This is already unsafe today, with no quantum computer involved. SHAttered and subsequent work produced practical collisions; NIST withdrew SHA-1 in 2030 guidance and it is already unacceptable for signatures.

What to do. `crypto/sha256`, or `crypto/sha512` for long-lived signatures.

  1. authority/provisioner/collection.go:325 sum := sha1.Sum([]byte(p.GetID()))
go.hash.weak · CWE-328
SHA-1 Already broken 1 place See details

Call to code named for an algorithm

A call, construction or operation whose own name states the algorithm: a project's wrapper such as `Hash.sha256(data)`, `hmacSha256(key, msg)`, `getMD5()` or `new ScryptGenerator(..)`, a key type such as `new Ed25519PublicKey(bytes)`, or an operation on an object named for its algorithm, `sha256.digest()`. The library call inside the wrapper is reported where it is written; these are the places it is used.

This line calls code named after an encryption or hashing method.

What to do. Migrate the wrapper once, and these call sites follow it.

  1. cas/stepcas/issuer.go:23 return uuid.NewSHA1(raAuthorityNS, []byte(data))
code.named-call
TLS Quantum-vulnerable Recorded traffic 41 places See details

TLS cipher suite named in source

A cipher suite written into the code rather than into a configuration file - `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`, the OpenSSL spelling `ECDHE-RSA-AES128-GCM-SHA256`, or a TLS 1.3 suite. Each is reported as a setting of the TLS protocol and listed in its `cipherSuites`; RSA key transport and broken bulk ciphers are reported again, as `config.cipher-suite.weak`.

This code names the exact cryptography its TLS connections may use. Because the list is in the program rather than in a settings file, changing it needs a new release - which is the thing that makes a migration slow.

What to do. A hardcoded suite list ships with the binary and cannot be changed without a release, so move it to configuration first. The key exchange changes when the TLS library offers a hybrid group, not before.

  1. authority/config/tls_options.go:20 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
  2. authority/config/tls_options.go:21 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
  3. authority/config/tls_options.go:26 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
  4. authority/config/tls_options.go:27 "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
  5. authority/config/tls_options.go:28 "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
  6. authority/config/tls_options.go:29 "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
  7. authority/config/tls_options.go:30 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
  8. authority/config/tls_options.go:31 "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
  9. authority/config/tls_options.go:34 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
  10. authority/config/tls_options.go:35 "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
  11. authority/config/tls_options.go:36 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
  12. authority/config/tls_options.go:37 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
  13. authority/config/tls_options.go:121 "TLS_RSA_WITH_RC4_128_SHA": tls.TLS_RSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  14. authority/config/tls_options.go:122 "TLS_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
  15. authority/config/tls_options.go:123 "TLS_RSA_WITH_AES_128_CBC_SHA": tls.TLS_RSA_WITH_AES_128_CBC_SHA,
  16. authority/config/tls_options.go:124 "TLS_RSA_WITH_AES_256_CBC_SHA": tls.TLS_RSA_WITH_AES_256_CBC_SHA,
  17. authority/config/tls_options.go:125 "TLS_RSA_WITH_AES_128_CBC_SHA256": tls.TLS_RSA_WITH_AES_128_CBC_SHA256, // lgtm[go/insecure-tls]
  18. authority/config/tls_options.go:126 "TLS_RSA_WITH_AES_128_GCM_SHA256": tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
  19. authority/config/tls_options.go:127 "TLS_RSA_WITH_AES_256_GCM_SHA384": tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
  20. authority/config/tls_options.go:128 "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  21. authority/config/tls_options.go:129 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
  22. authority/config/tls_options.go:130 "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
  23. authority/config/tls_options.go:131 "TLS_ECDHE_RSA_WITH_RC4_128_SHA": tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA, // lgtm[go/insecure-tls]
  24. authority/config/tls_options.go:132 "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
  25. authority/config/tls_options.go:133 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
  26. authority/config/tls_options.go:134 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
  27. authority/config/tls_options.go:135 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, // lgtm[go/insecure-tls]
  28. authority/config/tls_options.go:136 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, // lgtm[go/insecure-tls]
  29. authority/config/tls_options.go:137 "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
  30. authority/config/tls_options.go:138 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
  31. authority/config/tls_options.go:139 "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
  32. authority/config/tls_options.go:140 "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
  33. authority/config/tls_options.go:141 "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256": tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
  34. authority/config/tls_options.go:142 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256": tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
  35. authority/config/tls_options.go:145 "TLS_AES_128_GCM_SHA256": tls.TLS_AES_128_GCM_SHA256,
  36. authority/config/tls_options.go:146 "TLS_AES_256_GCM_SHA384": tls.TLS_AES_256_GCM_SHA384,
  37. authority/config/tls_options.go:147 "TLS_CHACHA20_POLY1305_SHA256": tls.TLS_CHACHA20_POLY1305_SHA256,
  38. authority/config/tls_options.go:150 "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
  39. authority/config/tls_options.go:151 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
  40. scripts/install-step-ra.sh:227 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
  41. scripts/install-step-ra.sh:228 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
config.cipher-suite · CWE-757
TLS Quantum-vulnerable Recorded traffic 20 places See details

TLS configuration in code

A `tls.Config` field pinning versions, cipher suites or curve preferences. Every available suite negotiates a classical key exchange.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Every TLS cipher suite in general use negotiates a classical key exchange, so a recorded session is decryptable once that exchange falls.

What to do. Set `MinVersion: tls.VersionTLS13`. Go 1.24 enables the hybrid X25519MLKEM768 group by default, which is the single highest-value change available today.

  1. acme/challenge.go:242 config := &tls.Config{
  2. acme/client.go:59 TLSClientConfig: &tls.Config{
  3. authority/config/tls_options.go:42 CipherSuites: DefaultTLSCipherSuites,
  4. authority/config/tls_options.go:172 return &tls.Config{
  5. authority/config/tls_options.go:173 CipherSuites: t.CipherSuites.Value(),
  6. authority/http_client.go:47 tr.TLSClientConfig = &tls.Config{
  7. authority/linkedca.go:482 conn, err := grpc.NewClient(endpoint, grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{
  8. authority/linkedca.go:532 conn, err := grpc.NewClient(endpoint, grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{
  9. authority/linkedca.go:609 return cert, &tls.Config{
  10. ca/ca.go:634 serverTLSConfig = &tls.Config{
  11. ca/client.go:69 Transport: getDefaultTransport(&tls.Config{InsecureSkipVerify: true}),
  12. ca/client.go:258 t.TLSClientConfig = &tls.Config{
  13. ca/client.go:299 TLSClientConfig: &tls.Config{
  14. ca/client.go:421 return getDefaultTransport(&tls.Config{
  15. ca/client.go:439 return getDefaultTransport(&tls.Config{
  16. ca/client.go:450 return getDefaultTransport(&tls.Config{
  17. ca/identity/client.go:65 tr.TLSClientConfig = &tls.Config{
  18. ca/identity/identity.go:300 tr.TLSClientConfig = &tls.Config{
  19. ca/tls.go:63 Config: &tls.Config{
  20. ca/tls.go:295 return &tls.Config{
go.tls.config · CWE-757
RSA Quantum-vulnerable Recorded traffic 7 places See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. acme/api/middleware.go:163 if k.Size() < keyutil.MinRSAKeyBytes {
  2. acme/api/middleware.go:166 8*keyutil.MinRSAKeyBytes, keyutil.MinRSAKeyBytes))
  3. authority/provisioner/sign_options.go:95 return newPublicKeyMinimumLengthValidator(8 * keyutil.MinRSAKeyBytes).Valid(req)
  4. authority/provisioner/sign_ssh_options.go:363 case ssh.KeyAlgoRSA:
  5. authority/provisioner/sign_ssh_options.go:372 if key.Size() < keyutil.MinRSAKeyBytes {
  6. authority/provisioner/sign_ssh_options.go:374 8*keyutil.MinRSAKeyBytes, keyutil.MinRSAKeyBytes)
  7. cas/vaultcas/vaultcas.go:216 case x509.RSA:
code.algorithm-constant
ECDSA-P256256-bitsecg/secp256r1 Quantum-vulnerable 6 places See details

ECDSA in the Go standard library

`ecdsa.GenerateKey()` or `ecdsa.Sign*()`. The curve is read from the `elliptic.P###()` argument.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. ML-DSA-65 (FIPS 204).

  1. authority/linkedca.go:80 signer, err := keyutil.GenerateDefaultSigner()
  2. authority/provisioners.go:363 jwk, jwe, err := jose.GenerateDefaultKeyPair([]byte(password))
  3. authority/tls.go:891 priv, err := keyutil.GenerateDefaultKey()
  4. ca/client.go:1439 pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
  5. ca/client.go:1480 key, err := keyutil.GenerateDefaultKey()
  6. pki/pki.go:473 p.ottPublicKey, p.ottPrivateKey, err = jose.GenerateDefaultKeyPair(pass)
go.ecdsa · CWE-327
ECDSA-P256 Quantum-vulnerable 3 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:175 case jose.ES256, jose.ES384, jose.ES512, jose.EdDSA:
  2. acme/api/middleware.go:473 case jose.ES256:
  3. cas/stepcas/x5c_issuer.go:173 alg = jose.ES256
jose.algorithm · CWE-327
ECDSA-P384 Quantum-vulnerable 3 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:175 case jose.ES256, jose.ES384, jose.ES512, jose.EdDSA:
  2. acme/api/middleware.go:475 case jose.ES384:
  3. cas/stepcas/x5c_issuer.go:175 alg = jose.ES384
jose.algorithm · CWE-327
ECDSA-P521 Quantum-vulnerable 3 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:175 case jose.ES256, jose.ES384, jose.ES512, jose.EdDSA:
  2. acme/api/middleware.go:477 case jose.ES512:
  3. cas/stepcas/x5c_issuer.go:177 alg = jose.ES512
jose.algorithm · CWE-327
TLS Quantum-vulnerable Recorded traffic 3 places See details

TLS used in code

A TLS connection, context or setting made in code: `SSLContexts.createDefault()`, `SSLSocketFactory.getDefault()`, `setEnabledProtocols()`, `setEnabledCipherSuites()`, `startHandshake()`, Go `tls.VersionTLS12` and `tls.Dial()`, Python `ssl.create_default_context()`, Node `tls.connect()`, and version names such as `"TLSv1.2"`. Every TLS key exchange in general use is classical, so recorded traffic is exposed.

This code opens or configures an encrypted connection. Its key exchange is the part a future quantum computer breaks, which exposes traffic recorded today.

What to do. TLS 1.3 everywhere, then a hybrid group such as X25519MLKEM768 as the platform offers it.

  1. acme/client.go:80 return tls.DialWithDialer(c.dialer, network, addr, config)
  2. ca/bootstrap.go:191 return tls.NewListener(inner, tlsConfig), nil
  3. ca/tls.go:228 return tls.DialWithDialer(d, network, addr, tlsCtx.mutableConfig.TLSConfig())
tls.protocol · CWE-757
ECDSA384-bitsecg/secp384r1 Quantum-vulnerable 2 places See details

X.509 certificate

A PEM certificate. The subject public-key algorithm and key size are read from the SubjectPublicKeyInfo structure, and the not-after date is reported so certificates that outlive the migration window are visible.

This is a digital identity document. Its expiry date matters: one valid for many years locks in today's algorithms for that long.

What to do. Shorten certificate lifetimes so re-issuing with a post-quantum key is routine.

  1. acme/challenge.go:1293 -----BEGIN CERTIFICATE-----
  2. acme/challenge.go:1431 -----BEGIN CERTIFICATE-----
pem.certificate
ECDSA-P256256-bitsecg/secp256r1 Quantum-vulnerable 2 places See details

Certificate signed or verified

A certificate or signing request is signed - `x509.CreateCertificate()`, a pyca `builder.sign()`, a Bouncy Castle `certBuilder.build(signer)` - or its signature or chain is checked: `CheckSignature()`, `Verify(x509.VerifyOptions{})`, `CertPathValidator`, `is_signature_valid`. The algorithm is the signing key's.

This code puts a signature on a digital identity document, or checks one.

What to do. Find the key behind the signature. Issuing certificates is where an ML-DSA key eventually goes, and the relying parties that verify them have to accept it first.

  1. authority/linkedca.go:84 csr, err := x509util.CreateCertificateRequest(claims.Subject, claims.SANs, signer)
  2. ca/client.go:1460 csr, err := x509.CreateCertificateRequest(rand.Reader, template, pk)
x509.signature
Ed25519255-bitother/Ed25519 Quantum-vulnerable 2 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:175 case jose.ES256, jose.ES384, jose.ES512, jose.EdDSA:
  2. cas/stepcas/x5c_issuer.go:182 alg = jose.EdDSA
jose.algorithm · CWE-327
RSA2048-bit Quantum-vulnerable 2 places See details

X.509 certificate

A PEM certificate. The subject public-key algorithm and key size are read from the SubjectPublicKeyInfo structure, and the not-after date is reported so certificates that outlive the migration window are visible.

This is a digital identity document. Its expiry date matters: one valid for many years locks in today's algorithms for that long.

What to do. Shorten certificate lifetimes so re-issuing with a post-quantum key is routine.

  1. acme/challenge.go:1639 -----BEGIN CERTIFICATE-----
  2. acme/challenge.go:1661 -----BEGIN CERTIFICATE-----
pem.certificate
RSA Quantum-vulnerable Recorded traffic 2 places See details

Public key parsed or encoded

`x509.ParsePKIXPublicKey()`, `x509.ParsePKCS1PublicKey()` and their `Marshal` counterparts. PKCS#1 is RSA; PKIX says nothing, so the algorithm is read from a type switch on the key a few lines up where there is one. Certificates themselves are `x509.certificate` and `x509.signature`.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. Inventory only. The key's algorithm migrates with whatever signs or encrypts with it.

  1. cas/cloudcas/certificate.go:101 Bytes: x509.MarshalPKCS1PublicKey(key),
  2. internal/cryptoutil/cryptoutil.go:52 b, err := x509.MarshalPKIXPublicKey(key)
go.x509
RSASSA-PKCS1-SHA256 Quantum-vulnerable 2 places See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. authority/provisioner/aws.go:63 const awsSignatureAlgorithm = x509.SHA256WithRSA
  2. cas/softcas/softcas.go:289 case x509.SHA256WithRSA, x509.SHA384WithRSA, x509.SHA512WithRSA:
code.algorithm-constant
TLS-1.0 Quantum-vulnerable Recorded traffic 2 places See details

TLS used in code

A TLS connection, context or setting made in code: `SSLContexts.createDefault()`, `SSLSocketFactory.getDefault()`, `setEnabledProtocols()`, `setEnabledCipherSuites()`, `startHandshake()`, Go `tls.VersionTLS12` and `tls.Dial()`, Python `ssl.create_default_context()`, Node `tls.connect()`, and version names such as `"TLSv1.2"`. Every TLS key exchange in general use is classical, so recorded traffic is exposed.

This code opens or configures an encrypted connection. Its key exchange is the part a future quantum computer breaks, which exposes traffic recorded today.

What to do. TLS 1.3 everywhere, then a hybrid group such as X25519MLKEM768 as the platform offers it.

  1. authority/config/tls_options.go:70 case tls.VersionTLS10:
  2. authority/config/tls_options.go:88 1.0: tls.VersionTLS10,
tls.protocol · CWE-757
TLS-1.1 Quantum-vulnerable Recorded traffic 2 places See details

TLS used in code

A TLS connection, context or setting made in code: `SSLContexts.createDefault()`, `SSLSocketFactory.getDefault()`, `setEnabledProtocols()`, `setEnabledCipherSuites()`, `startHandshake()`, Go `tls.VersionTLS12` and `tls.Dial()`, Python `ssl.create_default_context()`, Node `tls.connect()`, and version names such as `"TLSv1.2"`. Every TLS key exchange in general use is classical, so recorded traffic is exposed.

This code opens or configures an encrypted connection. Its key exchange is the part a future quantum computer breaks, which exposes traffic recorded today.

What to do. TLS 1.3 everywhere, then a hybrid group such as X25519MLKEM768 as the platform offers it.

  1. authority/config/tls_options.go:72 case tls.VersionTLS11:
  2. authority/config/tls_options.go:89 1.1: tls.VersionTLS11,
tls.protocol · CWE-757
ECDSA Quantum-vulnerable 1 place See details

ECDSA in the Go standard library

`ecdsa.GenerateKey()` or `ecdsa.Sign*()`. The curve is read from the `elliptic.P###()` argument.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. ML-DSA-65 (FIPS 204).

  1. acme/challenge.go:1800 if !ecdsa.VerifyASN1(pub, sum[:], sig) {
go.ecdsa · CWE-327
ECDSA Quantum-vulnerable 1 place See details

Public key parsed or encoded

`x509.ParsePKIXPublicKey()`, `x509.ParsePKCS1PublicKey()` and their `Marshal` counterparts. PKCS#1 is RSA; PKIX says nothing, so the algorithm is read from a type switch on the key a few lines up where there is one. Certificates themselves are `x509.certificate` and `x509.signature`.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. Inventory only. The key's algorithm migrates with whatever signs or encrypts with it.

  1. cas/cloudcas/certificate.go:85 asn1Bytes, err := x509.MarshalPKIXPublicKey(key)
go.x509
ECDSA Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/vaultcas/vaultcas.go:218 case x509.ECDSA:
code.algorithm-constant
ECDSA256-bitsecg/secp256r1 Quantum-vulnerable 1 place See details

Public key file

A PEM public-key block. The algorithm is read from the SubjectPublicKeyInfo.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. Inventory only; a public key is not itself a secret.

  1. cosign.pub:1 -----BEGIN PUBLIC KEY-----
pem.public-key
ECDSA-P256 Quantum-vulnerable 1 place See details

COSE algorithm identifier

A COSE algorithm named as an identifier or as its IANA registry number - `COSEAlgorithmIdentifier.ES256`, or `alg: -7` in a WebAuthn `pubKeyCredParams`. The names match JOSE's; the numbers are the registry's.

This is the list of signature algorithms a security key or a passkey is allowed to use. Every one available today is broken by a quantum computer, so the value of writing it down now is knowing where to look later.

What to do. No post-quantum COSE algorithm is registered for WebAuthn yet. Record the exposure and keep the list short, so there is less to change when one is.

  1. acme/challenge.go:1009 coseAlgES256 = coseAlgorithmIdentifier(-7)
cose.algorithm
ECDSA-P256256-bitsecg/secp256r1 Quantum-vulnerable 1 place See details

Key type chosen by a setting

A named curve written as a string - `elliptic_curve="secp256r1"`, `"P-384"` in a list of accepted curves - or an RSA key size in a setting that names RSA (`rsa_key_size=2048`). The curve is reported as ECDSA where the file signs, ECDH where it agrees keys, and EC where it does both or neither.

This setting picks the kind of key the software makes.

What to do. The setting is where the key type changes; keep the list short so a post-quantum option can be added in one place.

code.curve
ECDSA-P384384-bitsecg/secp384r1 Quantum-vulnerable 1 place See details

Key type chosen by a setting

A named curve written as a string - `elliptic_curve="secp256r1"`, `"P-384"` in a list of accepted curves - or an RSA key size in a setting that names RSA (`rsa_key_size=2048`). The curve is reported as ECDSA where the file signs, ECDH where it agrees keys, and EC where it does both or neither.

This setting picks the kind of key the software makes.

What to do. The setting is where the key type changes; keep the list short so a post-quantum option can be added in one place.

code.curve
ECDSA-P521521-bitsecg/secp521r1 Quantum-vulnerable 1 place See details

Key type chosen by a setting

A named curve written as a string - `elliptic_curve="secp256r1"`, `"P-384"` in a list of accepted curves - or an RSA key size in a setting that names RSA (`rsa_key_size=2048`). The curve is reported as ECDSA where the file signs, ECDH where it agrees keys, and EC where it does both or neither.

This setting picks the kind of key the software makes.

What to do. The setting is where the key type changes; keep the list short so a post-quantum option can be added in one place.

code.curve
ECDSA-SHA256 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. ca/client.go:1453 SignatureAlgorithm: x509.ECDSAWithSHA256,
code.algorithm-constant
Ed25519255-bitother/Ed25519 Quantum-vulnerable 1 place See details

Ed25519 in the Go standard library

`ed25519.GenerateKey()` or `ed25519.Sign()`.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. ML-DSA-65 (FIPS 204). Go 1.24 ships ML-DSA as `crypto/mldsa`.

  1. acme/challenge.go:1809 if !ed25519.Verify(pub, []byte(keyAuth), sig) {
go.ed25519 · CWE-327
Ed25519255-bitother/Ed25519 Quantum-vulnerable 1 place See details

Public key parsed or encoded

`x509.ParsePKIXPublicKey()`, `x509.ParsePKCS1PublicKey()` and their `Marshal` counterparts. PKCS#1 is RSA; PKIX says nothing, so the algorithm is read from a type switch on the key a few lines up where there is one. Certificates themselves are `x509.certificate` and `x509.signature`.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. Inventory only. The key's algorithm migrates with whatever signs or encrypts with it.

  1. authority/provisioner/nebula.go:350 pub = ed25519.PublicKey(c.PublicKey())
go.x509
Ed25519255-bitother/Ed25519 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/vaultcas/vaultcas.go:220 case x509.Ed25519:
code.algorithm-constant
RSA4096-bit Quantum-vulnerable 1 place See details

X.509 certificate

A PEM certificate. The subject public-key algorithm and key size are read from the SubjectPublicKeyInfo structure, and the not-after date is reported so certificates that outlive the migration window are visible.

This is a digital identity document. Its expiry date matters: one valid for many years locks in today's algorithms for that long.

What to do. Shorten certificate lifetimes so re-issuing with a post-quantum key is routine.

  1. acme/challenge.go:1399 -----BEGIN CERTIFICATE-----
pem.certificate
RSA Quantum-vulnerable Recorded traffic 1 place See details

Call to code named for an algorithm

A call, construction or operation whose own name states the algorithm: a project's wrapper such as `Hash.sha256(data)`, `hmacSha256(key, msg)`, `getMD5()` or `new ScryptGenerator(..)`, a key type such as `new Ed25519PublicKey(bytes)`, or an operation on an object named for its algorithm, `sha256.digest()`. The library call inside the wrapper is reported where it is written; these are the places it is used.

This line calls code named after an encryption or hashing method.

What to do. Migrate the wrapper once, and these call sites follow it.

  1. authority/provisioner/sign_ssh_options.go:368 key, err := sshParseRSAPublicKey(in)
code.named-call
RSA Quantum-vulnerable Recorded traffic 1 place See details

Private key parsed or encoded

`x509.ParsePKCS1PrivateKey()` (RSA), `x509.ParseECPrivateKey()` (EC), `x509.ParsePKCS8PrivateKey()` and their `Marshal` counterparts. The algorithm is read from the function, or from a type switch on the key a few lines up.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. Find where the key is stored. A private key that moves through code is a key that has to be re-issued when the algorithm changes.

  1. internal/cryptoutil/cryptoutil.go:61 b, err := x509.MarshalPKCS8PrivateKey(key)
go.private-key
RSASSA-PKCS1-SHA1 Quantum-vulnerable 1 place See details

COSE algorithm identifier

A COSE algorithm named as an identifier or as its IANA registry number - `COSEAlgorithmIdentifier.ES256`, or `alg: -7` in a WebAuthn `pubKeyCredParams`. The names match JOSE's; the numbers are the registry's.

This is the list of signature algorithms a security key or a passkey is allowed to use. Every one available today is broken by a quantum computer, so the value of writing it down now is knowing where to look later.

What to do. No post-quantum COSE algorithm is registered for WebAuthn yet. Record the exposure and keep the list short, so there is less to change when one is.

  1. acme/challenge.go:1011 coseAlgRS1 = coseAlgorithmIdentifier(-65535) // deprecated, but (still) often used in TPMs
cose.algorithm
RSASSA-PKCS1-SHA256 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer. The v1.5 signature scheme of RFC 8017 section 8.2 has no classical break of its own; RSA-PSS is preferred for new work, but the quantum exposure is the same for both.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PKCS1-SHA256 Quantum-vulnerable 1 place See details

COSE algorithm identifier

A COSE algorithm named as an identifier or as its IANA registry number - `COSEAlgorithmIdentifier.ES256`, or `alg: -7` in a WebAuthn `pubKeyCredParams`. The names match JOSE's; the numbers are the registry's.

This is the list of signature algorithms a security key or a passkey is allowed to use. Every one available today is broken by a quantum computer, so the value of writing it down now is knowing where to look later.

What to do. No post-quantum COSE algorithm is registered for WebAuthn yet. Record the exposure and keep the list short, so there is less to change when one is.

  1. acme/challenge.go:1010 coseAlgRS256 = coseAlgorithmIdentifier(-257)
cose.algorithm
RSASSA-PKCS1-SHA256 Quantum-vulnerable 1 place See details

RSA in the Go standard library

`rsa.GenerateKey()`, `rsa.SignPKCS1v15()`, `rsa.EncryptOAEP()` or an import of `crypto/rsa`.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer. The v1.5 signature scheme of RFC 8017 section 8.2 has no classical break of its own; RSA-PSS is preferred for new work, but the quantum exposure is the same for both.

What to do. ML-KEM-768 for encryption, ML-DSA-65 for signatures. Go 1.24 ships ML-KEM as `crypto/mlkem`.

  1. acme/challenge.go:1805 if err := rsa.VerifyPKCS1v15(pub, crypto.SHA256, sum[:], sig); err != nil {
go.rsa · CWE-327
RSASSA-PKCS1-SHA384 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer. The v1.5 signature scheme of RFC 8017 section 8.2 has no classical break of its own; RSA-PSS is preferred for new work, but the quantum exposure is the same for both.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PKCS1-SHA384 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/softcas/softcas.go:289 case x509.SHA256WithRSA, x509.SHA384WithRSA, x509.SHA512WithRSA:
code.algorithm-constant
RSASSA-PKCS1-SHA512 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer. The v1.5 signature scheme of RFC 8017 section 8.2 has no classical break of its own; RSA-PSS is preferred for new work, but the quantum exposure is the same for both.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PKCS1-SHA512 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/softcas/softcas.go:289 case x509.SHA256WithRSA, x509.SHA384WithRSA, x509.SHA512WithRSA:
code.algorithm-constant
RSASSA-PSS-SHA256 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PSS-SHA256 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/softcas/softcas.go:291 case x509.SHA256WithRSAPSS, x509.SHA384WithRSAPSS, x509.SHA512WithRSAPSS:
code.algorithm-constant
RSASSA-PSS-SHA384 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PSS-SHA384 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/softcas/softcas.go:291 case x509.SHA256WithRSAPSS, x509.SHA384WithRSAPSS, x509.SHA512WithRSAPSS:
code.algorithm-constant
RSASSA-PSS-SHA512 Quantum-vulnerable 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer of sufficient size breaks this completely. It has to be replaced, not tuned. Broken by Shor's algorithm on a cryptographically relevant quantum computer.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/middleware.go:159 case jose.RS256, jose.RS384, jose.RS512, jose.PS256, jose.PS384, jose.PS512:
jose.algorithm · CWE-327
RSASSA-PSS-SHA512 Quantum-vulnerable 1 place See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. cas/softcas/softcas.go:291 case x509.SHA256WithRSAPSS, x509.SHA384WithRSAPSS, x509.SHA512WithRSAPSS:
code.algorithm-constant
TLS-1.2 Quantum-vulnerable 17 places See details

TLS used in code

A TLS connection, context or setting made in code: `SSLContexts.createDefault()`, `SSLSocketFactory.getDefault()`, `setEnabledProtocols()`, `setEnabledCipherSuites()`, `startHandshake()`, Go `tls.VersionTLS12` and `tls.Dial()`, Python `ssl.create_default_context()`, Node `tls.connect()`, and version names such as `"TLSv1.2"`. Every TLS key exchange in general use is classical, so recorded traffic is exposed.

This code opens or configures an encrypted connection. Its key exchange is the part a future quantum computer breaks, which exposes traffic recorded today.

What to do. TLS 1.3 everywhere, then a hybrid group such as X25519MLKEM768 as the platform offers it.

  1. acme/challenge.go:247 MinVersion: tls.VersionTLS12,
  2. authority/config/tls_options.go:12 DefaultTLSMinVersion = TLSVersion(1.2)
  3. authority/config/tls_options.go:74 case tls.VersionTLS12:
  4. authority/config/tls_options.go:90 1.2: tls.VersionTLS12,
  5. authority/http_client.go:48 MinVersion: tls.VersionTLS12,
  6. authority/linkedca.go:533 MinVersion: tls.VersionTLS12,
  7. authority/linkedca.go:610 MinVersion: tls.VersionTLS12,
  8. ca/ca.go:635 MinVersion: tls.VersionTLS12,
  9. ca/client.go:259 MinVersion: tls.VersionTLS12,
  10. ca/client.go:300 MinVersion: tls.VersionTLS12,
  11. ca/client.go:422 MinVersion: tls.VersionTLS12,
  12. ca/client.go:440 MinVersion: tls.VersionTLS12,
  13. ca/client.go:451 MinVersion: tls.VersionTLS12,
  14. ca/identity/client.go:66 MinVersion: tls.VersionTLS12,
  15. ca/identity/identity.go:303 MinVersion: tls.VersionTLS12,
  16. ca/tls.go:64 MinVersion: tls.VersionTLS12,
  17. ca/tls.go:296 MinVersion: tls.VersionTLS12,
tls.protocol · CWE-757
TLS-1.3 Quantum-vulnerable 4 places See details

TLS used in code

A TLS connection, context or setting made in code: `SSLContexts.createDefault()`, `SSLSocketFactory.getDefault()`, `setEnabledProtocols()`, `setEnabledCipherSuites()`, `startHandshake()`, Go `tls.VersionTLS12` and `tls.Dial()`, Python `ssl.create_default_context()`, Node `tls.connect()`, and version names such as `"TLSv1.2"`. Every TLS key exchange in general use is classical, so recorded traffic is exposed.

This code opens or configures an encrypted connection. Its key exchange is the part a future quantum computer breaks, which exposes traffic recorded today.

What to do. TLS 1.3 everywhere, then a hybrid group such as X25519MLKEM768 as the platform offers it.

  1. authority/config/tls_options.go:14 DefaultTLSMaxVersion = TLSVersion(1.3)
  2. authority/config/tls_options.go:76 case tls.VersionTLS13:
  3. authority/config/tls_options.go:86 0: tls.VersionTLS13,
  4. authority/config/tls_options.go:91 1.3: tls.VersionTLS13,
tls.protocol · CWE-757
PBES2-HS256+A128KW Reduced margin 4 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

A quantum computer weakens this but does not break it. Increasing the key or digest size restores the margin. Grover's algorithm halves the effective strength; the parameter, not the design, is the problem.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. authority/provisioners.go:363 jwk, jwe, err := jose.GenerateDefaultKeyPair([]byte(password))
  2. ca/provisioner.go:187 data, err := enc.Decrypt(password)
  3. cas/stepcas/jwk_issuer.go:125 b, err := jose.Decrypt([]byte(key),
  4. pki/pki.go:473 p.ottPublicKey, p.ottPrivateKey, err = jose.GenerateDefaultKeyPair(pass)
jose.algorithm · CWE-327
SHA-256 Reduced margin 4 places See details

Algorithm named by a constant

A library or project constant whose name is an algorithm, used in code: `JavaAlgorithm.SHA256`, `XMLCipher.AES_128`, Go `crypto.SHA256` and `x509.SHA256WithRSA`, `SignatureMethod.RSA_SHA256`. The holder's name has to say it holds algorithms, so an unrelated `Foo.AES` is left alone.

This line picks an algorithm by name.

What to do. The migration belongs to the operation that consumes the constant; this line is where the choice is written down.

  1. acme/account.go:52 kid, err := jwk.Thumbprint(crypto.SHA256)
  2. acme/challenge.go:1144 hash = crypto.SHA256
  3. acme/challenge.go:1805 if err := rsa.VerifyPKCS1v15(pub, crypto.SHA256, sum[:], sig); err != nil {
  4. acme/challenge.go:1909 thumbprint, err := jwk.Thumbprint(crypto.SHA256)
code.algorithm-constant
SHA-256 Reduced margin 2 places See details

Call to code named for an algorithm

A call, construction or operation whose own name states the algorithm: a project's wrapper such as `Hash.sha256(data)`, `hmacSha256(key, msg)`, `getMD5()` or `new ScryptGenerator(..)`, a key type such as `new Ed25519PublicKey(bytes)`, or an operation on an object named for its algorithm, `sha256.digest()`. The library call inside the wrapper is reported where it is written; these are the places it is used.

This line calls code named after an encryption or hashing method.

What to do. Migrate the wrapper once, and these call sites follow it.

  1. ca/bootstrap.go:41 return NewClient(claims.Audience[0], WithRootSHA256(claims.SHA))
  2. cas/stepcas/stepcas.go:46 client, err := ca.NewClient(opts.CertificateAuthority, ca.WithRootSHA256(opts.CertificateAuthorityFingerprint)) //nolint:contextcheck // deeply nested context
code.named-call
AES-CBC Reduced margin 1 place See details

PKCS#7 / CMS enveloped data in Go

`pkcs7.Encrypt()` and a parsed message's `Decrypt(cert, key)`: the content key travels under RSA PKCS#1 v1.5, and the content is DES-CBC unless the code sets `pkcs7.ContentEncryptionAlgorithm` to an AES mode. SCEP servers use exactly this.

This code encrypts or opens a PKCS#7 envelope, the format certificate enrolment uses. Its key exchange is RSA, which a quantum computer breaks.

What to do. Set the content cipher to AES-256-GCM, and plan the RSA key transport as part of the migration: recorded enrolments are exposed by it.

  1. scep/authority.go:201 envelope, err := p7c.Decrypt(cert, decrypter)
go.pkcs7 · CWE-327
AES-GCM Reduced margin 1 place See details

PKCS#7 / CMS enveloped data in Go

`pkcs7.Encrypt()` and a parsed message's `Decrypt(cert, key)`: the content key travels under RSA PKCS#1 v1.5, and the content is DES-CBC unless the code sets `pkcs7.ContentEncryptionAlgorithm` to an AES mode. SCEP servers use exactly this.

This code encrypts or opens a PKCS#7 envelope, the format certificate enrolment uses. Its key exchange is RSA, which a quantum computer breaks.

What to do. Set the content cipher to AES-256-GCM, and plan the RSA key transport as part of the migration: recorded enrolments are exposed by it.

  1. scep/authority.go:201 envelope, err := p7c.Decrypt(cert, decrypter)
go.pkcs7 · CWE-327
SHA-256 Reduced margin 27 places See details

Hash function in Go

`sha256.Sum256()`, `sha512.New384()`, `sha3.Sum256()`, `blake2b.Sum256()` and the rest of the SHA-2, SHA-3 and BLAKE2 families. Grover halves the margin, which these digest sizes absorb.

This turns data into a fingerprint. Quantum computers do not meaningfully weaken it.

What to do. No action.

  1. acme/challenge.go:312 hashedKeyAuth := sha256.Sum256([]byte(keyAuth))
  2. acme/challenge.go:378 h := sha256.Sum256([]byte(expectedKeyAuth))
  3. acme/challenge.go:891 sum := sha256.Sum256([]byte(ch.Token))
  4. acme/challenge.go:1176 hashedKeyAuth := sha256.Sum256([]byte(keyAuth))
  5. acme/challenge.go:1201 if data.Fingerprint, err = keyutil.Fingerprint(publicKey); err != nil {
  6. acme/challenge.go:1378 if data.Fingerprint, err = keyutil.Fingerprint(leaf.PublicKey); err != nil {
  7. acme/challenge.go:1613 if data.Fingerprint, err = keyutil.Fingerprint(attCert.PublicKey); err != nil {
  8. acme/challenge.go:1780 if data.Fingerprint, err = keyutil.Fingerprint(leaf.PublicKey); err != nil {
  9. acme/challenge.go:1799 sum := sha256.Sum256([]byte(keyAuth))
  10. acme/challenge.go:1804 sum := sha256.Sum256([]byte(keyAuth))
  11. acme/order.go:198 fp, err := keyutil.Fingerprint(csr.PublicKey)
  12. authority/authority.go:486 sum := sha256.Sum256(crt.Raw)
  13. authority/authority.go:507 sum := sha256.Sum256(crt.Raw)
  14. authority/authorize.go:213 sum := sha256.Sum256([]byte(token))
  15. authority/linkedca.go:518 sum := sha256.Sum256(cert.Raw)
  16. authority/provisioner/aws.go:204 sum := sha256.Sum256([]byte(token))
  17. authority/provisioner/aws.go:210 sum := sha256.Sum256([]byte(unique))
  18. authority/provisioner/aws.go:266 sum := sha256.Sum256([]byte(unique))
  19. authority/provisioner/azure.go:165 sum := sha256.Sum256([]byte(claims.XMSMirID))
  20. authority/provisioner/gcp.go:143 sum := sha256.Sum256([]byte(token))
  21. authority/provisioner/gcp.go:157 sum := sha256.Sum256([]byte(unique))
  22. authority/provisioner/sign_options.go:531 sum := sha256.Sum256(cr.Raw)
  23. ca/ca.go:444 log.Printf("X.509 Root Fingerprint: %s", x509util.Fingerprint(crt))
  24. ca/client.go:739 sum := sha256.Sum256(root.RootPEM.Raw)
  25. ca/client.go:1424 return x509util.Fingerprint(lastChain[len(lastChain)-1]), nil
  26. cas/vaultcas/vaultcas.go:165 sum := sha256.Sum256(cert.root.Raw)
  27. pki/pki.go:569 sum := sha256.Sum256(rootCrt.Raw)
go.hash
X.509 Could not be determined 42 places See details

X.509 certificate handled in code

A certificate, signing request or revocation list loaded, parsed or created: `x509.load_pem_x509_certificate()`, `x509.ParseCertificate()`, `CertificateFactory.generateCertificate()`, `new X509Certificate()`. Certificates are the longest-lived cryptographic artefacts most systems own.

This code reads or builds a digital identity document. Its key, and how long it stays valid, decide when it has to be replaced.

What to do. Shorten certificate lifetimes now, so re-issuing with a post-quantum key is routine rather than an incident.

  1. acme/api/order.go:152 f.csr, err = x509.ParseCertificateRequest(csrBytes)
  2. acme/api/revoke.go:66 certToBeRevoked, err := x509.ParseCertificate(certBytes)
  3. acme/challenge.go:1035 akCert, err := x509.ParseCertificate(akCertBytes)
  4. acme/challenge.go:1046 intCert, err := x509.ParseCertificate(intCertBytes)
  5. acme/challenge.go:1328 root, err := pemutil.ParseCertificate([]byte(appleEnterpriseAttestationRootCA))
  6. acme/challenge.go:1348 leaf, err := x509.ParseCertificate(der)
  7. acme/challenge.go:1359 cert, err := x509.ParseCertificate(der)
  8. acme/challenge.go:1496 rsaRoot, err := pemutil.ParseCertificate([]byte(androidRSARootCA))
  9. acme/challenge.go:1500 ecdsaRoot, err := pemutil.ParseCertificate([]byte(androidECDSARootCA))
  10. acme/challenge.go:1526 cert, err := x509.ParseCertificate(der)
  11. acme/challenge.go:1701 pivRoot, err := pemutil.ParseCertificate([]byte(yubicoPIVRootCA))
  12. acme/challenge.go:1705 attRoot, err := pemutil.ParseCertificate([]byte(yubicoAttestationRootCA))
  13. acme/challenge.go:1726 leaf, err := x509.ParseCertificate(der)
  14. acme/challenge.go:1736 cert, err := x509.ParseCertificate(der)
  15. acme/db/nosql/certificate.go:131 crt, err = x509.ParseCertificate(block.Bytes)
  16. api/api.go:133 cert, err := x509.ParseCertificate(block.Bytes)
  17. api/api.go:193 cr, err := x509.ParseCertificateRequest(block.Bytes)
  18. api/sshRenew.go:99 cert, err := x509.ParseCertificate(r.TLS.PeerCertificates[0].Raw)
  19. authority/authority.go:438 options.CertificateChain, err = pemutil.ReadCertificateBundle(a.config.IntermediateCert)
  20. authority/authority.go:478 crts, err := pemutil.ReadCertificateBundle(path)
  21. authority/authority.go:499 crts, err := pemutil.ReadCertificateBundle(path)
  22. authority/linkedca.go:512 cert, err := x509.ParseCertificate(block.Bytes)
  23. authority/linkedca.go:569 crt, err := x509.ParseCertificate(block.Bytes)
  24. authority/linkedca.go:591 leaf, err := x509.ParseCertificate(block.Bytes)
  25. authority/options.go:420 cert, err := x509.ParseCertificate(block.Bytes)
  26. authority/provisioner/acme.go:237 cert, err := x509.ParseCertificate(block.Bytes)
  27. authority/provisioner/aws.go:97 cert, err := x509.ParseCertificate(block.Bytes)
  28. authority/provisioner/scep.go:380 if s.decrypterCertificate, err = x509.ParseCertificate(block.Bytes); err != nil {
  29. authority/provisioner/x5c.go:116 cert, err := x509.ParseCertificate(block.Bytes)
  30. ca/acmeClient.go:349 cert, err := x509.ParseCertificate(block.Bytes)
  31. ca/ca.go:671 cert, err := x509.ParseCertificate(certBytes)
  32. ca/client.go:1464 cr, err := x509.ParseCertificateRequest(csr)
  33. ca/client.go:1530 cr, err := x509.ParseCertificateRequest(csr)
  34. ca/identity/identity.go:235 x509Cert, err := x509.ParseCertificate(crt.Certificate[0])
  35. cas/cloudcas/cloudcas.go:686 cert, err := x509.ParseCertificate(block.Bytes)
  36. cas/cloudcas/cloudcas.go:698 cr, err := x509.ParseCertificateRequest(block.Bytes)
  37. cas/stepcas/x5c_issuer.go:68 cert, err := pemutil.ReadCertificate(i.certFile, pemutil.WithFirstBlock())
  38. cas/stepcas/x5c_issuer.go:151 certs, err := pemutil.ReadCertificateBundle(certFile)
  39. cas/vaultcas/vaultcas.go:291 cert, err := x509.ParseCertificate(block.Bytes)
  40. ca/tls.go:283 leaf, err := x509.ParseCertificate(cert.Certificate[0])
  41. db/db.go:302 cert, err := x509.ParseCertificate(asn1Data)
  42. scep/authority.go:217 csr, err := x509.ParseCertificateRequest(msg.pkiEnvelope)
x509.certificate
JWS Could not be determined 24 places See details

Signed token created or verified

A JSON Web Signature or JWT is signed or verified with a key chosen at run time: go-jose `jose.NewSigner()`, `jose.Signed()`, `jws.Verify(key)`, `token.Claims(key, &out)`; josepy `JWS.sign()`; the `jose` npm package's `SignJWT` and `jwtVerify()`. Where the code names the `alg`, that is reported separately.

This code signs or checks a login token. Its algorithm is set by the key it is given.

What to do. Pin the accepted `alg` values, and keep token lifetimes short.

  1. acme/api/middleware.go:427 payload, err := jws.Verify(jwk)
  2. acme/api/middleware.go:503 data, err = jws.Verify(jwk)
  3. acme/api/middleware.go:543 data, err = jws.Verify(jwk)
  4. acme/api/revoke.go:100 _, err := jws.Verify(certToBeRevoked.PublicKey)
  5. acme/challenge.go:435 idToken, err := verifier.Verify(ctx, oidcPayload.IDToken)
  6. acme/challenge.go:676 if err = jwt.Claims(v.tokenKey, &accessToken); err != nil {
  7. acme/challenge.go:722 if err := dpopJWT.Claims(v.dpopKey, &wireDpop); err != nil {
  8. acme/challenge.go:750 if err := dpopJWT.Claims(v.dpopKey, &dpopToken); err != nil {
  9. authority/authorize.go:131 if err := jwt.Claims(leaf.PublicKey, &claims); err != nil {
  10. authority/authorize.go:421 if err := jwt.Claims(leaf.PublicKey, &claims); err != nil {
  11. authority/provisioner/aws.go:542 if err := jwt.Claims(unsafeClaims.Amazon.Signature, &payload); err != nil {
  12. authority/provisioner/azure.go:284 if err := jwt.Claims(key.Public(), &claims); err == nil {
  13. authority/provisioner/gcp.go:354 if err := jwt.Claims(key.Public(), &claims); err == nil {
  14. authority/provisioner/jwk.go:124 if err = jwt.Claims(p.Key, &claims); err != nil {
  15. authority/provisioner/k8sSA.go:181 if err = jwt.Claims(pk, &claims); err == nil {
  16. authority/provisioner/nebula.go:357 if err := jose.Verify(jwt, pub, &claims); err != nil {
  17. authority/provisioner/oidc.go:280 if err := jwt.Claims(key, &claims); err == nil {
  18. authority/provisioner/sshpop.go:162 if err = jwt.Claims(pubKey, &claims); err != nil {
  19. authority/provisioner/x5c.go:163 if err = jwt.Claims(leaf.PublicKey, &claims); err != nil {
  20. ca/acmeClient.go:174 signer, err := jose.NewSigner(jose.SigningKey{
  21. ca/acmeClient.go:181 signed, err := signer.Sign(payload)
  22. cas/stepcas/jwk_issuer.go:84 builder := jose.Signed(i.signer).Claims(claims)
  23. cas/stepcas/x5c_issuer.go:91 builder := jose.Signed(signer).Claims(claims)
  24. cas/stepcas/x5c_issuer.go:189 signer, err := jose.NewSigner(jose.SigningKey{Algorithm: alg, Key: key}, so)
jws.operation
X.509 Could not be determined 20 places See details

Certificate signed or verified

A certificate or signing request is signed - `x509.CreateCertificate()`, a pyca `builder.sign()`, a Bouncy Castle `certBuilder.build(signer)` - or its signature or chain is checked: `CheckSignature()`, `Verify(x509.VerifyOptions{})`, `CertPathValidator`, `is_signature_valid`. The algorithm is the signing key's.

This code puts a signature on a digital identity document, or checks one.

What to do. Find the key behind the signature. Issuing certificates is where an ML-DSA key eventually goes, and the relying parties that verify them have to accept it first.

  1. acme/api/order.go:156 if err = f.csr.CheckSignature(); err != nil {
  2. acme/challenge.go:1079 verifiedChains, err := akCert.Verify(x509.VerifyOptions{
  3. acme/challenge.go:1366 if _, err := leaf.Verify(x509.VerifyOptions{
  4. acme/challenge.go:1561 _, err := root.Verify(x509.VerifyOptions{
  5. acme/challenge.go:1570 chains, err := leaf.Verify(x509.VerifyOptions{
  6. acme/challenge.go:1742 if _, err := leaf.Verify(x509.VerifyOptions{
  7. api/rekey.go:22 if err := s.CsrPEM.CertificateRequest.CheckSignature(); err != nil {
  8. api/sign.go:30 if err := s.CsrPEM.CertificateRequest.CheckSignature(); err != nil {
  9. api/ssh.go:67 if err := s.IdentityCSR.CertificateRequest.CheckSignature(); err != nil {
  10. authority/provisioner/aws.go:418 if err := crt.CheckSignature(p.config.signatureAlgorithm, signed, signature); err == nil {
  11. authority/tls.go:134 if err := csr.CheckSignature(); err != nil {
  12. authority/tls.go:912 cr, err := x509util.CreateCertificateRequest(a.config.CommonName, sans, signer)
  13. ca/client.go:1468 if err := cr.CheckSignature(); err != nil {
  14. ca/client.go:1526 csr, err := x509.CreateCertificateRequest(rand.Reader, template, key)
  15. ca/client.go:1534 if err := cr.CheckSignature(); err != nil {
  16. cas/cloudcas/cloudcas.go:595 crt, err := x509util.CreateCertificate(template, req.Parent.Certificate, template.PublicKey, req.Parent.Signer)
  17. cas/softcas/softcas.go:154 revocationListBytes, err := x509.CreateRevocationList(rand.Reader, req.RevocationList, certChain[0], signer)
  18. cas/softcas/softcas.go:284 return x509util.CreateCertificate(template, parent, pub, signer)
  19. cas/vaultcas/vaultcas.go:327 return cert.CheckSignatureFrom(cert) == nil
  20. scep/authority.go:221 if err := csr.CheckSignature(); err != nil {
x509.signature
SSH Could not be determined 17 places See details

SSH implementation in use

`golang.org/x/crypto/ssh`: keys parsed or created, and signatures made or checked. The algorithm is the key's. Host keys are long-lived and awkward to rotate.

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. An SSH key or signature whose algorithm is the key's.

What to do. OpenSSH's `sntrup761x25519` hybrid key exchange addresses the recorded-traffic half; the host-key signature has no standardised replacement yet.

  1. api/ssh.go:125 pub, err := ssh.ParsePublicKey(certData)
  2. api/ssh.go:168 pub, err := ssh.ParsePublicKey(data)
  3. api/ssh.go:270 publicKey, err := ssh.ParsePublicKey(body.PublicKey)
  4. api/ssh.go:278 addUserPublicKey, err = ssh.ParsePublicKey(body.AddUserPublicKey)
  5. api/sshRekey.go:56 publicKey, err := ssh.ParsePublicKey(body.PublicKey)
  6. authority/authority.go:542 a.sshCAHostCertSignKey, err = ssh.NewSignerFromSigner(s)
  7. authority/authority.go:545 a.sshCAHostCertSignKey, err = ssh.NewSignerFromSigner(s)
  8. authority/authority.go:575 a.sshCAUserCertSignKey, err = ssh.NewSignerFromSigner(s)
  9. authority/authority.go:578 a.sshCAUserCertSignKey, err = ssh.NewSignerFromSigner(s)
  10. authority/config/ssh.go:77 key, err := ssh.NewPublicKey(k.Key.Key)
  11. authority/options.go:268 signer, err := ssh.NewSignerFromSigner(s)
  12. authority/options.go:284 signer, err := ssh.NewSignerFromSigner(s)
  13. authority/provisioner/sshpop.go:147 if err = (&ssh.Certificate{Key: k}).Verify(data, sshCert.Signature); err == nil {
  14. authority/provisioner/sshpop.go:260 sshPub, err := ssh.ParsePublicKey(sshCertBytes)
  15. authority/ssh.go:617 sig, err := signer.Sign(rand.Reader, data)
  16. pki/pki.go:681 sshKey, err := ssh.NewPublicKey(resp.PublicKey)
  17. pki/pki.go:710 sshKey, err = ssh.NewPublicKey(resp.PublicKey)
go.ssh · CWE-327
X.509 Could not be determined 5 places See details

Certificate verification disabled

TLS certificate or host-name verification switched off: `InsecureSkipVerify: true`, `rejectUnauthorized: false`, `verify=False`, `ssl.CERT_NONE`, `NoopHostnameVerifier`, `TrustAllStrategy`. Any key exchange is worthless when the peer is not authenticated, post-quantum or not.

This connection accepts any certificate, so it cannot tell the real server from an impostor.

What to do. Verify certificates. Pin a private CA through a trust store instead of switching verification off.

  1. acme/challenge.go:249 InsecureSkipVerify: true, //nolint:gosec // we expect a self-signed challenge certificate
  2. acme/client.go:61 InsecureSkipVerify: true, // lgtm[go/disabled-certificate-check]
  3. authority/linkedca.go:484 InsecureSkipVerify: true, // lgtm[go/disabled-certificate-check]
  4. ca/client.go:69 Transport: getDefaultTransport(&tls.Config{InsecureSkipVerify: true}),
  5. ca/client.go:302 InsecureSkipVerify: true,
x509.verification-disabled · CWE-295
unknown Could not be determined 3 places See details

Signature with whatever key the code holds, in Go

A PKCS#7 SignedData signed by `AddSigner(cert, signer, ..)`, or a TPM certification checked by go-attestation's `CertificationParameters.Verify(..)`. The algorithm is the key's - RSA or ECDSA - which the code does not name at this line.

This code signs, or checks a signature, with a key chosen elsewhere.

What to do. Find where the key is generated or loaded: that is what decides the algorithm, and what an ML-DSA migration changes.

  1. acme/challenge.go:1162 if err = certificationParameters.Verify(verifyOpts); err != nil {
  2. scep/authority.go:376 if err := signedData.AddSigner(signerCert, signer, config); err != nil {
  3. scep/authority.go:471 if err := signedData.AddSigner(signerCert, signer, config); err != nil {
go.key-signature · CWE-327
unknown Could not be determined 3 places See details

Public key parsed or encoded

`x509.ParsePKIXPublicKey()`, `x509.ParsePKCS1PublicKey()` and their `Marshal` counterparts. PKCS#1 is RSA; PKIX says nothing, so the algorithm is read from a type switch on the key a few lines up where there is one. Certificates themselves are `x509.certificate` and `x509.signature`.

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.

What to do. Inventory only. The key's algorithm migrates with whatever signs or encrypts with it.

  1. webhook/options.go:49 key, err := x509.MarshalPKIXPublicKey(cr.PublicKey)
  2. webhook/options.go:69 key, err := x509.MarshalPKIXPublicKey(leaf.PublicKey)
  3. webhook/options.go:131 key, err := x509.MarshalPKIXPublicKey(leaf.PublicKey)
go.x509
unknown Could not be determined 1 place See details

Cryptographic library in the dependency manifest

A dependency known to implement classical asymmetric cryptography. Its presence is inventory, not a finding about this codebase: the library may never be called with a quantum-vulnerable algorithm.

The project depends on a cryptography library. Listed so the inventory is complete; it is not by itself a problem.

What to do. Check the version. Several of these libraries have shipped ML-KEM and ML-DSA support since 2024, so the migration may need an upgrade rather than a replacement.

  1. go.mod:43 golang.org/x/crypto v0.58.0
dep.crypto-library
ML-DSA-65 Quantum-safe 3 places See details

Post-quantum algorithm in use

`crypto/mlkem` or `crypto/mldsa`, added in Go 1.24. Recorded so the inventory shows completed migration work.

This is already a quantum-safe algorithm.

What to do. None. Confirm the parameter set matches the required NIST category.

  1. acme/challenge.go:1812 case *mldsa.PublicKey:
  2. api/api.go:664 case *mldsa.PublicKey:
  3. internal/cryptoutil/cryptoutil.go:21 case *rsa.PublicKey, *ecdsa.PublicKey, ed25519.PublicKey, *mldsa.PublicKey:
go.pqc
CSPRNG Quantum-safe 2 places See details

Random number generation

`crypto/rand`. Recorded so the inventory names its randomness source. `math/rand` reaching key material would be a present-day defect, and is a different thing entirely.

This is where the software gets its random numbers. Quantum computers do not weaken it.

What to do. No action.

  1. acme/db/nosql/eab.go:67 _, err = rand.Read(random)
  2. authority/ssh.go:581 if err := binary.Read(rand.Reader, binary.BigEndian, &serial); err != nil {
go.rng
HMAC-SHA256 Quantum-safe 2 places See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

No known quantum attack changes how strong this is. A keyed MAC is not affected by Shor and only marginally by Grover.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/eab.go:134 if algorithm != jose.HS256 && algorithm != jose.HS384 && algorithm != jose.HS512 {
  2. authority/provisioner/aws.go:270 jose.SigningKey{Algorithm: jose.HS256, Key: signature},
jose.algorithm · CWE-327
HMAC-SHA256 Quantum-safe 2 places See details

Signed token created or verified

A JSON Web Signature or JWT is signed or verified with a key chosen at run time: go-jose `jose.NewSigner()`, `jose.Signed()`, `jws.Verify(key)`, `token.Claims(key, &out)`; josepy `JWS.sign()`; the `jose` npm package's `SignJWT` and `jwtVerify()`. Where the code names the `alg`, that is reported separately.

This code signs or checks a login token. Its algorithm is set by the key it is given.

What to do. Pin the accepted `alg` values, and keep token lifetimes short.

  1. authority/provisioner/aws.go:269 signer, err := jose.NewSigner(
  2. authority/provisioner/aws.go:294 tok, err := jose.Signed(signer).Claims(payload).CompactSerialize()
jws.operation
HMAC Quantum-safe 1 place See details

Signed token created or verified

A JSON Web Signature or JWT is signed or verified with a key chosen at run time: go-jose `jose.NewSigner()`, `jose.Signed()`, `jws.Verify(key)`, `token.Claims(key, &out)`; josepy `JWS.sign()`; the `jose` npm package's `SignJWT` and `jwtVerify()`. Where the code names the `alg`, that is reported separately.

This code signs or checks a login token. Its algorithm is set by the key it is given.

What to do. Pin the accepted `alg` values, and keep token lifetimes short.

  1. acme/api/eab.go:77 payload, err := eabJWS.Verify(externalAccountKey.HmacKey)
jws.operation
HMAC-SHA256 Quantum-safe 1 place See details

Keyed hash in use

`hmac.New()`. Not broken by Shor and only marginally affected by Grover.

This is a fingerprint proving a message was not altered. Quantum computers do not break it.

What to do. No action, unless the digest is MD5 or SHA-1.

  1. authority/provisioner/webhook.go:240 h := hmac.New(sha256.New, secret)
go.hmac
HMAC-SHA384 Quantum-safe 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

No known quantum attack changes how strong this is. A keyed MAC is not affected by Shor and only marginally by Grover.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/eab.go:134 if algorithm != jose.HS256 && algorithm != jose.HS384 && algorithm != jose.HS512 {
jose.algorithm · CWE-327
HMAC-SHA512 Quantum-safe 1 place See details

JOSE algorithm declared in configuration

An `alg` value in JSON or YAML. `none` is reported as a critical defect; HS* is an HMAC and is not quantum-vulnerable; RS*, PS*, ES* and EdDSA are.

No known quantum attack changes how strong this is. A keyed MAC is not affected by Shor and only marginally by Grover.

What to do. No standardised post-quantum JOSE algorithm exists yet. Keep token lifetimes short.

  1. acme/api/eab.go:134 if algorithm != jose.HS256 && algorithm != jose.HS384 && algorithm != jose.HS512 {
jose.algorithm · CWE-327

Cryptographic assets

Algorithm Assessment What it means Occurrences
TLS Quantum-vulnerable Every TLS cipher suite in general use negotiates a classical key exchange, so a recorded session is decryptable once that exchange falls. 106
unknown Could not be determined The algorithm could not be established from the source - chosen at runtime, or decided somewhere this scan does not reach. 79
X.509 Could not be determined An X.509 certificate, signing request or revocation list, or a signature over one. The algorithm is the key's, which this code does not name. 67
SHA-256 Reduced margin Pre-image resistance falls to about 128 bits of quantum work. Adequate for most uses; SHA-384 restores the full margin where a signature must last decades. 45
ECDSA Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. 38
Ed25519 Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. 38
RSA-1024 Already broken A modulus of 1024 bits or less is below the NIST SP 800-57 floor and is within reach of classical factorisation. Shor is not the nearest problem here. 33
RSA Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. 26
JWS Could not be determined A JSON Web Signature whose algorithm comes from the key or the token header at run time. 24
SSH Could not be determined An SSH key or signature whose algorithm is the key's. 17
RSASSA-PKCS1v15 Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. The v1.5 signature scheme of RFC 8017 section 8.2 has no classical break of its own; RSA-PSS is preferred for new work, but the quantum exposure is the same for both. 10
HMAC Quantum-safe A keyed MAC is not affected by Shor and only marginally by Grover. 9
RSAES-PKCS1v15 Already broken PKCS#1 v1.5 encryption padding is vulnerable to Bleichenbacher oracles today, and the underlying RSA is broken by Shor. 9
CSPRNG Quantum-safe A cryptographically secure random number generator provided by the platform. Not weakened by a quantum computer. 7
RSA-PSS Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. 6
PBES2 Reduced margin Grover's algorithm halves the effective strength; the parameter, not the design, is the problem. 4
SHA-1 Already broken SHAttered and subsequent work produced practical collisions; NIST withdrew SHA-1 in 2030 guidance and it is already unacceptable for signatures. 4
RC4 Already broken RC4 keystream biases break it classically; it is prohibited in TLS by RFC 7465. 3
3DES Already broken Triple DES is withdrawn by NIST and limited by its 64-bit block, independent of quantum. 3
ML-DSA-65 Quantum-safe No known quantum algorithm changes the security margin. 3
AES Reduced margin Grover's algorithm halves the effective strength; the parameter, not the design, is the problem. The key size was not visible at this call site, so the weaker case is assumed. 2
DES Already broken A 56-bit key is brute-forced classically in hours. 2
DSA Quantum-vulnerable Broken by Shor's algorithm on a cryptographically relevant quantum computer. 1

Imported cryptographic libraries

Library Files
crypto/sha1 the SHA-1 digest, which has practical collisions 1
crypto/ed25519 Edwards-curve signatures 31
crypto/tls the TLS client and server 17
crypto/rsa RSA key generation, signing and OAEP encryption 12
crypto/ecdsa elliptic-curve signatures 7
crypto/dsa DSA signatures; frozen by the Go team since 1.16 1
crypto/sha256 the SHA-2 digests 12
crypto/x509 certificate and key parsing 73
crypto/rand the platform random source 5
crypto/hmac keyed message authentication 1