Research
Zer0n: An AI-Assisted Vulnerability Discovery and Blockchain-Backed Integrity Framework
Automated security tools increasingly rely on LLMs to find vulnerabilities, but there is no verifiable record proving that a given AI-generated report was actually produced by that analysis and not…

- arXiv
- 2601.07019
- Published
- 2026-01-11
- Authors
- Harshil Parmar, Pushti Vyas, Prayers Khristi, Priyank Panchal
AI summary
Overview
Research area: Cybersecurity / applied cryptography — specifically the intersection of AI-assisted vulnerability discovery (Large Language Models) and blockchain-based integrity logging.
Technical level: Intermediate. The paper is readable without deep cryptographic background, but assumes familiarity with vulnerability scanning concepts, hashing, and smart contracts.
Scope (one sentence): The paper presents and empirically evaluates Zer0n, a prototype that pairs Google Gemini 2.0 Pro vulnerability analysis with hash-based integrity records on the Avalanche C-Chain, measuring detection quality and the latency cost of the blockchain layer.
What This Paper Is About
Automated security tools increasingly rely on LLMs to find vulnerabilities, but there is no verifiable record proving that a given AI-generated report was actually produced by that analysis and not altered afterwards — the authors call this the "trust gap." Zer0n's goal is to close that gap by keeping the heavy analysis off-chain for speed while writing a cryptographic hash of each report to a public blockchain, so any later tampering becomes detectable. The paper asks whether that integrity layer can be added without an unacceptable performance penalty.
Key Contributions
- A hybrid trust architecture. A modular design that decouples AI reasoning from integrity enforcement, so each can scale independently; execution stays off-chain and only integrity proofs are finalized on-chain, explicitly avoiding decentralized storage systems such as IPFS.
- Tamper-evident artifacts. A Solidity-based mechanism (the
logVulnerabilityHashfunction inZer0nLog.sol) deployed on the Avalanche C-Chain that renders post-analysis report manipulation mathematically detectable. The scheme is formalized as computing a fixed-length digest h = H(R) of report R and recording it on-chain for later recomputation and comparison. - Dual-purpose on-chain design. The same Avalanche C-Chain contracts manage user subscriptions (Basic/Pro tiers) and record integrity proofs, decentralizing access control while making reports immutable.
- An empirical feasibility analysis. An evaluation on 500 web application endpoints and 100 smart contract samples (sourced from the SWC Registry and OWASP Juice Shop), showing 80% detection accuracy (F1-score 80%) at a 22.9% total workflow overhead, plus detailed blockchain latency and verification measurements.
Main Findings
- Detection quality: Precision of 78%, recall of 82%, and an F1-score of 80%; the remaining 20% of cases were false positives requiring manual verification. Ground truth was established via manual code review and existing CVE mappings, with a true positive defined as a vulnerability correctly identified by both type and logical location.
- Overhead is moderate, not prohibitive: Total workflow time rose from 12.39 s (baseline) to 15.23 s (Zer0n), a 22.9% overhead. Analysis execution moved from 12.34 ± 1.21 s to 12.89 ± 1.35 s and report generation from 45.2 ± 8.1 ms to 48.7 ± 9.2 ms.
- The dominant cost is on-chain confirmation: Block confirmation averaged 14,200 ± 1,800 ms and network propagation on the Fuji testnet 2,180 ± 450 ms — the paper describes this as roughly 14–16 seconds. Because logging is asynchronous and occurs after report generation, it does not block the analysis workflow.
- Hashing is essentially free: SHA-256 hash computation took 0.82 ± 0.15 ms; transaction construction 12.4 ± 2.3 ms and signing 8.7 ± 1.8 ms.
- Verification is fast and exact: Local hash recomputation 0.79 ± 0.12 ms, on-chain hash retrieval 89.3 ± 18.7 ms, total verification 90.1 ± 18.9 ms, with tamper detection accuracy of 100.0% and a false positive rate of 0.0%.
- LLM reasoning beats static analysis on logic flaws (case study on
Reentrancy.sol): Slither correctly flagged the reentrancy pattern but issued a generic warning based on function state mutability; Gemini 2.0 Pro additionally deduced the multi-step attack vector involving a malicious fallback function and recommended the Checks-Effects-Interactions pattern. Slither alone could not provide context on the specific callback mechanism. - Determinism was engineered, not assumed: A temperature of 0.2 with structured chain-of-thought system prompts was used so that final vulnerability classification remained deterministic across valid runs, despite variation in the LLM's reasoning path.
- Threat model is scoped: Post-analysis report tampering and local artifact manipulation are considered and detected; blockchain consensus compromise, ledger denial-of-service, and active exploitation of vulnerabilities are out of scope, as is defending against compromise of the Node.js environment or the Gemini API connection up to the point of hash generation.
Methodology in Plain English
The team built a prototype with three loosely coupled parts. The analysis engine sends target information to Gemini 2.0 Pro through its API, following a five-phase workflow: reconnaissance and scope, discovery (crawling and technology fingerprinting), attack surface analysis (parameter discovery and AI-driven payload generation), exploitation (active validation with generated proofs of concept), and reporting. A Node.js/Express backend uses Puppeteer for headless browser automation so JavaScript-heavy applications can be analyzed dynamically, while a React and Vite dashboard handles coordination and visualization.
The integrity layer is deliberately lightweight. After a report is generated, the system computes a SHA-256 hash of it and writes only that hash plus minimal metadata to a Solidity smart contract on the Avalanche C-Chain, developed in Remix IDE and tested on the Fuji test network. Raw artifacts never leave the local machine. Anyone can later recompute the hash and compare it with the on-chain value; a mismatch proves the report changed after the analysis.
To evaluate, the researchers ran the system against 500 web application endpoints and 100 smart contract samples, comparing baseline analysis against the integrity-augmented workflow and measuring execution time, logging latency, hashing overhead, and verification cost across 100 independent runs on a workstation with an Intel Core i7-12700H (14 cores, 2.3 GHz base frequency), 32 GB DDR5 RAM, a 1 TB NVMe SSD, and Windows 11 Pro, using Python 3.11, scikit-learn 1.3.0, web3.py 6.11.0, and hashlib. All scanning was done against isolated testbeds such as OWASP Juice Shop and synthetic contracts.
Why This Matters
Impact on research: The paper reframes the problem of LLM reliability in security from "make the model more accurate" to "make the model's output verifiable," and offers a concrete, measured argument that a hybrid off-chain/on-chain split is more practical than fully decentralized designs that suffer high latency. It also gives the community a reusable measurement baseline for the cost of blockchain integrity logging, and it complements rather than competes with static analyzers such as Slither and Mythril.
Real-world applications:
- Compliance and audit trails for penetration tests and security assessments, where a client or regulator needs proof a report was not edited after delivery.
- Bug bounty and third-party audit workflows, where disputes over what was reported and when are otherwise hard to settle.
- Decentralized subscription and access control for security tooling, using the same contracts that already log integrity proofs.
- Multi-party incident response, where several organizations need a shared, tamper-evident record of findings from an adversarial environment.
Industry relevance: Security teams already worry about prompt injection, model hallucination, and adversarial manipulation of LLM outputs — risks catalogued in the OWASP Top 10 for LLM Applications 2025. Zer0n offers a cheap mitigation pattern (under 1 ms of hashing, under 100 ms of verification, tens of seconds of asynchronous confirmation) that DevSecOps pipelines could plausibly absorb, and it does so without the operational burden of IPFS or other decentralized storage.
Future Directions
- Multi-agent orchestration and reputation. The authors propose extending the model to multi-agent environments where reputation scores are tied to on-chain history, potentially creating a decentralized marketplace of trusted security auditors. Reputation-based contributor scoring appears in their table of conceptual future work.
- Automated incentives and payment. The prototype's implemented set covers analysis, hashing, and tamper-evident logging; automated incentive or payment mechanisms and continuous large-scale scanning pipelines are listed only as future work.
- Scale and coverage. The evaluation is explicitly a feasibility study with no large-scale deployment assessment and no claim of comprehensive vulnerability coverage — production-scale behavior remains unmeasured.
- Full release and safety review. The core Solidity contracts and integrity verification scripts have been released as a minimal public artifact, but the full AI analysis pipeline remains closed-source pending safety reviews, leaving reproducibility of the detection results as an open item.
Target Audience
Security researchers and graduate students working on AI-assisted vulnerability discovery; blockchain engineers interested in lightweight integrity and provenance patterns rather than decentralized storage; DevSecOps and application security practitioners evaluating whether tamper-evident logging can fit into real pipelines; and auditors or compliance teams who need verifiable evidence that a security report was not modified after generation. Readers seeking a rigorous large-scale benchmark of LLM vulnerability detection should note that this paper explicitly positions itself as a feasibility prototype, not a performance benchmark.
Authors’ abstract
As vulnerability research increasingly adopts generative AI, a critical reliance on opaque model outputs has emerged, creating a "trust gap" in security automation. We address this by introducing Zer0n, a framework that anchors the reasoning capabilities of Large Language Models (LLMs) to the immutable audit trails of blockchain technology. Specifically, we integrate Gemini 2.0 Pro for logic-based vulnerability detection with the Avalanche C-Chain for tamper-evident artifact…
The full abstract on arXiv