qrp-mcp
Summary: This MCP server inventories cryptographic usage in local directory trees, explains its algorithm catalogue, exports audit-ready CBOMs, and checks scan comparability and fix closure — all offline and read-only.
Scan a repository/directory (
scan_repo): find algorithms, file/line locations, family classification, and coverage with every file accounted for; supportsfull/masked/trimmedline output and national replacement profiles.List recognised algorithms (
list_algorithms): see every family the server knows and how it is classified, without reading any files.Export a CycloneDX 1.6 CBOM (
export_cbom): produce a portable document carrying findings, evidence occurrences, and the coverage block for auditors or pipelines.Compare coverage blocks (
compare_coverage): determine whether two scans' coverage numbers are actually comparable and, if not, which conditions differ.Prove what a change closed (
prove_closure): compare two saved scans to classify findings as closed, still open, relocated, changed, removed, new, or unverifiable — only when the runs are comparable.Run a self-seeded control (
run_self_seeded_control): plant known crypto uses and non-uses into a temporary copy and report which were detected, missed, or falsely reported.Stay local and non-destructive: tools are read-only, make no network calls, and
run_self_seeded_controlonly writes to a temporary copy that it removes.
Detects secp256k1/ECDSA signing code in Bitcoin wallet and protocol sources — bitcoinjs, ECPair, btcec — and reports where an exposed public key makes the private key derivable by Shor's algorithm.
Flags Ed25519 public-key cryptography used in Cardano code as vulnerable to a quantum computer.
Scans Ethereum contracts and wallet code for ECDSA/ecrecover usage, BLS12-381 aggregation in the consensus layer, and BIP340/Taproot Schnorr, classifying each as quantum-vulnerable or post-quantum.
Identifies ethers library usage and the secp256k1 signing primitives it wraps, reporting file and line of each finding.
Inspects Kubernetes manifests for key algorithms and for private key material committed by mistake.
Reads nginx.conf to see which TLS groups a deployment negotiates, including post-quantum hybrids like X25519MLKEM768 and SecP256r1MLKEM768.
Reads openssl.cnf (and PEM/DER key and certificate files with OIDs) to resolve the algorithms and hybrid TLS groups actually configured.
Scans OpenZeppelin contract trees as a corpus — a full run over openzeppelin-contracts (711 files) reported ECDSA and RSA findings with a classical_only readiness summary.
Flags Ed25519 public-key cryptography used in Polkadot code as vulnerable to a quantum computer.
Recognises Solana client and program code (@solana/web3.js, solana_program) that authenticates with Ed25519, flagging it as quantum-vulnerable.
Parses Solidity (.sol) sources for ECDSA, ecrecover and classical crypto such as RSA, MD5, SHA-1 and DES/3DES.
Inspects Terraform infrastructure-as-code for key algorithms and for private key material committed by mistake.
Identifies web3.js usage and the secp256k1/ECDSA signing it performs in Ethereum-facing code.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@qrp-mcp Scan ~/code/my-protocol for quantum-vulnerable cryptography."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
qrp-mcp
An adaptive post-quantum readiness scanner. It closes operations against a catalogue of their documented spellings, each with a test, says in its output which (operation, ecosystem) pairs are closed, and carries its coverage and limits inside the CBOM. A maintainer tool in the repository re-reads the documentation and proposes new spellings, which enter only with a source and a test.
34 s: the fix list drawn as a network, and why closure is by operation. The method and the closure savings theorem: Tenev (2026), Zenodo, doi:10.5281/zenodo.24336932.
Every signature in your wallet, contract and validator rests on elliptic-curve cryptography, and a large quantum computer breaks it. Plenty of tools will tell you what they found. This one also tells you what it read, what it could not read, and which question it is not answering — in the document itself, where an auditor can check it rather than take your word.
An MCP server that scans a local directory for cryptography that Shor's algorithm defeats — secp256k1, Ed25519, BLS, Schnorr, RSA — plus weak primitives and CI signing commands, and classifies each one: broken by a quantum computer, post-quantum, or neither.
Everything runs on your machine. No network calls, no account, no API key, nothing
uploaded. A tool that reads your keys' surroundings has no business phoning home, so this one
makes zero outbound connections — enforced by a test, not promised in a paragraph. The only process it
starts is a local git, to pin what it read, with the scanned repository's own hooks and filters disarmed.
flowchart TD
R["Your repository, on your machine, at a commit"] --> Q["qrp-mcp — offline, zero network calls"]
Q --> F["Found<br/>file:line and family"]
Q --> N["Not read<br/>each file with its reason"]
F --> J["scan --out result.json"]
N --> J
J --> O["CBOM (CycloneDX 1.6)<br/>SARIF<br/>closure: what a change closed"]Need a cryptographic inventory (a CBOM) for a post-quantum migration or an audit, without uploading your code? One command, no install step:
uvx qrp-mcp scan ~/code/my-project --out result.jsonWhat comes back, run on this repository's own test fixtures -- the findings, and next to them what the scan did not read:
"verdict": "This scan read 24 of 27 files (88.89%); the remaining 3 (1 of 1, by extension
— .b64 — being 100.0% of them) are listed with a reason each."
"summary": { "total_findings": 10, "quantum_vulnerable_count": 6, "pqc_ready_count": 1,
"weak_count": 1, "pqc_readiness": "hybrid_partial", ... }Why this matters for chains and wallets
Bitcoin and Ethereum authenticate with ECDSA over secp256k1. Solana, Cardano and Polkadot use Ed25519. Ethereum's consensus layer aggregates with BLS12-381. Taproot adds Schnorr.
All four are public-key schemes whose security rests on discrete-log hardness — and all four fall to the same quantum algorithm. The practical consequence is specific: once a public key is exposed, the private key becomes derivable. Reused addresses, on-chain public keys, and long-lived validator keys are where that exposure already exists today.
None of this is a prediction about dates. It is an inventory question: which of my code paths sign with what? That question has an answer right now, and this tool gives it.
Related MCP server: Secure Code Review MCP Server
Quick start
Add it to your MCP client — no installation step, uvx fetches and runs it:
{
"mcpServers": {
"qrp": {
"command": "uvx",
"args": ["qrp-mcp"]
}
}
}Then ask your agent:
Scan ~/code/my-protocol for quantum-vulnerable cryptography.
As a Claude Code plugin
The same server, packaged with a skill, so there is no config file to edit:
/plugin marketplace add StanimirTenev/qrp-mcp
/plugin install qrp@quantumreadinessThen /qrp:pqc-scan in any project. Both routes need uv on
your PATH, since uvx is what fetches and runs the server.
Without an agent: write the result to a file
uvx qrp-mcp scan ~/code/my-protocol --out result.jsonThis produces the same result as the scan_repo tool, written to a file you can read
before it goes anywhere. Nothing is sent. By default (from 0.40.0, as cbom since 0.16.0 and
the tools) the quoted line is masked: everything in it but the algorithm name is starred out.
--level full writes the line as it is, and --level trimmed removes the line altogether; all
three keep each file and line number. The SHA-256 of the written bytes is printed,
so anyone you send the file to can quote back exactly what they received.
That digest is the file's integrity, and the file holds its read times, so two runs over one
commit print different ones. Beside it, findings sha256 is the fingerprint of the findings
alone (findings_fingerprint in the JSON, in SARIF's run properties and in the CBOM as
qrp:findings_fingerprint:sha256): the same on every run and at every --level that finds the
same, different when a finding is added or removed. Its normalisation rules are written into the
output beside it: each finding as family, raw value, classification and severity; each
occurrence as category, path, line, family, role and key size; excerpts, confidence, owners,
baseline state, mandate clauses, suppressed rows, coverage and the read window left out; both
lists sorted, serialised as compact JSON with sorted keys, SHA-256 in hex. It says the result
repeats; it says nothing about whether the result is complete.
uvx qrp-mcp cbom ~/code/my-protocol --out cbom.json
uvx qrp-mcp closure before.json after.json --out closure.jsoncbom writes the same CycloneDX document as the export_cbom tool, masked by default because
it is the document built to be sent. closure writes the prove_closure verdict for two saved
scans, and names both inputs by their SHA-256, so the three files can be tied together by
whoever receives them. Both print the SHA-256 of what they wrote.
From 0.46.0 a TLS version a file pins is linked, in CycloneDX's own fields, to what the same file
configures: the TLS groups in protocolProperties.cryptoRefArray, and the cipher suites in
protocolProperties.cipherSuites by their IANA names, each pointing at the algorithms it names. A
reader that skips qrp: properties can resolve the key exchange of TLS 1.3
(details).
From 0.47.0 an algorithm read only from the name of a certificate or key file a TLS setting loads
(ssl_certificate /etc/nginx/certs/mldsa65_srv.crt;) is marked named_in_a_path: true and is one
confidence level lower: the file's name is a label, not the certificate.
From 0.47.0 tls_listeners lists each nginx server block that listens with ssl or quic: its
ports, server names (masked below --level full), the groups and the certificates set for it, with
each one's family, so two servers in one file no longer read as one inventory. The CBOM carries it
as qrp:tls_listeners (details).
From 0.48.0 --mandate also takes the deadlines of the EU (eu-pqc-roadmap), the UK (uk-ncsc),
Canada (ca-cccs), Australia (au-ism), the Netherlands (nl-rqs), Sweden (se-ncsc), Japan
(jp-gov), Singapore's CII owners (sg-csa-cii), India (in-dst) and Germany (de-bsi), each
quoted from the authority's own document, so a finding says which deadline catches it in each.
A date for a class of system the scan cannot see -- high-risk, highest priority -- is said beside
the clause and not counted by the gate. Every mandate block says how old its reading of the
document is, and past 180 days (stale) the command line says so
(details).
From 0.49.0 --mandate also takes four financial regulators whose duty dates no line of code --
Bank of Israel (il-boi), FINMA (ch-finma), HKMA (hk-hkma) and MAS (sg-mas, a
consultation): the sector and the duty, quoted, with no clause on any occurrence and a gate that
never counts them. A mandate block also carries the sha256 of each document as it was read, and
qrp-mcp mandate-check NAME --document FILE says whether a copy you downloaded is still the same
document (the tool itself still fetches nothing)
(details).
Four of the mandates also date symmetric or hash algorithms, which the scan does not read:
cnsa-2.0 (AES-256 and SHA-384/512, already required), au-ism (AES-128/192, SHA-224/256 and
HMAC-SHA256 "will not be approved beyond 2030", for interoperability and maintainability reasons),
ca-cccs and nist-ir-8547 (the 112-bit tail by 2030). From 0.49.0 their blocks say
symmetric: not_established, quoting the document, and a gate that would pass reads
not_established instead -- the exit code stays that of a pass. Before, AES-128 and SHA-256 code
passed --mandate cnsa-2.0 in silence.
From 0.49.0 trust_stores lists each place that loads a trust store (Python cafile, Go
AppendCertsFromPEM, nginx ssl_client_certificate), the anchors read in it, and whether its
path is outside the tree; a strongSwan proposal that can be negotiated with a classical key
exchange alone is a row of its own (evidence.ike_proposals), so removing the fallback is
closed; a KMS SDK call (boto3 KMS, Azure Key Vault) says key_location: kms; and every evidence
row with a path says in_test_code
(details).
From 0.47.0 --mandate nist-ir-8547 also gives each clause federal_high_value_assets: the date
by role that NIST IR 8547 (section 4) restates from EO 14412 and OMB M-26-15 -- post-quantum key
establishment by 2030-12-31, signatures by 2031-12-31 -- for federal high value assets and high
impact systems only. The scan cannot tell which systems those are, so the gate does not count it
(details).
From 0.47.0 an RSA, EC, ECDSA, EdDSA or DSA line that calls .sign(, .verify(, .encrypt( or
.decrypt( on a key carries operation, so verifying an old signature no longer reads the same
as signing a new one; in the CBOM as qrp:operation. Under --mandate nist-ir-8547 a verify-only or decrypt-only line
says what IR 8547 calls legacy use, with no exemption: the dates and the gate are unchanged
(details).
From 0.47.0 a call into a post-quantum KEM or signature API is a row with operation --
keygen apart from encapsulate, decapsulate, sign and verify -- so where a device
generates its own key is said with file and line: the NIST API of pqm4, PQClean and SUPERCOP
(crypto_kem_keypair/enc/dec, crypto_sign_keypair, crypto_sign_signature/crypto_sign,
crypto_sign_verify/crypto_sign_open), liboqs (OQS_KEM_keypair/encaps/decaps,
OQS_SIG_keypair/sign/verify and the per-scheme forms) and mlkem-native's namespaced
functions. Where the call does not name the scheme, the family is the one the same file names
(family_named_at), and a family named there only in a comment stays not used; a file naming
none or two gives no row. Declarations are not calls. Code
shows where a key is generated, not whether that step survives a fault.
From 0.47.0 RustCrypto's ml_kem, ml_dsa and slh_dsa crates and libcrux are named as the
provider, and Go's mlkem.GenerateKey768() and its siblings give the parameter set
(details); so do
liboqs's SLH-DSA names (SLH_DSA_PURE_SHA2_128S, SLH_DSA_SHA2_224_PREHASH_SHAKE_128F).
From 0.47.0 an Android Keystore key (KeyPairGenerator.getInstance(..., "AndroidKeyStore")) takes
its role from the PURPOSE_* of the file's one KeyGenParameterSpec.Builder, and an EC key its
curve from ECGenParameterSpec(...) or setKeySize(...) there; where it sets neither, P-256 as the
Keystore's default, marked as such in curve_basis (CBOM qrp:curve_basis). Where the key lives
(StrongBox or TEE) is not read.
From 0.47.0 the CBOM names the scanned folder in qrp:coverage:corpus:target by its own name, not
its absolute path, so it no longer carries a path from your machine and one commit scanned in two
places gives the same bytes; the scan result (scan --out, scan_repo) still has the absolute path.
From 0.47.0 a public-key PEM (PUBLIC KEY, RSA PUBLIC KEY) that parses is read as a key, with
its size and curve, and marked key_material: "public key"; it is not counted as a committed
private key. U-Boot's FIT names ecdsa256/ecdsa384/ecdsa521 give the key size, as rsa2048
already did.
From 0.47.0 the CBOM has one related-crypto-material component per key -- type private-key or
public-key, its size, algorithmRef and qrp:curve -- instead of one "Embedded private key
material" component for all the keys in the tree
(details).
From 0.47.0 an RSA line that encrypts a named value with OAEP (pub.encrypt(archive_key, padding.OAEP(...)), on one line or split over up to four) carries wraps: the value's name (masked below --level full), and, where the
file assigns it once with generate_key(bit_length=N), os.urandom(n), secrets.token_bytes(n) or
get_random_bytes(n), what: "symmetric key" and its size -- a symmetric key is as safe as the key
that wraps it. In the CBOM as qrp:wraps. AES itself is still not reported: symmetric cryptography
is out of scope by design (measurement).
ECIES and AES key wrap under a DH-derived key are not read.
A control on your own tree
uvx qrp-mcp control ~/code/my-protocol --seed 1 --out control.jsonFrom 0.43.0. The tree is copied to a temporary directory, known cryptographic uses (9 styles) and
lines that name an algorithm without using it (7 kinds) are planted into the copy, and the copy
is scanned with the same instrument. The result says which planted lines were found, which were
missed and which non-uses were reported as uses — robustness on known patterns, for this
version. It is not a statement about what your tree contains, and it never makes the coverage
claim stronger. scan --control-seed N carries the block in the result. The control.
A source scan against the build
uvx qrp-mcp scan ~/code/my-service --out scan.json # before building
uvx qrp-mcp build-gap scan.json ~/code/my-service/bin/publish --out gap.jsonFrom 0.44.0. Of K public-key-bearing packages or modules in the build, the source scan named J;
the K - J list; the families on one side only; and a Go binary's DefaultGODEBUG crypto
settings as recorded. It reads only tables the toolchain wrote (*.deps.json, .NET metadata
names, go version -m, go tool nm), never code, and never a key size from the build —
robustness on known patterns, not recall or coverage of the build. Source against build.
How it adapts
"Adaptive" means one thing here: the operations in the scanner's catalogue are tested against the documentation of the libraries and formats the catalogue cites, and a maintainer tool re-reads that documentation for spellings the catalogue does not hold yet. The scan itself stays deterministic and offline. Nothing is learned at run time, and no rule enters the scanner without a source and a test.
An operation is closed, not a line. For each of its (operation, ecosystem) pairs, the package carries a catalogue of the documented spellings (
src/qrp_mcp/data/operations/*.toml), each with the page it comes from and the words quoted from it. Every spelling is a test: it is written to a file, scanned, and expected on its line (tests/test_operation_closure.py). In 0.50.0 the catalogue holds 10 pairs and 1,261 sourced spellings: IKE/IPsec, the public-key names of seven C libraries, key files and key sizes in PKI, key sizes in .NET, TLS endpoints and TLS groups in nginx-style configuration, SSH algorithms, liboqs and hash-based signatures in C, and Python dependencies and environment reads.operation_closurein the result lists those pairs, withspellings_countand the catalogue version. It says what this version was tested against, not what your code contains. It does not enter the findings, their fingerprint, a gate or the exit code.ecosystems,angles,chosen_outside_files.leads,where_to_look. These sections are read from the finished result and change no row of it:ecosystemsnames every ecosystem among the files read, with the rule that put it there, and saysclosed,partially_closedornot_closedagainst the catalogue, with "here we may miss" where it is not closed;anglessets dependency, code and configuration against each other: "declared, not seen", "seen, not declared", andnot_comparedwhere the imports of an ecosystem are not read (Go, Rust, Java, .NET, Ruby, PHP);leadsfollows aninclude, a key file path or a key path read from the environment to the files read, and says where each one ends (followed,outside_the_tree,not_found,templated,read_at_run_time,pattern_not_followed, ...). Nothing new is opened, so a lead adds no finding;where_to_lookputs the three in one list, production code first.
operation_closureand these four sections are in the scan JSON, thescan_repotool andscan --out. The CBOM and SARIF do not carry them.Self-tuning, for the maintainer.
tools/catalogue_refresh.pyis in the repository, not in the installed package, and is run by hand. It fetches each page the catalogue cites (or reads a saved copy with--pages), looks for names with that page's own pattern, and writes what the catalogue does not hold as candidates. Each candidate is an expected-failure test (tests/test_operation_candidates.py). Every page also carries a positive control (a name the catalogue knows, which must be read) and a negative one (a name that exists nowhere, which must not be). A page where the negative control is read is named as not discriminating, and its candidates are not run.
The boundary. Self-tuning proposes; a person or an agent confirms, with a source and a
quotation, and after that a candidate becomes a closure test. In the first judged round, of
the 119 candidates the scanner was silent on, 21 were real spellings of their operation and 12 of
those were gaps the scanner missed (they are closed in 0.50.0); the other candidates were noise or
unclear. That figure is for those 119, not for all the candidates. Under the strict rule no
ecosystem is closed today: an ecosystem is closed when the catalogue holds every operation
in which a gap has been recorded for it, and PKI, the nearest, still lacks one. A spelling the
documentation does not list, or a page the catalogue does not cite, can still be missed.
Why the operation and not the line, and what waiting for the first report costs, is set out in
Tenev, S. (2026), Close the operation, not the line: a closure savings formula for maintaining a
cryptographic-inventory scanner, version 1.0, Zenodo,
doi:10.5281/zenodo.24336932. CITATION.cff in this
repository gives the same reference.
What it reads
Every file under the path is either read or named with the reason it was not. The full list of rules, file types and their limits is in What it looks at.
Kind | Read as |
Source code | C and C++, C#, Visual Basic and F#, Go, Rust, Java, Kotlin, Scala and Groovy, Swift (from 0.47.0: CryptoKit's |
Scripts |
|
CI/CD pipelines | signing commands ( |
Infrastructure as code | Terraform/HCL (an |
TLS, SSH and VPN configuration | nginx, Apache, HAProxy, Caddy, Envoy, Istio, Traefik, Ingress-NGINX, Postfix, Dovecot, MySQL, PostgreSQL, Kafka, ZooKeeper, OpenVPN, WireGuard, strongSwan, OpenSSH ( |
Device configuration | FortiOS backups, Cisco IOS and Junos — read in part, and named as read in part with what was and was not read |
Firmware signing | U-Boot FIT image sources and device trees ( |
Windows |
|
Certificates and keys | PEM and DER ( |
Manifests and lockfiles | the dependencies that bring cryptography in, by ecosystem (npm, PyPI, Cargo, Go, Maven/Gradle, NuGet, RubyGems, CocoaPods, SwiftPM, deb/apk/rpm in a Dockerfile) |
Not read, on purpose | documentation ( |
A name is not a use. A post-quantum name that only names something the file defines
(self.mlkem_key = ec.generate_private_key(...), def kyber_exchange) is an identifier row and
does not make a file post-quantum ready; a file that also calls the library keeps every row as it
was (details).
A name that only spells like a family is not one: MLDSA1R (an SH7722 register) is not ML-DSA,
tinycrypt's ecc_dsa is ECDSA, not DSA, and #define MBEDTLS_REMOVE_3DES_CIPHERSUITES is a
removal, not a use. A call inside with pytest.raises(...) or with self.assertRaises(...) whose
block names a key size (key_size=1024) is attempted in order to fail, and is not a use either; a
block without one (pytest.raises(InvalidSignature) over a verify) is a use; a function defined inside a test whose
docstring makes it a rejection test ("... is rejected.") still runs what it calls.
Coverage on three public repositories
What coverage.scope says on three trees this project did not write, measured on 18 Nov 2026 with
qrp-mcp 0.50.0 (the repositories at OpenSSH 7fe3b24, certbot 56ee049, Vault 41e571b).
coverage_pct is the share of the files present that were read; read_in_full_pct leaves out the
files read only in part (a device configuration, a certificate block that did not parse).
Findings are the entries of findings, Weak is summary.weak_count.
Repository | Files present | Read |
| Read in part |
| Findings | Weak |
OpenSSH | 873 | 742 | 84.99% | 5 | 84.42% | 72 | 55 |
certbot | 1,250 | 850 | 68.00% | 0 | 68.00% | 41 | 28 |
Vault | 9,281 | 5,437 | 58.58% | 9 | 58.49% | 74 | 62 |
These are reading figures, not detection figures. How well the rules find what is there is a different question; the measurements made of it, each with its date and version, are in How it is measured, and no recall or precision figure is cited here as current.
Documentation
What it looks at — the rules, file types and formats, and their limits
What the coverage block says —
coverage_pct,read_in_part,read_in_full_pct,examined_partly, concentrationThe CBOM it emits — CycloneDX 1.6 fields, the kind of place a finding sits in, how sure the scan is of each occurrence
What a TLS line does not establish — TLS places, classical groups and SSH key exchanges offered on their own
Gate, mandates and suppression markers —
--mandate,--min-coverage,.qrp.toml,qrp:ignorewithuntil=andowner=Closure, replacements and profiles — whether a fix closed it, what to replace it with, national profiles, the role of an RSA or EC line
The control —
qrp-mcp control, what it plants, theself_seeded_controlblock and its fieldsSource against build —
qrp-mcp build-gap, what it reads from a build, what it never reads, what K and J areHow it is measured — the measurements, the corpora, what an outside review found, what is still missing
CHANGELOG — what changed in each version, newest first
What it is not
It reads source, configuration, CI pipelines, infrastructure-as-code, Kubernetes manifests,
build files, certificates and key inventories. It does not read documentation, binaries or
images; build-gap reads only the name tables a toolchain wrote into a build, never its code.
Every file under the path is accounted for in one of four ways: scanned, unreadable,
skipped because the tool does not claim that type — counted by extension, so
the coverage figure has a base, and from 0.27.3 named one by one in the coverage block (not_examined → paths) —
or a link not followed, named in symlinks_not_followed. files_scanned + unreadable_files + files_skipped_by_type plus the linked files always equals files_present; until 0.34.0 this
sentence said three ways and left the links out. A directory the scan cannot enter or list is named in
unreadable_directories; its files cannot be counted, so the scan then says it cannot account
for every file instead of claiming it read them all. A scan that read seven files out of nine is a different report
from one that read seven out of four hundred, and only one of them is worth trusting.
A free inventory tool, not a readiness assessment. It deliberately does not do:
risk scoring or prioritisation,
migration planning — a
replacementnames what a finding becomes, not when or in what order,network or host scanning, or reading a system certificate store,
tracking change over time —
prove_closurecompares two scans you give it; nothing keeps a history,symmetric cryptography, hashes and MACs, key derivation (PBKDF2, scrypt, Argon2, HKDF) or random number generation (SecureRandom, DRBG,
os.urandom,secrets, a remote entropy service) — out of scope by design: it reports the public-key cryptography a quantum computer would break. A file holding only these is read and gives no row; the output says so incoverage.claims.out_of_scope_by_design. MD5, SHA-1, DES, 3DES and RC4 are still named where found. Four--mandatedocuments date AES or SHA sizes (cnsa-2.0,au-ism,ca-cccs,nist-ir-8547); under them the gate saysnot_establishedfor symmetric rather than pass,which OpenSSL or other TLS library a base image carries:
FROM alpine:3.12orFROM ubuntu:16.04says nothing about the OpenSSL inside it (onlynginx:1.24.0is known); a package aRUNline installs is a dependency row with its version,the algorithm of a signature made by a KMS, Vault or an agent: such a call is a place in
chosen_outside_files(kind: remote_signing), not a family,fetching keys from a QKD key management entity (an ETSI GS QKD 014 client) or judging where a postquantum preshared key comes from beyond the files read.
Those live in the Quantum Readiness Platform, the product this tool is extracted from. Nothing here is crippled to push you there. What it does not cover is said, not hidden: the scan writes its coverage and limits into the CBOM and claims no completeness beyond them.
It also does not tell you that you are about to be hacked. It tells you what you are using.
License
Apache-2.0.
Available Tools
6 toolscompare_coverageARead-onlyIdempotent
Say whether two scans produced numbers that can be compared at all.
Two coverage percentages can differ because the estate moved, because the instrument moved, or because the corpus was collected differently, and the percentages show none of the three. This reads the pins and conditions in both blocks and answers with one of three verdicts.
comparable means nothing that moves the number differs. not_comparable lists
which conditions differ, each with what it means, so the reader knows whether to
re-run, re-clone or ignore it. unestablished means the blocks do not carry enough
to decide -- an unpinned corpus, or an emitter that names no commit -- which is a
different situation from a known difference and has a different repair.
Use it before putting two coverage figures in one table. Do not use it to compare findings; it reads conditions, not results.
Inputs: first (required), second (required). Returns: object
export_cbomARead-onlyIdempotent
Scan one directory and return a CycloneDX 1.6 CBOM that carries its own coverage.
Same reading as scan_repo; a different document. Use this when the result has to
leave the machine -- an auditor, a customer, a pipeline artefact -- and scan_repo
when a person or an agent is going to read it here.
What the document carries beyond the components: compositions.aggregate states how
complete the list is in the schema's own vocabulary, complete only when every file
present was examined; properties carries the whole coverage block flattened,
including every file not examined with its reason; and each asset carries
evidence.occurrences with file, line and matched text.
The coverage block travels as properties because the CycloneDX root object is
additionalProperties: false and the format has no field for it. That is the point
of emitting it this way rather than a limitation to work around.
The serial number is derived from the two pins and a digest of the findings, not from where the tree sits, so two runs of the same code over the same corpus that find the same things share it and a different result does not. The timestamp is the tree's commit time (or SOURCE_DATE_EPOCH), so two runs over one unchanged tree give the same bytes; the read window stays in the scan result.
The matched text in evidence.occurrences is masked by default, for the reason
given on scan_repo and one more: this document is the one built to be sent.
An auditor needs the algorithm, the file and the line; the contents of the line
are not part of the claim being made.
Inputs: path (required), level. Returns: object
list_algorithmsARead-onlyIdempotent
List every algorithm family this server can recognise, and how each is classified.
Returns the whole table: family name, classification (classical and quantum-vulnerable, post-quantum, symmetric, hash, or deprecated) and the kind of use it stands for. Reads no files and takes no arguments.
Use this to check coverage before trusting a scan -- whether a scheme the project
depends on is one this server knows at all -- or to explain a classification without
scanning. To find what a particular directory uses, use scan_repo instead; this
tool never looks at a codebase.
An algorithm absent from this table is reported as unknown by a scan, which is not
the same as absent from the code.
Inputs: no named parameters. Returns: object
prove_closureARead-onlyIdempotent
Say which findings a change actually closed, by comparing two saved scans of one tree.
First it decides whether the two runs can be compared for closure at all: the same instrument commit, version, rules, file types and exclusions, both trees pinned to a commit and clean, both results quoting lines at the same level. The trees themselves may differ -- that difference is what is measured. If the runs cannot be compared, nothing is reported as closed and the repair is named.
Only then does it match every occurrence without its line number: closed
(present before, absent from every file the second run read), still open (and
how many only moved lines), relocated to another path (renamed or moved, not
fixed), changed (gone from a file in which the second run finds the same family
again -- not closed), removed (the whole file is gone from the second tree -- not counted as
closed), moved into or out of test code, new, and unverifiable (in a file the
second run did not read). A file the second run could not open is never counted
as fixed.
To keep the verdict as a file that names the two scans it judged, run
qrp-mcp closure BEFORE AFTER --out FILE.
Use it after a fix, to evidence the fix. Do not use it to compare coverage
figures between two estates -- compare_coverage answers that. It reads two
local files and nothing else.
Inputs: after (required), before (required). Returns: object
run_self_seeded_controlARead-onlyIdempotent
Plant known lines into a temporary copy of a directory, scan the copy, and say what the scan did with each: robustness on known patterns.
27 cryptographic uses in 9 styles (direct calls, aliased names, names built from
pieces, calls split over lines, shell commands in strings, cert-manager, Terraform,
Java properties, UTF-16 without a byte-order mark) and 18 lines that name an algorithm
without using it (switched-off flags, deny lists, log strings, variable names,
comments, a JWKS key label, an sshd_config removal list) per tree with one language.
Returns self_seeded_control -- counts by style, by decoy class and by confidence,
the seed, the harness digest -- and items, where each line went and its outcome.
Behaviour beyond the annotations: it writes the copy to a temporary directory and
removes it afterwards; nothing in path changes and nothing leaves the machine.
Use it to learn which styles this instrument's silence may be relied on in this tree.
Do not use it to inventory the tree -- that is scan_repo -- and do not read its counts
as a statement about the tree's own cryptography: the denominator is what was planted,
and the figure never makes claims.control.held true.
Inputs: path (required), seed. Returns: object
scan_repoARead-onlyIdempotent
Inventory the cryptography inside one local directory tree, file by file.
Reads source, configuration (nginx.conf, sshd_config, .ini, .toml), CI pipelines,
Terraform and Kubernetes manifests under path. Returns each algorithm found with
its file and line, the mathematical family and standing of every post-quantum
scheme, and a coverage count.
Use this to answer what a specific project on this machine actually uses. Do not
use it to ask whether this server knows a given algorithm, or to explain how one is
classified without scanning anything -- list_algorithms answers that from the same
table and reads no files. It is also the wrong tool for a network endpoint, a
running host or a certificate store: it opens files on disk and nothing else.
Coverage is reported as a fraction with a base. files_scanned + unreadable_files + files_skipped_by_type + the linked files in symlinks_not_followed == files_present;
a link is not followed and is named, not read. A file that could not be opened is listed,
never counted as scanned, because no findings in a file nobody read is not the same
as a file that is clean. Files skipped because this tool does not claim their type
are counted by extension, so the reader can judge the boundary rather than assume
past it.
The owner's own settings apply and are reported, never silent: a .qrp.toml at the
root (its excludes are listed under coverage.not_examined as excluded_by_config;
its baseline marks rows new or baselined), and qrp:ignore <family> <reason> comments,
whose rows move to suppressed with the reason and are counted in
coverage.suppressed; a marker past its until=YYYY-MM-DD no longer applies and is
listed as expired.
The result also says where this version may miss, read from the finished result
without changing any row: operation_closure (the (operation, ecosystem) pairs whose
documented spellings this version tests one by one), ecosystems (each ecosystem of
the files read, closed, partially closed or not closed against that catalogue),
angles (dependency, code and configuration where they disagree),
chosen_outside_files.leads (includes and key paths followed to the files read) and
where_to_look. None of these enters the findings or their fingerprint, and the CBOM
from export_cbom does not carry them.
Cost scales with the size of the tree, so a large monorepo takes proportionally longer; there is no cache and no partial mode.
Quoted lines are masked by default. Reading happens on this machine, but this
result does not stay on it: it is returned to a model, which is a place the
scanned line has not been before. A secret sharing a line with a finding -- a
token in the call that names the cipher -- would travel with it. Masking keeps
what a reader needs (the algorithm, the file, the line number, the shape of the
call) and removes what nobody asked for. Pass level="full" when the line
itself is the thing being examined.
Inputs: path (required), level, profile. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool occupies a distinct slot in the audit lifecycle: inventory (scan_repo), emit (export_cbom), classify (list_algorithms), compare coverage conditions (compare_coverage), compare findings for closure (prove_closure), and validate detection by seeding (run_self_seeded_control). The descriptions go further than most servers, explicitly naming the neighbouring tool and stating when it, not this one, is correct (e.g. scan_repo vs list_algorithms, compare_coverage vs prove_closure, scan_repo vs export_cbom). The one genuine overlap — scan_repo and export_cbom run the same reading — is resolved by an explicit output-consumer distinction (read here vs send off-machine).
All six names are snake_case verb_noun constructions (scan_repo, compare_coverage, export_cbom, list_algorithms, prove_closure, run_self_seeded_control) with no casing or style drift. The single long outlier, run_self_seeded_control, is still the same pattern and is descriptive of what it does.
Six tools is tightly scoped for a crypto-inventory server and each maps to a non-redundant operation rather than a variation of another. Nothing feels padded or missing at the count level.
The lifecycle is well covered: scan, export to a standard format, classify, compare coverage, prove remediation, and self-validate detection, plus the .qrp.toml baseline/ignore mechanism surfaced through scan results. Minor gaps remain — there is no tool to query or page through a saved scan result directly (only the two comparison tools read saved files), and no operation for managing or validating the policy/baseline configuration itself.
Maintenance
Related MCP Connectors
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
Audit your MCP servers for poisoned tools and leaked secrets, and check AI-generated code for flaws.
Scan any public GitHub MCP-server repo for security issues. 37 MCP-specific L1 rules, 8 languages.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for ai-scanner that enables AI agents to scan codebases for LLM usage, AI frameworks, and exposed secrets.1MIT
- FlicenseNot gradedqualityDmaintenanceLocal MCP server that scans code for security issues (secrets, dependencies, configurations, risky patterns) and integrates with GitHub Copilot in VS Code for automated pre-commit reviews.-
- AlicenseAqualityCmaintenancePost-quantum readiness for AI coding agents: scans code for quantum-vulnerable cryptography (RSA/ECDH/ECDSA/DH) and returns NIST ML-KEM/ML-DSA/SLH-DSA (and hybrid) migration guidance, with fix verification and dependency checks. Content-based, advisory tools only; runs local (npx @quantakrypto/mcp) or as a hosted OAuth endpoint.1616Apache 2.0
- AlicenseNot gradedqualityBmaintenanceStandalone MCP server that provides security scanning, project mapping, and vulnerability fix generation to AI coding assistants.1,118 npm2MIT