Your 2019 backups are the breach of 2033.
qScan now reads the platform around your code: CI/CD signing, secrets at rest, Kubernetes PKI, message brokers, databases, IaC, and token encryption. Same CLI, same GitHub Action, same MCP server. No new install.
The exposure you cannot patch in hindsight
A source-code fix moves you forward from today. It does nothing for the encrypted secret already sitting in your git history, or the broker traffic an adversary recorded last quarter. Harvest-now-decrypt-later means the ciphertext is captured today and opened the day a cryptographically-relevant quantum computer exists, so the backup you took in 2019 is a breach waiting on a date. qScan ranks these retroactive, un-fixable surfaces first, because they are the ones a code review will never catch.
Where classical crypto hides in your platform
Every place your platform pins itself to pre-quantum cryptography, in one scan, grouped by how it fails: harvest-now-decrypt-later first (un-fixable in hindsight), then forgeable at Q-day, then weak configuration.
18
infrastructure surfaces
14
source languages
5
report formats
Apache-2.0
open source
Secrets at rest
GitOps secrets
Ciphertext committed to git is un-fixable in hindsight. Rotate the key all you like: the encrypted blob already in your history was captured the moment it was pushed, and it decrypts the day a quantum computer arrives.
Detects
- SOPS + age X25519 recipients
- PGP-encrypted secret files in the tree
- Sealed Secrets RSA controller keys
- age identities checked into history
Message brokers
Event streaming
Broker traffic is long-lived and trivial to tap. A classical ECDHE handshake protecting a Kafka or MQTT stream is a harvestable session key, recorded now and opened later.
Detects
- Kafka listener TLS version & cipher floors
- MQTT broker legacy TLS configuration
- Classical-only ECDHE cipher suites
- RSA key-transport in broker TLS config
Databases
Data layer
Public-key encryption inside the database, and weak transport to reach it, are both quantum-exposed, and the rows they protect carry the longest confidentiality lifetime you own.
Detects
- pgcrypto pgp_pub_encrypt public-key usage
- libpq sslmode below verify-full
- Classical-only TLS to the database endpoint
- Column-encryption key algorithms
Reverse proxies & gRPC
Edge / service TLS
The proxy that terminates TLS at your edge, and the gRPC channels between your services, negotiate the session keys everything else rides on. A classical-only ECDHE handshake there is a harvestable key, recorded now and opened later, and it sits in front of the mesh, where the Kubernetes detectors never see it.
Detects
- Envoy / Nginx / HAProxy / Traefik TLS config
- In-code gRPC channel credentials (Python/Node/Java/Go)
- Classical-only ECDHE termination at the edge
- Legacy TLS version & cipher floors
JOSE / JWE key management
Token encryption
Encrypted tokens pin their security to the key-management algorithm in the header. A captured JWE, or a JWK with a classical curve, is decryptable later if that algorithm is classical.
Detects
- JWE alg RSA-OAEP / RSA1_5
- ECDH-ES key agreement
- JSON Web Keys with classical kty / crv
- Static key-wrap for long-lived tokens
Cloud KMS SDKs
Runtime key minting
The keys your application code mints in AWS, GCP, or Azure KMS decide the crypto posture of everything they wrap. RSA key-encryption and EC key-agreement specs are quantum-exposed, the application-code counterpart to the IaC detectors.
Detects
- AWS KMS KeySpec RSA_* / ECC_NIST_P*
- GCP KMS RSA_SIGN_* / EC_SIGN_* algorithms
- Azure Key Vault RSA key creation
- SDK key-agreement (ECDH) paths
HashiCorp Vault
Secrets engines
Vault's transit engine wraps real production data with the key algorithm you configure. An RSA transit key, or a classical PKI role, is a quantum-exposed root for everything it protects.
Detects
- transit type = rsa-2048/3072/4096 keys
- transit ecdsa-p* / ed25519 signing keys
- pki role key_type = rsa | ec
- native .hcl secrets-engine config
Committed keystores
Binary key material
A keystore committed to a repo is un-fixable in hindsight: the private keys inside were captured the moment it was pushed, and they decrypt or forge the day a quantum computer exists.
Detects
- Java KeyStore (JKS, magic 0xFEEDFEED)
- JCEKS keystores
- PKCS#12 .p12 / .pfx containers
- BouncyCastle .bks stores
HSMs & PKCS#11 tokens
Hardware roots
HSMs hold your longest-lived roots, CA keys and code-signing keys, exactly the keys a post-quantum migration has to find first. Classical mechanisms on a PKCS#11 token are the hardest to rotate and the most exposed.
Detects
- pkcs11-tool --key-type rsa: / EC: keygen
- CKM_RSA_PKCS* mechanism constants
- CKM_EC* / CKM_ECDH* mechanisms
- Finite-field DH CKM_DH_PKCS_*
VPNs & tunnels
Network transport
Recorded tunnel traffic is decryptable the day a quantum computer arrives. WireGuard's Curve25519 handshake has no standard PQC option, and IPsec's finite-field and elliptic-curve DH groups are equally exposed: a captured session opens later.
Detects
- WireGuard [Interface]/[Peer] Curve25519 keys
- IPsec / strongSwan finite-field DH (modp*)
- IPsec elliptic-curve DH groups (ecp*)
- Committed WireGuard private keys
SAML & XML signatures
Enterprise SSO
Encrypted SAML assertions pin their confidentiality to RSA key transport, captured now and opened later, and a forged XML-DSig signature is a spoofed SSO assertion. Enterprise identity rides on both.
Detects
- XML-Enc RSA-OAEP / RSA-1_5 key transport
- xmldsig#rsa-sha* signature URIs
- xmldsig-more#ecdsa-sha* URIs
- SAML library algorithm constants
CI/CD & code signing
Supply chain
A signature is only as future-proof as its algorithm. Every classical signature you ship today becomes forgeable the day a quantum computer exists, and a forged release signature is a supply-chain compromise. The same detectors flag SHA-1 (which NIST retires on the same 2030 window) and MD5 (already broken and disallowed today) in signing or certificate contexts.
Detects
- cosign / Sigstore ECDSA & RSA keys
- GPG / PGP release signing keys
- signtool / apksigner / rpmsign / nuget sign / codesign
- SHA-1 / MD5 signature & certificate hashes
SSH certificate authority
Access PKI
An SSH CA signs the host and user certificates that grant access across your fleet. If the CA key is classical, every certificate it issues is forgeable the day a quantum computer exists, and a forged SSH certificate is unauthenticated access to anything that trusts the CA.
Detects
- TrustedUserCAKeys / HostCertificate deployment
- ssh-keygen -s CA signing keys
- *[email protected] certificate types
- Classical CA key material (RSA / ECDSA / Ed25519)
SPIFFE / SPIRE identities
Workload identity
SPIRE issues the X.509-SVID identities workloads use to authenticate to each other. The key algorithm on the authority and the SVIDs sets the floor for the entire identity plane: classical keys leave every workload identity quantum-exposed.
Detects
- SPIRE server ca_key_type (rsa-*, ec-p256/384)
- Agent svid_key_type for X.509-SVIDs
- Classical upstream authority key algorithms
- Helm, JSON, and YAML SPIRE deployments
DNSSEC
DNS trust chain
A forged DNSKEY/RRSIG chain lets an attacker spoof DNSSEC-validated records the day classical signatures fall. The signing algorithms in your zone policy decide whether that day is reachable.
Detects
- RSASHA1/256/512 in BIND / Knot / PowerDNS
- ECDSAP256SHA256 / ECDSAP384SHA384
- ED25519 / ED448 signing (classical)
- DNSKEY RDATA algorithm numbers
Kubernetes PKI
Kubernetes
cert-manager mints the certificates that hold your mesh together. If the issuer's key algorithm is classical, so is every leaf it signs, and the mesh negotiates down to match.
Detects
- cert-manager Certificate / Issuer key algorithms
- Istio minProtocolVersion TLS 1.0/1.1 floors
- Linkerd identity keys
- Consul Connect CA keys
Terraform / OpenTofu IaC
Infrastructure as code
The keys your infrastructure code generates, and the KMS aliases it wires up, decide the crypto posture of everything downstream, provisioned before a single workload runs.
Detects
- tls_private_key RSA / ECDSA resources
- KMS key spec & signing algorithms
- Provisioned SSH & TLS key algorithms
- Classical keys in .tf / .tf.json configs
CloudFormation, Bicep, Pulumi & Ansible
Infrastructure as code
Terraform isn't the only place infrastructure provisions keys. CloudFormation, Bicep, Pulumi, and Ansible generate the TLS keys and KMS aliases that set the crypto floor for everything downstream, before a workload runs.
Detects
- AWS::KMS::Key KeySpec + ACM KeyAlgorithm
- Bicep Microsoft.KeyVault kty RSA / EC
- Pulumi tls.PrivateKey (RSA / ECDSA)
- Ansible community.crypto openssl_privatekey
One zero-dependency repo · Apache-2.0 · npm @quantakrypto/*
Surfaced by the tools you already run
The infrastructure detectors ship inside the same qscan CLI, GitHub Action, and MCP server. Nothing new to add to your toolchain: point it at a repository and it reads code and infrastructure together. Findings export as JSON, SARIF, a CycloneDX CBOM, an ISO 27001 A.8.24 evidence report, or OpenVEX.
Scan a repository
$ npx @quantakrypto/qscan ./Gate every pull request
$ uses: quantakrypto/pqc-tools/packages/action@v1Inside your AI coding agent
$ claude mcp add quantakrypto npx @quantakrypto/mcpqprobe
Active probe · opt-inOwnership-gated · read-onlyqprobe, active probe
Confirm what your live endpoints actually negotiate
Static scanners read configuration. qprobe reads reality. It is a separate, opt-in package that handshakes the TLS and SSH endpoints you own and reports whether they negotiate a post-quantum hybrid key exchange.
Opt-in install
$ npx @quantakrypto/qprobe --i-own-this example.comDetects
- TLS 1.3 hybrid group X25519MLKEM768
- SSH KEX offers (mlkem768x25519, sntrup761x25519)
- Hybrid vs classical-only endpoints
- Silent downgrade to classical groups
Ownership-gated · read-only
qprobe is a separate, opt-in install, never bundled with qscan. It runs only against endpoints you explicitly attest you own, sends nothing beyond a key-exchange handshake, and never modifies a target. No attestation, no probe.
Frequently asked questions
What does infrastructure scanning cover?
Eighteen surfaces around your code, including CI/CD and code signing, secrets at rest, Kubernetes PKI, message brokers, databases, infrastructure-as-code, VPNs, DNSSEC, and HSMs.
Do I need to install anything new?
No. It is the same qScan CLI, the same GitHub Action, and the same MCP server you already use for source code. No new install.
Why worry about infrastructure before a quantum computer exists?
Because of harvest now, decrypt later. Encrypted backups and traffic captured today can be opened once a large quantum computer arrives. Your 2019 backups are the breach of 2033.
How are findings prioritized?
By three risk archetypes: harvest now, decrypt later; forgeable at Q-day; and weak key or legacy TLS floor. That tells you what to move first.
What does qProbe add here?
It checks live endpoints for hybrid key exchange, TLS X25519MLKEM768 and SSH mlkem768x25519 or sntrup761x25519, and flags classical-only endpoints and silent downgrades. It is ownership-gated and read-only.
What evidence can I hand to auditors?
Reports in JSON, SARIF, CycloneDX CBOM, ISO 27001 A.8.24 evidence, and OpenVEX.
Find the crypto your infrastructure forgot.
Run the scan across your platform, then book a discovery call for a senior read on what to migrate first.