Solidity has undergone 116 version iterations between August 2015 and February 2026, during which compiler updates have introduced behavioral changes, including issues later fixed in subsequent releases. Contracts compiled under specific versions may exhibit version-dependent execution behaviors, particularly in low-level code. These differences are often difficult for developers and users to recognize, creating opportunities for adversaries to exploit legacy compiler behaviors and deploy contracts with potentially deceptive outcomes. We define this issue as the Compiler Version Discrepancy (CVD) risk , where attackers leverage compiler-version-dependent behaviors to produce misleading or unfair outcomes while contracts appear functionally benign. We summarize five representative CVD risk patterns from real compiler inconsistencies. To mitigate this risk, we develop the CompileGuard detection tool. It combines Abstract Syntax Tree (AST) analysis, taint analysis, and symbolic execution with Control Flow Graph (CFG) analysis to identify version-sensitive code patterns. Evaluation on 227 smart contracts shows CompileGuard achieves an overall F1 score of 95.22%. A user study with 21 blockchain practitioners shows contracts exploiting CVD risks can mislead users, while detection reports enable all participants to correctly identify risk-inducing behaviors. These results highlight the practical exploitability of CVD risks and the effectiveness of automated detection in preventing such deception.
An increasing number of special Internet of Things (IoT) applications are being deployed within federated and zero-trust (ZT) environments. These ad-hoc networks consist of heterogeneous, resource-constrained devices from various administrative domains, all of which are susceptible to compromise. The dynamic nature of these environments necessitates near-real-time Situational Awareness (SA), where processed data varies with its sensitivity and reliability, without dependence on a central authority. Examples include NATO and non-NATO coalitions engaged in hybrid military operations or humanitarian aid scenarios. To address the challenges of security, reliability, and context-aware data dissemination, we propose FedM, a multi-level formal model designed for context-aware and policy-driven data dissemination in federated IoT environments. This model is built upon various access control models and Denning’s research on information flow control (IFC), prioritizing the protection and reliability of data flows. A crucial element of this model is the distributed ledger, which facilitates the dynamic modification of label expressiveness, enhances resilience against disruption attacks, and separates policy logic from application functionality to mitigate risks associated with the benevolent developer. Additionally, we delineate a deterministic and history- and precedence-aware policy enforcement procedure to resolve conflicting actions and introduce processing primitives for the ongoing Data Quality Assessment (DQA) process. Our model also aligns with the concepts of Ubiquitous and Continuum Computing. Furthermore, in our paper we illustrate a policy-based dissemination pipeline, incorporating a bounded trustworthiness dimension. Additionally, we present a refined multi-layered framework that proposes the deployment of Information Flow Control (IFC) components, such as the Open Policy Agent decision engine, to facilitate policy-driven contextual data dissemination. We provide preliminary benchmarks for resource-constrained platforms, along with a formal threat model that addresses implicit flows, the benevolent developer problem, and the behavior of a distributed ledger under degraded network conditions. Finally, we conduct a formal verification of our model using the P framework.
Cryptographic software forms a critical foundation of modern computing systems, but the security guarantees of cryptographic protocols do not automatically extend to their implementations. Errors in arithmetic operations, validation logic, data conversion, constraint generation, or component integration can cause deployed software to deviate from the intended protocol while still producing plausible outputs. Such risks are difficult to detect in compiled binaries and become even more challenging in modern cryptographic systems such as zero-knowledge proofs, where implementations combine finite-field arithmetic, constraint systems, witness generation, proving procedures, verification logic, and serialization formats.Securing cryptographic implementations requires analysis techniques that can reason about both low-level program behavior and high-level cryptographic intent. To address this need, cryptographic function identification in binaries is first examined. It categorizes existing detection techniques, develops a unified benchmarking framework, and evaluates current tools through reproduction and replication studies across different compilers, optimization levels, obfuscation strategies, and algorithm variants. The second part introduces an automated security analysis framework for zkSNARK implementations that combines constraint checking with fuzzing-based testing to detect and locate cryptographic logic errors. This approach helps determine whether an implemented zkSNARK system correctly enforces the intended computation and security design. The third part develops a grey-box differential fuzzing approach for zero-knowledge proof binary applications. It uses structured input generation, coverage monitoring, control-dependency-aware taint tracking, and error localization to guide testing toward security-relevant code and expose inconsistencies in circuit construction, witness conversion, proof generation, and verification logic.Together, these contributions connect binary analysis, automated checking, and protocol-aware fuzzing to improve the practical security of cryptographic software. They provide methods for identifying implementation-level weaknesses that may remain hidden during ordinary testing, especially when programs produce valid-looking outputs despite incorrect cryptographic behavior. By combining systematic evaluation, zkSNARK-specific analysis, and binary-level testing, the resulting methodologies advance the development of more reliable techniques for analyzing, testing, and securing real-world cryptographic systems.
Validation of a secure blockchain architecture's effectiveness and robustness may be achieved via a methodical process that involves comprehensive testing and implementation in real-world environments. The testing process includes analyzing requirements, setting up the environment, and conducting detailed evaluations. All aspects of the smart contract, from its logic and functionality to its defences against common attack vectors like Sybil and re-entrancy vulnerabilities, are evaluated in these reports. Performance testing under different loads and realistic network conditions is essential for assessing scalability, latency, and throughput, in addition to API and integration testing, which ensure that system components operate well together. System resilience to defects and hostile events is tracked, critical test cases are automated, and large-scale peer-to-peer networks are modelled to evaluate the framework's robustness further. Supply chain verification and clinical trial administration are two examples of real-world applications of blockchain technology that demonstrate its ability to secure sensitive activities on a large scale. These use cases also give light on the system's efficacy, data integrity, and anomaly detection capabilities. Verifying the scalability, security, and reliability of a blockchain architecture against real business objectives via integrated deployments and complicated testing methods is essential for a safe blockchain.
The inherent challenge of balancing scalability, security, and decentralization – commonly termed the blockchain trilemma – continues to hinder the adoption of distributed systems. This paper presents InternxtChain, a decentralized storage framework designed to address this trilemma through a novel integration of erasure-coded sharding, zero-knowledge succinct non-interactive arguments of knowledge (zk-SNARKs), and a sharded Proof-of-Storage consensus mechanism. By leveraging aggregated BLS-381 signatures and distributed redundancy protocols, the framework achieves a throughput of 2,800 transactions per second with a latency of 420 milliseconds across 1,024 nodes, surpassing Filecoin by a factor of 3.5 and Ethereum’s capacity by 165 times. The system maintains 99.9% data integrity even under adversarial conditions involving 30% Byzantine nodes. Additionally, InternxtChain reduces storage costs to $0.002 per gigabyte, representing an 85% reduction compared to centralized alternatives like AWS S3. Empirical evaluations demonstrate linear scalability to 4,200 transactions per second with 2,048 nodes, alongside hardware affordability at $180 per node. These advancements not only outperform decentralized platforms in throughput by 2.8 times but also ensure GDPR-compliant data sovereignty, positioning InternxtChain as a pioneering solution for Web3 ecosystems seeking to harmonize enterprise-grade performance with decentralized trustlessness.
A controlled timestamp-only projection of an ABD-style multiwriter quorum-register tag leaves completed reads current, exact, and linearizable while omitting the writer-identity component of the full protocol tag. Correctness therefore does not imply auditability at a distributed read boundary. A deterministic five-state host gives the protocol-independent companion: four sequential operations are totally ordered in real time, yet the read boundary exposes no source evidence. For an external specification fixed before the realization is chosen, zero-error boundary recovery exists exactly when all co-encoding locations agree and native source evidence aligns with the specified source and derivation relation. Under edit-generated source semantics, boundary agreement is equivalent to temporal zero-delay synchronization. Disjoint audited systems compose, but two independently verified services can assign incompatible roles to one shared location. Value projection likewise fails to preserve auditability; a certified refinement law transports it. A CAP partition carrier induces the corresponding read-boundary discriminator, but carrier data alone cannot supply the scheduler continuations required for an FLP transport. Finite DLS histories yield an exact stabilization-certificate bound and exclude one fixed evidence budget across all horizons. Protocol and replicated-storage rows illustrate the criterion across distributed boundaries. The substrate-independent ledger records the broader scope. Lean 4 verifies the finite models, reductions, abstraction maps, and internal bounds; the premises linking named systems to those models remain documentary.
Proof of Work (PoW) and Proof of Stake (PoS) remain the dominant consensus mechanisms for public blockchains, yet both suffer from well-documented limitations: PoW incurs prohibitive energy costs and scales poorly with network size, while PoS tends to concentrate validator influence among large stake holders, reintroducing a form of economic centralization.This paper proposes Proof of Effort (PoE), a novel consensus mechanism in which validator eligibility is determined exclusively by verifiable, continuous protocol participation rather than by computational expenditure or financial stake.PoE integrates four lightweight security primitives -node-identity binding via asymmetric key pairs, sequence-number-based replay prevention, digital-signature message authentication, and threshold-based malicious-node detection -chosen specifically to impose negligible per-node overhead while maintaining Byzantine resilience.We formalize the effort accumulation model mathematically, provide a detailed pseudocode specification of the protocol, and evaluate the mechanism through an agent-based simulation implemented in NetLogo 6.4 with 500 heterogeneous agents (350 honest, 150 adversarial).Simulation results, presented with full graphical and tabular support, demonstrate that PoE achieves an average throughput of 900 tx/s (vs. 25 tx/s for PoS and 7 tx/s for PoW), reduces average consensus latency to 56 ms (vs.400 ms and 1,200 ms), and correctly identifies 92-97% of malicious agents while accepting fewer than 0.2% of forged or replayed messages.The effort gap between honest and adversarial nodes remained below 0.21%, confirming protocol fairness under adversarial load, and the validator-selection Gini coefficient of 0.18 represents a 71% improvement in participation equality over PoS.These results position PoE as a compelling candidate for permissioned and consortium blockchain deployments where energy efficiency, participation fairness, and lightweight security are primary requirements.
Ethereum, one of the largest blockchain platforms, manages millions of dollars in digital assets daily and depends on consistent community standards and cohesive implementations to maintain network consensus. This study introduces a novel methodology for identifying and measuring temporal inconsistencies in opcode mappings across Ethereum clients and the Solidity compiler. Using this methodology, we uncover significant and previously undocumented discrepancies both among different components of Ethereum’s implementation and between theoretical specifications and practical execution behavior. We further demonstrate the potential consequences of these inconsistencies by illustrating their impact on the detection of vulnerabilities in Solidity smart contracts. Such discrepancies can substantially undermine the accuracy and reliability of vulnerability analysis, highlighting the critical need for strict consistency in Ethereum’s operational semantics. Ensuring this consistency is essential for preserving transaction security and the overall robustness of the platform.
Vabuk Pahari, B. Chandrasekaran, Johnnatan Messias, Krishna P. Gummadi · 5 authors
A decentralized autonomous organization (DAO) is a governance entity that allows its stakeholders to manage blockchain-based protocols through smart contracts. The DAO explicitly specifies how stakeholders make and enforce decisions concerning a protocol's operation in a smart contract, aptly referred to as its governance contract. The design of this governance contract, therefore, has far-reaching implications for the security (trust) and privacy (transparency) of the smart contracts managed by the DAO and its stakeholders. In this work, we (i) explicate the trust and transparency trade-offs of the design choices in implementing a DAO and (ii) highlight how poor choices introduce critical vulnerabilities, using real-world examples as case studies. To this end, we analyze $48$ public, actively used Ethereum-based DAOs that control a vast capital. We classify the design choices into a handful of key dimensions that succinctly capture how a DAO's stakeholders initiate a protocol change, vote on it, and, based on the voting outcome, execute that change. Our analyses crucially uncover a new class of attacks, which we call governance attacks, that directly exploit the fundamental design of a DAO's governance mechanisms, even if we assume bug-free implementations.
Blockchain technology provides a decentralized and secure data-management system. However, PoW consensus remains vulnerable to the risk of 51% attacks, where a single miner or pool controls over half of the network and can manipulate blocks and execute double-spending. This paper proposes a defense mechanism called Consensus-Level Restriction (CLR) for Ethereum Classic. It limits the number of sequential blocks from a single miner to reduce the feasibility of 51% attacks. We evaluated the effectiveness of CLR by using BlockSim simulator. Results show that CLR reduces the success rate of 51% attacks while maintaining a decentralized structure. This work strengthens blockchain security without compromising PoW principles.
Arman Kolozyan, Tom Sorger, Alexander Hicks, Stefanos Chaliasos
Zero-knowledge proofs (ZKPs) have become a core technology for privacy and verifiable computing. They are used to secure blockchains that handle billions of dollars and identity applications dealing with sensitive personal data. However, ZKP systems are complex, and subtle implementation errors can completely break their guarantees, letting attackers forge money or false proofs of identity. Researchers and practitioners have therefore developed a growing set of bug detection and formal verification methods to secure these systems. Yet their real-world effectiveness and adoption remain unclear. In this paper, we aim to shed light on the state of ZKP security tooling. We first systematize the landscape of these tools and observe that most target Circom, leaving newer DSLs and zkVMs with limited support. We then evaluate six tools across 70 real-world vulnerabilities and find that while the tools detect 45.7% of bugs on isolated targets, their effectiveness drops to 19.6% on full codebases, with important vulnerability classes left unaddressed. We also present the first systematic analysis of formal verification efforts, revealing that current work focuses primarily on constraint correctness and identifying key gaps and risks. Finally, we survey 48 practitioners, showing that development and security remain human-led, LLMs are widely used, and practitioners prioritize tools with clearer guarantees and lower integration effort. Overall, our results highlight the need for better integration of security tooling with the development and auditing process, and we provide actionable insights for researchers and practitioners.
Ethereum non-fungible tokens (NFTs) implement ownership, transfer, authorization, and metadata operations through smart contracts, making contract vulnerabilities a direct risk to digital assets. Existing static analyzers provide efficient rule-based screening but can struggle with application-specific logic, whereas unconstrained large language model analysis may be distracted by irrelevant code or produce inconsistent outputs. We present a vulnerability-detection method that combines vulnerability-focused code slicing, an ERC-721-oriented knowledge base, and constrained DeepSeek analysis. Regular-expression patterns locate candidate statements for reentrancy, integer overflow or underflow, and timestamp dependence. A structure-aware context-window algorithm then extracts line-numbered code slices. DeepSeek analyzes each slice using explicit decision rules and a fixed output schema, and the resulting records support automated batch processing. On 450 NFT contract samples, the full configuration produced 437 positive labels, corresponding to a reported positive-label rate of 97.1%. Removing the external knowledge base reduced this rate to 87.11%, while analyzing complete contracts without the knowledge base reduced it to 73.78%. These results indicate that focused code context and domain constraints materially affect the detector's reported output.
Autonomous AI agents increasingly execute actions, invoke tools, and operate on protected resources with limited human oversight. Existing authentication and authorization mechanisms establish identity and delegate authority, but do not inherently provide cryptographic evidence that a concrete request issued by a specific agent satisfies the applicable policy in a specific execution context. This paper hypothesizes that agent authorization can be formalized as a cryptographically verifiable relation, denoted $R_{CVA}$, that jointly binds an agent principal, a concrete authorization request, an execution context, and the satisfaction of an applicable policy, while selectively preserving the confidentiality of private authorization attributes. We introduce a preliminary formal abstraction for Cryptographically Verifiable Agent Authorization (CVA), define a compact set of candidate security properties including authorization soundness, principal binding, request binding, policy binding, and replay resistance, and provide an executable zero-knowledge proof of concept that instantiates selected elements of the model over a Groth16 zk-SNARK construction. We further identify and formalize the structural separation among identity binding, authorization-request binding, and runtime execution binding as a central open problem in the design of secure agentic systems (a distinction {not explicitly addressed by} current agentic security frameworks) and present a falsifiable research agenda for its resolution.
Zero-Knowledge Ethereum Virtual Machines (zkEVMs) secure Ethereum rollups by generating zero-knowledge proofs that guarantee off-chain execution correctness. However, subtle implementation bugs (e.g., incorrect gas accounting) can lead to valid proofs certifying semantically faulty states, thereby silently defeating cryptographic guarantees. Formal verification via SMT solvers can prevent this, but is bottlenecked by specification: current zkEVM development practice lacks automated methods to translate Rust opcode handlers into verification models. Current practices rely on unsustainable manual specifications, while LLM-based approaches suffer from hallucination and lack formal guarantees. To address this, we propose VeriSynth, a framework that synthesizes executable Python/Z3 verification models from Rust zkEVM code. VeriSynth enforces a hybrid paradigm: an LLM acts strictly as a formalization frontend to translate code into symbolic constraints, while an SMT solver serves as the correctness arbiter. To handle complex multi-component state transitions, VeriSynth integrates semantic decomposition, retrieval-grounded prompting, and verification-guided auto-repair into a closed-loop pipeline. We evaluate VeriSynth on the first source-level zkEVM verification benchmark, encompassing both correct and faulty opcode implementations. VeriSynth achieves a bug detection rate of over 90%, substantially outperforming direct and conversational LLM baselines, as well as a production-grade handwritten mutation-testing suite. Ablation studies confirm that each pipeline component is critical to the framework's overall effectiveness.
This dataset accompanies the paper An Architectural and Empirical Study of Root-Only Zero-Knowledge Verification and contains the scripts, intermediate artifacts, and published results used to reproduce the empirical evaluation. The repository is organized around two experiment groups: Blockchain-Side Deployment and Verification: deployment and Groth16 proof verification on Ethereum Sepolia and zkSync Sepolia, including contract sources, Merkle-tree inputs, Groth16 proofs, and blockchain measurement CSVs and figures. ZKP proving and off-chain verification: Constraint-count comparison — Groth16 R1CS constraint counts and expanded PLONK gate counts for Merkle-tree depths 5–15, with measurement scripts and summary CSVs/figures. Proving-time comparison — off-chain Groth16 and PLONK proving benchmarks across depths 5–15, including proving scripts, generated witness/proof/key artifacts, and benchmark CSVs/figures.
Contemporary AI governance regimes (GDPR, the EU AI Act, NIST AI RMF) operate declaratively: they mandate outcomes but provide no computational mechanism by which compliance can be verified at execution time without exposing the underlying data. This produces a structural verification asymmetry, the cost of proving integrity is borne by the auditor, who must inspect raw data the operator cannot lawfully or commercially disclose. We propose ZEGA (Zero-Knowledge Execution Governance Architecture), a governance layer in which execution logs are committed cryptographically at capture time, anomaly predicates are evaluated inside zero-knowledge circuits, and regulators verify a succinct proof of integrity without observing a single record. We formalize an Integrity Debt metric ID, quantifying accumulated unverified execution mass, and specify an empirical pipeline over Google BigQuery public datasets (GitHub Archive, 2011–present; >8 billion events) that operationalizes ZEGA’s anomaly-filtering and commitment stages at planetary scale. Executed over a 30-epoch window of 112 million real execution events, the pipeline demonstrates that predicate evaluation is tractable within commodity cloud infrastructure at a stable anomaly base rate of 0.0137% (CV = 0.269). A seven-year longitudinal extraction (2020–2026; 25.4 million events) shows execution volume persistently concentrated in the top decile of actors (66.2% mean share, CV = 0.097), establishing that the baseline ZEGA predicates are calibrated against is structural, not seasonal. We further execute a live zero-knowledge instance over a committed one-hour epoch (45,674 actors), proving the anomaly-rate predicate with a real BN128-curve argument that discloses a single verdict bit and survives forgery and tamper tests, establishing ZK verification with proof size O(log N) and verification time independent of N. ZEGA converts governance from attestation to mathematics: the regulator’s question changes from “show us your data” to “show us your proof.”
Xianhao Zhang, J F Sun, Zijian Zhang, Ye Liu · 7 authors
Smart contract vulnerabilities pose severe financial risks, yet existing security tools largely stop at vulnerability detection, offering limited support for explaining whether reported flaws are exploitable, how attacks unfold, and what concrete damage they cause. To bridge this gap, we propose KASS (Knowledge-Augmented Attack Synthesis and Simulation), a multi-agent framework for executable smart contract exploit verification. KASS decomposes automated exploit generation into planning, generation, and testing stages, and integrates three complementary mechanisms: retrieval-augmented planning over real-world audit knowledge, formal generation and validation constraints that bind attack plans to executable proof-of-concept tests, and a hierarchical dual-loop refinement process that repairs code-level errors while triggering strategy-level replanning when attack assumptions fail. We evaluate KASS on 104 SmartBugs-Curated contracts across four vulnerability categories. Experimental results show that KASS successfully generates executable exploits for 94.23% of tested contracts; this rate is higher than previously reported results for REX and AdvSCanner on comparable SmartBugs-Curated subsets, and higher than our reproduced Claude Code baseline under the same evaluation protocol. On 11 real-world CVE-tagged contracts, KASS successfully validates 9 cases. Beyond exploit generation, KASS produces structured attack plans that document exploitation flows, quantify potential asset losses, and serve as semantic false positive filters for static analysis tools.
# VeriSBOM: Secure and Verifiable SBOM Sharing Via Zero-Knowledge Proofs **VeriSBOM**, a trustless, selectively disclosed SBOM framework that provides cryptographic verifiability of SBOMs using zero-knowledge proofs. Within VeriSBOM, third parties can validate specific statements about a delivered software, mainly regarding the authenticity of the dependencies and policy compliance, without inspecting the content of an SBOM. Respectively, VeriSBOM allows independent third parties to verify if a software contains authentic dependencies distributed by official package managers and that the same dependencies satisfy rigorous policy constraints such as the absence of vulnerable dependencies or the adherence with specific licenses models. ## Key Features * **Selective Disclosure (Hiding):** Choose which proprietary components to hide from the public SBOM. The system generates a cryptographic proof that replaces the plaintext data, guaranteeing privacy. * **High-Performance Folding:** Powered by **Nova-Scotia**, utilizing recursive SNARKs to handle SBOMs. * **Interactive Dashboard:** A complete 4-step workflow (Package Manager, Auditor, Vendor, Client) built with **Streamlit**. ## Repository structure The repository contains three main folders: 1. **Empirical**: contains **Benchmarking** and **src**, for the analysis and source code, respectively. 2. **User study**: contains the code and results of the user study. 3. **README_Doc**: contains the images used for this documentation. ## VeriSBOM Architecture The system is divided into four main roles: 1. **Package Manager**: Maintains the package repository with the allowed packages. 2. **Auditor:** Represents the regulatory body marking the compliance status by checking the packages of the package manager. 3. **Software Vendor:** Represents the entity that provides software artefacts and wants to hide the related SBOMs for privacy reasons. He is responsible for the generation of the cryptographic proofs as verifiable substitutes of the hidden packages in SBOMs. 4. **Client:** The end-user who receives the cryptographic proofs along with the software artefact for verifying binding, inclusion and compliance status. ## Web Access (Recommended) **For direct access to the artefact, VeriSBOM can be accessed at this public link** https://verisbom-verisbom-software.hf.space ## Setup & Installation Follow the README within the artefact ## Operational Workflow The application follows a **linear workflow** composed of four steps. Each step depends on the output generated in the previous one. > **Performance Note** Due to the cryptographic operations involved, generating proofs may take some time depending on the number and complexity of the active policy constraints. In the current reference environment, proof generation takes approximately **~5 seconds**, while verification takes around **~3 seconds per proof**. ## Step 1 — Package Manager In this step, the **Package Manager initialises the package repository**. ### Instructions 1. Open the **Package Manager** tab. 2. Click **`Load repository`**. > For convenience, the system automatically loads a **default repository containing packages from the NPM ecosystem**. ### Expected Output After successful execution: - A **green confirmation message** is displayed. - The **package list** appears on the left panel. - The **dependencies of each package** can be inspected on the right panel using the search bar. - A **dependency graph** is displayed at the bottom of the interface. ## Step 2 — Auditor In this step, the **Auditor defines policy constraints** that will be applied to the packages in the repository. ### Instructions 1. Enter a **policy name** (e.g., `Vulnerabilities`, `MIT License`). 2. Click **`Add`** to create the policy constraint. 3. Use the **search bar** to locate target packages. 4. **Uncheck packages** to mark them as **non-compliant**. > By default, **all packages are marked as compliant**. 5. Click **`Save and Propagate`** to apply the policy. ### Optional - Repeat the previous steps to create additional policy constraints. - Remove policies that are no longer required. ### Expected Output - A **green confirmation message** appears. - A **dependency graph visualisation** shows how non-compliance propagates across dependencies for the selected policy (or combination of policies). ## Step 3 — Software Vendor In this step, the **Software Vendor generates cryptographic proofs for a given SBOM**. ### Instructions 1. Upload a **local SBOM file**. > For demonstration purposes, the system automatically loads an **example SBOM**. 2. In the **Selective Disclosure** section: - Select which SBOM packages should be used for proof generation. 3. Click **`Generate Proofs`**. 3. Click **`Download`**. - Download the SBOM with hidden components and plaintext components ### Expected Output - A **progress bar** indicates the proof generation process. - **Green confirmation messages** appear once proofs are generated successfully. > **Important:** Successful proof generation only means that the **cryptographic proof has been constructed correctly**. Compliance with policies is verified only in **Step 4**. ## Step 4 — Client In the final step, the **Client verifies the proofs generated by the vendor**. ### Instructions 1. Upload the **SBOM**. 2. Select a **policy** from the dropdown menu. 3. Click **`Verify`**. ### Expected Output - **Verified (green badge)** The SBOM satisfies the selected policy. - **Failed (red badge)** The verification failed, and the interface displays the reason for the failure.
Digital communication increasingly underpins identity, financial transactions, and regulatory compliance. In many settings, possession of a DKIM-signed email serves as evidence of account control, transaction confirmation, or institutional affiliation. Yet demonstrating such properties typically requires revealing the full email or relying on centralized intermediaries, introducing privacy risks and additional trust assumptions. A framework called ZK Email addresses this limitation by applying zero-knowledge proofs (ZKPs) to email verification, enabling publicly verifiable proofs of authenticity while preserving message confidentiality. However, its existing implementations struggle to support complex, real-world messages due to the inefficiency of regular-expression verification over structured formats and rich alphabets. We address this limitation with a new ZKP system for regex matching based on path verification over epsilon-free NFAs, yielding prover complexity linear in the captured path and independent of the original email's size. This approach enables practical validation of expressive standard structures required for full DKIM-signed email verification. To fully integrate our constructions into ZK Email, we design complete end-to-end ZK circuits that combine (i) DKIM signature verification, (ii) an arbitrary-length SHA-256 circuit with partial precomputation for rsa-sha256 under RFC~6376, and (iii) a general-purpose regex primitive enforcing structural constraints over email headers and body. We formalize the associated zero-knowledge relations and analyze their security under realistic adversary models. We implement the system~(fully integrated with ZK Email and released under the MIT license) in Circom and Noir, targeting Groth16 and UltraHonk backends, and evaluate it in both client-side and zkVM (SP1) deployment settings. Experimental results on a comodity hardware demonstrate substantial efficiency improvements over prior DFA-based approaches, achieving 2-6x in proving time using UltraHonk backend, while supporting a significantly richer class of regex languages.
Zhongjing Wei, Osaid Muhammad Ameer, Nikita Borisov, Yupeng Zhang
Modernizing the security of operational technology systems that control critical infrastructure has become a pressing challenge. Because edge devices have limited capabilities, modernization has relied on application gateways that interface with identity management systems and enforce access policies. These gateways are powerful enough to perform complex authorization decisions and support zero-trust architectures, but they create major deployment and management burdens: they must be collocated with remote, distributed edge devices, kept up to date with security patches, and managed with minimal downtime. We propose Provable Remote Execution of Zero-Trust Authorization (Prezta), an architecture that eliminates these gateways by evaluating policies within a zero-knowledge virtual machine (zkVM) running on the client. The zkVM produces a succinct proof of authorization that edge devices can verify efficiently, extending the zero-trust security envelope to the edge. Policies and identity management schemes can evolve without updating edge devices. To demonstrate the feasibility of Prezta, we implement a prototype built using the RISC Zero zkVM that supports XACML 3.0 policies and JWT identity claims. While zkVMs introduce substantial proof overhead, we mitigate this overhead by compiling policies to Rust code and precompiling regular expressions. Combined with optimized signature verification and JWT parsing, these measures reduce prover time by more than an order of magnitude. Our compiler correctly implements 83\% of the XACML 3.0 conformance suite, with proof generation completing in tens of seconds on a desktop. Verification, by contrast, takes only tens of milliseconds, which is fast enough for resource-constrained edge devices.
Project Name: PR-DataShield Summary: This technical disclosure introduces PR-DataShield, a lightweight, zero-trust, event-driven security gateway architecture designed to secure distributed source code supply chains at the boundary of version control integration. By decoupling repository-level change requests from localized security operations, the framework utilizes asynchronous webhooks, serverless relational data persistence, and tokenized downstream feedback mechanisms to construct a deterministic code-gate keeper. Key Architectural Features: Event-Driven Ingestion: Utilizes structured cryptographic JSON payloads for secure PR event interception. Multi-Route Gateway: Implements redundant endpoint mapping to ensure operational continuity and resilient webhook delivery. Immutable Audit Ledger: Enforces transactional persistence via a serverless PostgreSQL cluster, guaranteeing non-repudiation of security logs. Asynchronous Feedback Loop: Automatically updates the host repository with an isolated markdown audit badge, providing immediate and immutable visual proof of security logging. Experimental Validation: Empirical verification conducted on July 11, 2026, demonstrated a sub-second response latency (0.27s) for the complete end-to-end security audit loop. This architecture establishes an immutable audit trail, effectively mitigating unauthorized code injection and supply chain tampering risks in modern CI/CD pipelines. Repository: https://github.com/apps/pr-datashield-bot
Zero-knowledge succinct non-interactive arguments of knowledge (zkSNARKs) are a key technology to privacy-preserving applications today. The complexity of proof generation, however, heavily constrains throughput in latency-sensitive environments. The computational burden primarily stems from two fundamental algorithms: Multi-Scalar Multiplication (MSM) and the Number Theoretic Transform (NTT). We propose a series of optimizations for these two kernels, including computation-transfer pipelining, load balancing, and memory access fusion, achieving 1.97 × to 2.16 × proof generation speedup over a state-of-the-art open source GPU acceleration library. Our design also supports out-of-core computation, enabling the generation of large-scale ZKP proofs.