[Paper] Zer0n: An AI-Assisted Vulnerability Discovery and Blockchain-Backed Integrity Framework

Source: arXiv - 2601.07019v1

Overview

The paper presents Zer0n, a hybrid framework that couples the reasoning power of large language models (LLMs) with the tamper‑evident guarantees of blockchain. By letting an LLM (Gemini 2.0 Pro) spot potential software vulnerabilities and then anchoring its findings on the Avalanche C‑Chain, the authors aim to close the “trust gap” that arises when security tools rely on opaque AI outputs.

Key Contributions

• AI‑driven vulnerability detection: Integration of a state‑of‑the‑art LLM (Gemini 2.0 Pro) to generate logic‑based vulnerability hypotheses from code and configuration artifacts.
• Blockchain‑backed audit trail: Use of Avalanche C‑Chain to store cryptographic proofs (hashes, Merkle roots) of AI‑generated findings, providing immutable, publicly verifiable evidence.
• Hybrid off‑chain/on‑chain architecture: Execution of heavy AI inference stays off‑chain for speed, while only lightweight integrity proofs are committed on‑chain, avoiding the latency of fully decentralized solutions.
• Empirical evaluation: Experiments on 500 real‑world endpoints show ~80 % detection accuracy with a modest 22.9 % runtime overhead compared to a baseline AI‑only scanner.
• Open‑source prototype: The authors release a minimal reference implementation, encouraging community replication and extension.

Methodology

1. Data Ingestion – Source code, binaries, and configuration files from target endpoints are collected and pre‑processed into a uniform representation (e.g., abstract syntax trees, dependency graphs).
2. LLM Reasoning – The pre‑processed artifacts are fed to Gemini 2.0 Pro via a prompt template that asks the model to “explain any logical flaw or insecure pattern.” The model returns a structured vulnerability report (type, severity, location, rationale).
3. Proof Generation – For each report, Zer0n computes a deterministic hash of the report content and bundles it into a Merkle tree. The root hash is signed with the framework’s private key.
4. On‑chain Commitment – The signed root hash is submitted as a transaction to the Avalanche C‑Chain. The transaction’s receipt serves as an immutable timestamped proof that the AI‑generated report existed at that moment.
5. Verification – Auditors or downstream tools can retrieve the on‑chain receipt, recompute the hash from the stored report, and confirm integrity without needing to trust the LLM’s internal weights.

The workflow runs entirely on commodity hardware; only the final hash commitment incurs blockchain latency (≈ 2 seconds on Avalanche).

Results & Findings

The modest overhead stems mainly from cryptographic hashing and transaction submission; the LLM inference time dominates both systems. The authors also performed a tamper‑simulation test, showing that any post‑hoc alteration of a vulnerability report is instantly detectable by mismatched hashes.

Practical Implications

• Developer tooling – IDE plugins could embed Zer0n to auto‑suggest security findings while simultaneously logging them on a public ledger, giving security teams non‑repudiable evidence for compliance audits.
• Bug‑bounty platforms – Researchers can submit AI‑generated vulnerability claims with on‑chain proofs, reducing disputes over “who discovered it first.”
• Regulated industries – Financial and healthcare software must demonstrate rigorous change‑control; Zer0n’s immutable audit trail satisfies many regulatory requirements (e.g., GDPR, NIST 800‑53).
• Supply‑chain security – When scanning third‑party libraries, organizations can retain a blockchain‑anchored record of each scan, enabling downstream consumers to verify that a component was vetted at a specific point in time.
• Incident response – Post‑mortem analyses can reference the exact AI reasoning that triggered an alert, backed by a tamper‑evident log, improving root‑cause transparency.

Limitations & Future Work

• Model opacity remains – While the integrity of the output is provable, the internal reasoning of Gemini 2.0 Pro is still a black box; the framework does not provide explainability beyond the model’s textual rationale.
• Scalability to massive codebases – The current prototype processes endpoints sequentially; parallelizing across clusters and batching on‑chain commitments will be needed for enterprise‑scale CI pipelines.
• Blockchain cost model – Although Avalanche’s fees are low, high‑frequency scanning could still incur non‑trivial transaction costs; future work may explore layer‑2 batching or alternative commitment schemes (e.g., zk‑SNARKs).
• Adversarial attacks on the LLM – Prompt injection or data poisoning could degrade detection accuracy; hardening the prompt pipeline and incorporating model‑level defenses are open research directions.

The authors suggest extending Zer0n to support multiple LLM providers, richer proof formats (e.g., verifiable computation), and tighter integration with existing DevSecOps platforms.

Authors

• Harshil Parmar
• Pushti Vyas
• Prayers Khristi
• Priyank Panchal

Paper Information

• arXiv ID: 2601.07019v1
• Categories: cs.CR, cs.AI, cs.SE
• Published: January 11, 2026
• PDF: Download PDF