EVM and Solidity vulnerabilities in disclosed bug bounty reports

The deepest disclosure archive in the space, and the environment whose failure modes define the shared vocabulary of smart contract security.

Reports indexed
709
Total paid
$7.4M
Critical
4
Largest payout
$2.5M

The EVM is where most disclosed value has been lost and most disclosed bounty has been paid. Its execution model — synchronous external calls, a shared global state, and `delegatecall` proxies layered over immutable code — produces a specific set of recurring failures that the rest of the industry now names after it.

Solidity-specific surface matters here: storage collisions between proxy and implementation, initializer sequencing on upgradeable contracts, `delegatecall` context confusion, gas-dependent behaviour in `transfer` versus `call`, and the long tail of ERC-20 tokens that do not return a boolean, that charge transfer fees, or that rebase.

Reports across every category in the taxonomy land here, so the EVM pages are best read alongside a category filter rather than end to end.

What reviewers look for

  • Proxy and implementation storage layout collisions
  • Non-standard ERC-20 behaviour: missing return values, fees on transfer, rebasing
  • `delegatecall` executing untrusted code in the caller's storage context
  • Gas assumptions baked into `transfer` and `send`
  • Upgrade sequencing that leaves a window with no owner

Curated highlights

The largest disclosed payouts in this group, with our own summary of each. Every report links back to the original disclosure.

criticalSignature replayEVM-Solidity$2.5M

Cross-chain bridge signature replay allows infinite mint

A signature validation vulnerability in a cross-chain bridge protocol allowed valid guardian attestations to be replayed across different destination chains. The signed message digest omitted essential domain parameters like the target chain ID and global emitter sequence, allowing an attacker to reuse a single legitimate withdrawal signature on multiple bridge deployments. Consequently, an attacker could mint unlimited wrapped assets across various target chains without providing additional collateral on the source chain.

Wormhole-style BridgeimmunefiFeb 24, 2023Open
criticalBridge exploitEVM-Solidity$1.8M

Bridge withdrawal proof accepts empty Merkle path

A flawed proof verification mechanism in an L2 canonical bridge contract permitted withdrawal validation using an empty Merkle proof array. When no proof elements were supplied, the verification function failed to iterate and directly compared the unhashed withdrawal leaf against the target root. By matching a fake withdrawal leaf payload with a valid historical or relayable state root, an attacker could forge arbitrary withdrawal events and drain escrowed funds from the bridge.

L2 Canonical BridgeimmunefiJun 2, 2022Open
criticalReentrancyEVM-Solidity$1.2M

Read-only reentrancy in LP price oracle drains lending market

A lending market relied on a liquidity pool's raw virtual price function to value LP tokens deposited as collateral. During a liquidity removal operation, ETH transfers to the caller occurred before internal balance and supply states were reconciled, allowing an execution callback while state was inconsistent. An attacker used this callback to fetch an artificially inflated virtual price, enabling them to over-borrow against their collateral and drain the protocol's reserves in a single transaction.

Curve-style Lending Marketcode4renaApr 11, 2023Open
criticalOracle manipulationEVM-Solidity$900k

Spot TWAP oracle manipulated via single-block flash loan

A perpetual derivatives protocol relied on a Uniswap V3 TWAP oracle whose pool observation cardinality was capped at 12, severely reducing its intended 30-second time-weighted average window. An attacker executed a single-block flash loan to heavily distort the underlying spot price without triggering any secondary price feed validation. This allowed the attacker to open oversized leveraged positions at an artificial mark price and force liquidations against counterparties in a single atomic transaction.

Perp DEXsherlockAug 2, 2023Open
highGovernance attackEVM-Solidity$350k

Governance proposal executes arbitrary call via delegatecall module

A severe vulnerability in the governance timelock contract enabled proposal execution using DELEGATECALL without restricting the target address to a verified allowlist. Because the delegatecall target contract operated within the context of the timelock's storage without layout restrictions, a malicious proposal could overwrite key storage slots. An attacker leveraging flash loans or governance weight could pass a proposal that delegated to a custom contract, overwriting the timelock admin address in slot 0 to hijack governance authority and drain treasury funds.

DAO Treasurycode4renaJun 19, 2023Open
highPrice manipulationEVM-Solidity$300k

Stablecoin redemption path uses stale Chainlink round data

An algorithmic stablecoin's redemption module fetched Chainlink price data via latestRoundData without checking the update timestamp or round completeness status. During market volatility and L2 sequencer outages, oracle updates lagged, leaving stale collateral valuation in place on-chain. Attackers leveraged this discrepancy by buying discounted stablecoins on secondary markets and immediately redeeming them for full-value backing assets through the protocol.

Algorithmic StablecoinsherlockOct 17, 2023Open

All reports in this group

Vulnerability classes seen on this chain

Related chain / vm pages