Security · verifiable security-test evidence · status as of 2026-10-20
Implementation status. The scanner orchestration, standards knowledge base, PQC/CBOM detectors and QRNG honest-fallback policy described here are present in the QVAPT repository. The signed, hash-chained, DLT-anchored evidence transcript, the offline verifier and the in-browser "Verified" badge are the platform's design: no transcript signer, chain hash or verifier script could be located in the repository on 2026-10-20, so §2 should be read as the attestation architecture QVAPT is building toward. Under the owner's directive that every signature moves to FIPS 203–205, the Ed25519 transcript signature is a named classical exception; a hybrid Ed25519 + ML-DSA-65 signing adapter already exists in the repository and ML-DSA transcript signing is the roadmap.
Security testing produces findings, but findings are only as trustworthy as the process that produced them. A conventional penetration-test report is a PDF: a narrative that asserts what was tested, what was found, and when — with no cryptographic way for a third party to confirm that any of it is true, unaltered, or even that the described tests were actually run. QVAPT (Quantum VAPT) is a security-testing platform designed to close this gap. Every scan is designed to emit a signed, tamper-evident evidence transcript — signed (Ed25519 today, ML-DSA planned), hash-chained, and anchored to a distributed ledger — so anyone — auditor, regulator, customer, or the tested party — can independently verify the result offline, without trusting QVAPT or its operator. QVAPT unifies best-in-class open-source and standards-aligned tooling across web/API, smart-contract/infrastructure, AI/LLM, and secrets/supply-chain surfaces, and routes test entropy through a shared quantum random number generator (QRNG) service with a classical fallback. Its differentiator is not any single scanner: it is independently verifiable, DLT-anchored, cryptographically attested security-test evidence.
Vulnerability assessment and penetration testing (VAPT) is a compliance and trust cornerstone — required for SOC 2, ISO 27001, PCI-DSS, and most enterprise procurement gates. Yet the artifact of that work, the report, is structurally unauditable:
The result: security evidence that is expensive to produce, easy to fake, and hard to reuse. QVAPT treats the evidence, not the report, as the primary product — and makes that evidence verifiable by anyone, without trusting the producer.
QVAPT's core is an attestation chain (design — see the status note above). Each security-testing run is designed to produce an evidence transcript — the tools invoked, their versions, the target scope, the inputs, the raw findings, and timestamps — captured as a structured, canonical record rather than free-form prose.
Signatures — Ed25519 today, ML-DSA planned. Each transcript is signed with a key held by the QVAPT runner. Ed25519 is fast, compact, and widely implemented, so the signature can be checked by any standard cryptographic library with no QVAPT-specific software; it is, however, a classical algorithm and therefore a named exception to Aurigraph's FIPS 203–205 directive. QVAPT's repository already carries a hybrid Ed25519 + ML-DSA-65 signing adapter (vapt-pqc/hybrid_pqc.py), and the roadmap is to sign transcripts with ML-DSA so that the evidence itself is quantum-safe. The signature binds the exact bytes of the transcript to the runner's identity: alter one byte of a finding and the signature no longer verifies.
vapt-pqc/hybrid_pqc.py
Hash chaining. Transcripts are hash-chained — each record commits to the prior record's hash — so a run cannot be silently inserted, removed, or reordered after the fact. The chain yields a single chain_hash that summarizes the entire evidence history.
chain_hash
DLT anchor. That chain_hash is anchored to a distributed ledger. Anchoring publishes an immutable, independently timestamped commitment to the evidence: the ledger record fixes what was attested and when, and no party — including QVAPT's operator — can retroactively rewrite it. This is the difference between "the vendor says the scan ran on the 3rd" and "a ledger recorded the evidence hash on the 3rd, and here is the block."
Offline verifier (design). QVAPT is designed to ship standalone verifier scripts. Given a transcript, its signature, and the anchored hash, a third party would confirm — with no network call to QVAPT, no account, and no trust in the platform — that (a) the transcript is intact, (b) it was signed by the claimed runner key, and (c) its hash matches the value anchored on the ledger. Verification is a local, deterministic computation.
In-browser "Verified" badge (design). For non-technical consumers, the QVAPT portal is designed to render an attestation badge that performs the same checks in the browser and displays a green Verified state only when the signature and ledger anchor both check out. The badge is a convenience over the offline verifier, never a replacement for it: the authoritative proof is always the signed transcript plus the ledger anchor, which anyone can re-check independently.
Together these mean a QVAPT finding is not "trust us" — it is a portable, self-contained proof that a specific test, producing a specific result, was executed and recorded at a specific time.
QVAPT is a security-testing portal and orchestration platform: it drives a curated set of established open-source scanners across four attack surfaces, normalizes their output into the attested evidence transcript, and aggregates findings into vulnerability-management back-ends. It does not reinvent scanners; it makes their output verifiable and unifies their coverage.
Web and API. Dynamic and static application testing — schemathesis for property-based API fuzzing against OpenAPI schemas, katana for crawling and endpoint discovery, naabu for fast port/service enumeration, and CodeQL for deep static analysis of application source. This surface covers the OWASP-style injection, broken-auth, and misconfiguration classes at both the running-service and source levels.
schemathesis
katana
naabu
CodeQL
Smart contract and infrastructure-as-code. Mythril (symbolic execution / EVM bytecode analysis) and Aderyn (Solidity static analysis) target on-chain contract vulnerabilities — reentrancy, integer and access-control flaws, unchecked calls — a surface conventional pentest tooling ignores entirely, and one directly relevant to a DLT platform.
Mythril
Aderyn
AI and LLM. garak (LLM vulnerability probing) and PyRIT (AI red-teaming) exercise prompt-injection, jailbreak, data-leakage, and unsafe-output failure modes in AI/LLM components. As AI systems enter production paths, this surface is increasingly a primary attack vector; QVAPT treats it as a first-class scan target rather than an afterthought.
garak
PyRIT
Secrets and supply chain. TruffleHog (secret detection across code and history), osv-scanner (known-vulnerability matching against the OSV database), and Syft (SBOM generation) cover leaked credentials and vulnerable or unaccounted-for dependencies — the supply-chain surface behind a large share of real-world breaches.
TruffleHog
osv-scanner
Syft
Aggregation and tracking. Findings flow into DefectDojo (vulnerability management) and Dependency-Track (component/SBOM risk), giving a durable, deduplicated view of posture over time. QVAPT also pushes findings into JIRA, so remediation lands in the engineering workflow rather than a dead PDF.
DefectDojo
Dependency-Track
Crucially, the output of every tool above is captured into the same signed, ledger-anchored transcript — so the coverage itself is attested: the evidence states, verifiably, which tools ran, at which versions, against which scope.
Randomness quality matters in security testing: fuzzing inputs, nonces, test payloads, and entropy-sensitive probes are only as good as the source that generates them. QVAPT routes such entropy through a shared QRNG agent — a quantum random number generation service (originating from Aurigraph's quantum-os entropy stack, a gRPC QRNG agent, and a quantum worker, consolidated into the QVAPT platform).
quantum-os
The QRNG agent is designed to draw entropy from IBM quantum hardware when available, exposing it over a simple service interface so test tooling can request bytes without embedding backend credentials. Genuine quantum entropy is optional and gated, not always-on: the default configuration is classical CSPRNG fallback, and the service transparently labels its source (for example, quantum, mixed, or classical CSPRNG) rather than overstating it. Real quantum entropy depends on live backend availability and provisioned credentials; when those are absent, the fallback serves cryptographically secure classical randomness and the evidence records the true source. QVAPT never claims quantum-sourced entropy it did not actually use — the attested transcript reflects reality.
This honesty is deliberate and load-bearing: the same discipline that makes the attestation chain trustworthy applies to entropy provenance. A "quantum" label that could not be independently substantiated would undermine the platform's core promise.
On the roadmap, a gate-4 hardware-entropy milestone hardens the path to genuine, continuously available quantum entropy — full deployment of the QRNG agent, live IBM-quantum backends, and an executor mode that requires verified quantum bytes for designated runs — so that entropy provenance can itself be attested end-to-end.
QVAPT's methodology is aligned with established security-testing standards, so its output maps cleanly onto the frameworks auditors and customers already use:
The attestation layer is complementary to these standards rather than a replacement: NIST SP 800-115 and OWASP describe what to test and how; QVAPT adds a verifiable proof that the testing was actually performed and recorded as stated. This directly supports audit and compliance workflows, where the recurring weakness is not the test methodology but the credibility of the evidence.
QVAPT is an actively evolving platform. Near-term epics extend it from a testbench into continuous, verifiable security infrastructure:
The value of a security test is destroyed if its evidence cannot be trusted. QVAPT re-centers VAPT on the artifact that matters — a signed, hash-chained, ledger-anchored evidence transcript that any party can verify offline, without trusting the platform that produced it; that attestation chain is QVAPT's design target and is not yet shipped. Around that core it assembles standards-aligned, best-in-class tooling across web/API, smart-contract/IaC, AI/LLM, and secrets/supply-chain surfaces, and routes test entropy through a shared QRNG service that is honest about whether it is quantum-sourced or classically generated. The outcome is security evidence that is portable, tamper-evident, independently auditable, and mapped to NIST SP 800-115 and OWASP — turning the pentest report from an act of faith into a verifiable proof.
For the underlying distributed ledger that anchors QVAPT's attestation chain, see the Aurigraph DLT whitepaper.
github.com/Aurigraph-DLT-Corp/QVAPT
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io