Research
Software Supply Chain Security of Web3
Web3 applications manage billions of dollars in digital assets, but they are, first and foremost, software built on long chains of third-party dependencies.

- arXiv
- 2511.12274
- Published
- 2025-11-15
- Authors
- Martin Monperrus
AI summary
Overview
Research area: Software supply chain security, with a focus on how classic dependency and build-pipeline attacks play out in blockchain-based (Web3) systems.
Technical level: Intermediate. The paper is a conceptual threat-model and mitigation survey, not a paper requiring deep cryptographic or program-analysis background. Familiarity with package managers, CI/CD, and basic blockchain concepts (smart contracts, wallets, RPC) is helpful but the paper defines its terms.
Scope (one sentence): The paper is a systematic analysis of software supply chain attack vectors across every layer of a Web3 system — blockchain nodes, smart contract libraries, development tools, frontends, hosting, and wallets — together with a defense-in-depth mitigation strategy.
Publication details: arXiv:2511.12274v1 [cs.CR], 15 Nov 2025, single author (Martin Monperrus, KTH Royal Institute of Technology & mab.xyz).
What This Paper Is About
Web3 applications manage billions of dollars in digital assets, but they are, first and foremost, software built on long chains of third-party dependencies. The author argues that while traditional (Web2) supply chain attacks mainly harm availability and confidentiality, the same attacks in Web3 lead to direct, irreversible theft of funds because blockchain transactions are final and smart contracts are hard to patch. The goal is to build the missing systematic threat model for Web3 supply chain attacks and to propose concrete defenses.
Key Contributions
- A characterization of what makes Web3 different. The paper identifies four properties — immutability, transparency, finality, and pseudonymity — and explains how each amplifies the consequences of a supply chain compromise relative to conventional software.
- A layered threat model. It enumerates attack vectors across blockchain nodes, smart contract dependencies, frontend libraries, wallet software, development tools and build systems, hosting/DNS, plus governance, oracles, and AI coding assistants, and consolidates them into a single table (Table I) organized by layer and attack mechanism.
- A defense-in-depth mitigation strategy. It proposes combining technical controls (dependency verification, reproducible builds, sandboxed builds, multi-signature deployment, ERC-7936 proxy version pinning), process measures (specialized frontend and smart contract audits, incident response planning, developer education), and continuous monitoring of both frontend and on-chain components.
- A scoping boundary. The author explicitly states the paper does not cover the reverse direction — how Web3 technology could improve traditional software supply chain security.
Main Findings
- RPC endpoints are an invisible single point of failure. Most dApps rely on third-party node providers such as Infura, Alchemy, or Dwellir rather than running full nodes; a compromised RPC endpoint can return falsified balances, fabricated transaction histories, or manipulated contract state, and this is invisible to both users and developers because the application "seems to function normally."
- On-chain libraries enable many-to-one compromise. Unlike npm-style dependencies that are copied into each deployment, an upgradeable on-chain library can be maliciously upgraded once and affect every dependent contract in a single transaction. The 2017 Parity Multisig wallet hack, where a shared library vulnerability led to $150 million in frozen funds, is cited as the demonstration.
- Transaction parameter manipulation is the signature Web3 frontend attack. A compromised frontend dependency can rewrite the recipient address, raise token approvals to the maximum uint256 value, or substitute malicious calls before the user signs; because the user's signature cryptographically authorizes the altered transaction, it is indistinguishable on-chain from a legitimate one.
- The Bybit case shows the attack at scale. In the 2025 Bybit attack, a compromised Safe dApp frontend JavaScript dependency modified the parameters of a multi-signature wallet transaction before signing, resulting in the theft of $1.5 billion in assets, despite the transaction appearing legitimate and being signed by multiple authorized parties.
- Wallet dependency trees inherit full key privileges. Every package in a wallet's dependency tree — cryptographic libraries, JSON-RPC clients, UI frameworks — executes with access to private keys, seed phrases, and signing operations. The 2023 Ledger Connect Kit compromise is cited, where control of a library used by Ledger's browser extension let attackers prompt users to approve fund-draining transactions.
- Hosting and DNS compromise bypasses the entire build pipeline. Attackers who obtain hosting credentials, or who hijack DNS to point a legitimate domain at a cloned dApp, never touch source code or build checks. The 2021 BadgerDAO incident, in which compromised Cloudflare API credentials were used to inject malicious scripts for $120 million in losses, is given as the demonstration.
- Development tooling is a privileged, centralized target. A malicious Solidity compiler could inject backdoors so that deployed bytecode differs from the audited source; IDE extensions can exfiltrate deployment keys stored in environment variables (illustrated by the 2025 incident of Visual Studio Code extensions found to steal cryptocurrency); and frameworks such as Hardhat, Truffle, and Foundry control key management, compilation, and deployment, making a single compromised npm package a potential ecosystem-wide failure.
- Governance and oracle software extend the supply chain off-chain. Compromised off-chain voting platforms such as Snapshot can alter proposal text or display falsified results, and since these votes lack on-chain immutability, they can launder unauthorized on-chain actions. Compromised oracle software — or poisoned upstream data sources — can push false prices or results on-chain, since oracles verify integrity but not accuracy.
- AI-assisted coding introduces a training-data supply chain. The paper describes "vibe coding" attacks where backdoored code planted in open-source repositories poisons model training data and resurfaces as AI suggestions. A 2024 incident is cited in which a user lost $2,500 after deploying AI-generated Solana meme token bot code containing a private-key-stealing backdoor, traced to poisoned GitHub repositories targeting ChatGPT's training data.
- Historical Web2 incidents foreshadow the crypto-specific risk. The 2016 left-pad incident (an 11-line npm package removal breaking thousands of projects) and the 2018 event-stream attack (a malicious maintainer adding cryptocurrency-stealing code to a popular npm package) are used to establish the fragility of dependency chains and the precedent of crypto-targeted supply chain attacks.
- The paper states no empirical measurement. It reports no dataset, benchmark, or quantitative evaluation of its own; all figures are drawn from cited incidents.
Methodology in Plain English
The author takes an architectural approach rather than an experimental one. First, the paper decomposes a typical Web3 system into its layers — blockchain nodes, smart contracts, frontend, wallet software, plus development and hosting infrastructure — and notes where each layer pulls in third-party code. Second, for each layer it reasons about what an attacker who controls a component in that layer could actually do, and grounds each hypothesized vector in a documented real-world incident (Parity, BadgerDAO, Ledger Connect Kit, ua-parser-js, Bybit, and others). Third, it consolidates these into a single table mapping layer to attack mechanism, and then walks through countermeasures layer by layer, from dependency pinning and reproducible builds before deployment, through sandboxed CI/CD and multi-signature deployment during it, to monitoring and incident response after it.
No experiments, no survey data, no prototype tool, and no evaluation of the proposed mitigations are reported in the supplied content.
Why This Matters
Impact on research: The paper argues that "a systematic analysis of supply chain attack vectors specific to Web3 is missing," and positions itself as filling that gap by carrying over the Web2 supply chain literature into a setting where consequences are financial and irreversible. It gives researchers a shared vocabulary (layer × mechanism) and points to under-studied areas such as on-chain library upgrade risk, frontend transaction-construction integrity, and training-data poisoning for AI coding assistants.
Real-world applications:
- dApp frontend teams can use the transaction-construction threat analysis to decide which dependencies are allowed to touch transaction objects before they reach the wallet.
- Protocol and DAO operators can adopt the recommended multi-signature plus timelock deployment and upgrade patterns, and treat off-chain governance platforms as part of the security perimeter.
- Wallet vendors can treat their transitive dependency trees as key-material-adjacent code and apply the corresponding review and monitoring.
- Auditors and security teams can use the proposed frontend audit checklist — verifying that npm packages match published versions, reviewing transaction construction logic, and confirming the deployed application matches audited source.
Industry relevance: The cited losses — $625 million (Ronin Network bridge), $1.5 billion (2025 Bybit), $150 million (2017 Parity), $120 million (2021 BadgerDAO) — make the case that supply chain security is now a direct custody risk for Web3, not a hygiene issue. The paper's recommendations map onto tooling that already exists (npm audit, Slither, Dependabot, Renovate, Tenderly, Forta, Etherscan, Sourcify, Blockscout, HashiCorp Vault, AWS Secrets Manager, OpenZeppelin TimelockController), which lowers the barrier to adoption.
Future Directions
The provided content is truncated during the post-deployment monitoring section, and the paper does not report an explicit future-work agenda. The open questions the analysis raises are:
- How can a malicious upgrade to an on-chain library be contained in practice? The paper offers ERC-7936 — an interface letting callers explicitly select which implementation version to interact with, so clients can keep using audited versions after a malicious upgrade — as a mitigation, but whether dependent contracts and clients would actually adopt version pinning is not evaluated.
- Can smart contract bytecode be reliably tied to audited source? The paper recommends reproducible builds, build provenance attestations, and diverse double compilation, but does not report measurements of how reproducible real Web3 builds currently are.
- How should AI coding assistants be governed as a supply chain component? The described training-data poisoning vector has no proposed control in the content provided beyond the general call for developer education and dependency review.
- What does effective runtime detection look like across frontend and on-chain layers simultaneously? The monitoring tools named (Dependabot, Renovate, Tenderly, Forta) each cover one side; how to correlate frontend deployment changes with anomalous on-chain behaviour is left open.
Target Audience
Web3 security engineers and auditors, smart contract and dApp frontend developers, wallet and infrastructure providers, protocol/DAO operations leads who own deployment keys and upgrade processes, and software supply chain researchers looking for a Web3-specific threat model. It is also a useful orientation read for security managers coming from Web2 who need to understand why the same dependency attack carries different consequences on-chain.
Authors’ abstract
Web3 applications, built on blockchain technology, manage billions of dollars in digital assets through decentralized applications (dApps) and smart contracts. These systems rely on complex, software supply chains that introduce significant security vulnerabilities. This paper examines the software supply chain security challenges unique to the Web3 ecosystem, where traditional Web2 software supply chain problems intersect with the immutable and high-stakes nature of…
The full abstract on arXiv