Smart contract security research, tutorials, and analysis from the Sigvex team.
The deployed bytecode is the contract, not your GitHub repo. Here is how an attacker gets from a bare address to understanding, and why your private variables were never secret.
Read MoreHow an attacker enumerates every way value and control enter and leave a contract — and how to draw that same map of your own code before anyone else does.
Read MoreThe attacker's shortlist of value-extraction bugs — reentrancy, unchecked calls, precision loss, and oracle manipulation — with enough mechanism to spot them in your own code.
Read MoreHow broken authorization and unsafe upgradeability let an attacker take the whole contract, not just drain a single function — the endgame of the red-team half.
Read MoreHow an attacker's checklist becomes an automated detector — and why the hard part is not finding suspicious patterns but deciding which findings deserve a human's next hour.
Read MoreDetection tells you where you're exposed. This closing post is what you do about it — the defensive patterns and process that make the attacks from Parts 3 and 4 not work.
Read MoreHow a single round-down in KyberSwap Elastic's swap math let an attacker double-count liquidity across a tick boundary and drain pools on a dozen chains in November 2023.
Read MoreA signature proves who signed a message, not when, where, or how many times it can be used. The gap between those two things is where signature replay bugs live.
Read MoreHow WebAssembly enables coverage-guided smart contract fuzzing directly in the browser, without a backend dependency — the engineering decisions behind a browser-native fuzzer.
Read MoreHow to follow call chains across multiple contracts to detect multi-hop attack paths, composability vulnerabilities, and cross-protocol data flow that single-contract analysis misses.
Read MoreHow Sigvex goes beyond static findings to automatically generate and validate working exploits against detected vulnerabilities, turning theoretical alerts into confirmed attack scenarios.
Read MoreA step-by-step walkthrough of how security researchers discover and exploit flash loan vulnerabilities, from initial reconnaissance to proof-of-concept execution.
Read MoreA guide to Solana-specific vulnerability patterns — arbitrary CPI, missing signer checks, account validation gaps, type cosplay, and PDA seed collisions — and how bytecode analysis detects them in deployed programs.
Read MoreHow symbolic execution explores program paths using constraint solvers to find inputs that trigger vulnerabilities—and why it's both powerful and challenging for EVM analysis.
Read MoreA deep dive into fuzzing techniques for smart contracts—coverage-guided fuzzing, property-based testing, stateful fuzzing, and how modern fuzzers find bugs that static analysis misses.
Read MoreHow lifting bytecode through multiple IR levels—LIR, MIR, HIR, and AST—supports progressively deeper security analysis while preserving semantic fidelity.
Read MoreA technical walkthrough of analyzing Ethereum Virtual Machine bytecode—understanding opcodes, control flow recovery, data flow analysis, and the techniques that power modern smart contract security tools.
Read MoreBeyond 'it looks right'—quantitative metrics for evaluating decompiler output quality, semantic preservation, and security analysis utility.
Read MoreHow bytecode analysis can identify contracts vulnerable to MEV extraction, frontrunning, and sandwich attacks—turning a mempool problem into a detectable code pattern.
Read MoreStorage collisions, uninitialized implementations, upgrade-time storage breakage, and selfdestruct in proxy implementations. Why the proxy pattern's complexity translates directly to attack surface.
Read MoreAn exploration of why security tools built on source code assumptions fail in the EVM ecosystem, and how bytecode-native analysis provides ground truth that source code cannot.
Read MoreToken mechanics create a different class of bugs than reentrancy or overflow. Decimal mismatches, fee-on-transfer accounting errors, rebasing token incompatibility, and missing slippage protection have collectively drained hundreds of millions from DeFi protocols.
Read MoreHow proxy initialization bugs and unprotected delegatecall have cost over a billion dollars — and what the bytecode patterns actually look like.
Read MoreAn analysis of why the formal verification vs. fuzzing debate misses the point, and how combining constraint satisfaction, static analysis, and dynamic testing creates defense in depth.
Read MoreTechnical analysis of the May 2023 Level Finance attack where an attacker exploited unchecked referral logic to repeatedly claim rewards, and how bytecode analysis catches reward calculation bugs.
Read MoreWhy instant AMM prices are trivially manipulable, what TWAP windows actually buy you, and how to validate off-chain price feeds properly.
Read MoreFlash loans don't create vulnerabilities — they remove the capital requirement for exploiting ones that already exist. Here's what that means for detection.
Read MoreAnalysis of the May 2023 Tornado Cash governance attack where a malicious proposal granted an attacker 1.2 million votes, enabling complete protocol control through hidden exploit code.
Read MoreTechnical breakdown of the February 2023 Platypus Finance exploit where an attacker manipulated debt positions using flash loans, and how bytecode analysis reveals the vulnerable collateral logic.
Read MoreHow Avraham Eisenberg manipulated the MNGO oracle price 24x in 20 minutes to borrow $114 million against phantom profits—then publicly took credit for it.
Read MoreAnalysis of the three major Cream Finance exploits in 2021 totaling over $190 million in losses, examining flash loan attacks, oracle manipulation, and reentrancy through token hooks.
Read MoreAnalysis of the December 2021 BadgerDAO hack where attackers injected malicious scripts via a compromised Cloudflare API key, tricking users into granting unlimited token approvals.
Read MoreAnalysis of the August 2021 Poly Network hack where an attacker exploited cross-chain contract permissions to steal $611 million across three blockchains—then returned it all.
Read MoreTechnical analysis of the September 2022 Wintermute exploit where attackers cracked a vanity address private key using a known vulnerability in the Profanity tool, stealing $160 million.
Read MoreHow North Korean attackers compromised 5 of 9 Ronin validator keys to steal $625 million from Axie Infinity's bridge—undetected for six days.
Read MoreHow an attacker used a deprecated Solana function to bypass Wormhole's guardian signature verification, minting 120,000 wETH without locking a single real token.
Read MoreA routine upgrade accidentally made the zero hash a valid Merkle root in Nomad's bridge. Within two hours, ~300 addresses had copied and pasted their way to $190 million.
Read MoreA technical breakdown of the 2016 DAO reentrancy attack—how it worked, why the code failed, and the hard fork that divided the Ethereum community.
Read MoreHow two Parity multisig wallet vulnerabilities in 2017 resulted in $30 million stolen and roughly 500,000 ETH frozen forever—both caused by mishandled delegatecall proxy patterns.
Read MoreTechnical breakdown of the March 2023 Euler Finance flash loan attack that exploited a missing health check in the donateToReserves function.
Read MoreAnalysis of the July 2023 Curve pool incident caused by a Vyper compiler bug that broke reentrancy guards, resulting in $70 million in losses across multiple DeFi protocols.
Read MoreA technical breakdown of the three reentrancy vulnerability classes — classic, cross-function, and read-only — with real exploit patterns and bytecode-level detection strategies.
Read MoreSolidity 0.8 added overflow checks by default. Here's what it missed — and why bytecode analysis still finds real arithmetic vulnerabilities in modern contracts.
Read MoreA practical guide to understanding EVM bytecode, how decompilation works, and why bytecode-native analysis catches vulnerabilities that source-level tools miss.
Read MoreTechnical analysis of the April 2022 Beanstalk Farms exploit where an attacker used $1 billion in flash loans to hijack governance and steal $182 million, exposing critical DeFi governance vulnerabilities.
Read MoreSigvex is a Rust toolkit for decompiling and analyzing smart contracts across EVM and SVM runtimes. This post covers the architecture, the detector suite, and the design decisions behind building bytecode-native analysis.
Read More