KyberSwap Elastic: When a Rounding Bug Drains a Pool
How 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 MoreBlog
Security Insights
Smart contract security research, tutorials, and analysis from the Sigvex team.
What a Signature Actually Authorizes
A 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 MoreFuzzing Smart Contracts in the Browser: The Architecture Behind WASM-Based Security Testing
How WebAssembly enables coverage-guided smart contract fuzzing directly in the browser, without a backend dependency — the engineering decisions behind a browser-native fuzzer.
Read MoreCross-Contract Analysis: Tracing Attack Paths Across Protocol Boundaries
How 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 MoreFrom Finding to Proof: How Automated Exploit Generation Works
How Sigvex goes beyond static findings to automatically generate and validate working exploits against detected vulnerabilities, turning theoretical alerts into confirmed attack scenarios.
Read MoreRed Team Playbook: Anatomy of a Flash Loan Attack
A step-by-step walkthrough of how security researchers discover and exploit flash loan vulnerabilities, from initial reconnaissance to proof-of-concept execution.
Read MoreSolana Program Security: The Vulnerability Classes That EVM Tools Miss
A 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 MoreSymbolic Execution for Smart Contracts: Exploring Every Path Without Executing Any
How 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 MoreSmart Contract Fuzzing: From Random Inputs to Guided Exploitation
A 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 MoreIntermediate Representations in Smart Contract Analysis: From Bytecode to Semantic Understanding
How lifting bytecode through multiple IR levels—LIR, MIR, HIR, and AST—supports progressively deeper security analysis while preserving semantic fidelity.
Read MoreEVM Bytecode Analysis: From Raw Bytes to Security Insights
A 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 MoreMeasuring What Matters: A Framework for EVM Decompiler Accuracy Metrics
Beyond 'it looks right'—quantitative metrics for evaluating decompiler output quality, semantic preservation, and security analysis utility.
Read MoreMEV as a Security Threat: Static Analysis Approaches to Transaction Ordering Vulnerabilities
How bytecode analysis can identify contracts vulnerable to MEV extraction, frontrunning, and sandwich attacks—turning a mempool problem into a detectable code pattern.
Read MoreProxy and Upgrade Vulnerabilities: The $300M+ Risk
Storage collisions, uninitialized implementations, upgrade-time storage breakage, and selfdestruct in proxy implementations. Why the proxy pattern's complexity translates directly to attack surface.
Read MoreBytecode-Native Security: Why Source Code Analysis Is Fighting Yesterday's War
An 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 MoreDeFi-Specific Vulnerabilities: Beyond Traditional Smart Contract Security
Token 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 MoreAccess Control Vulnerabilities: The $1B+ Weakness
How proxy initialization bugs and unprotected delegatecall have cost over a billion dollars — and what the bytecode patterns actually look like.
Read MoreBeyond the Binary: Why Modern Smart Contract Security Needs Both Formal Verification and Fuzzing
An 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 MoreLevel Finance: The Referral Code Exploit That Drained $1.1 Million
Technical 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 MoreOracle Manipulation: The $400M+ DeFi Vulnerability
Why instant AMM prices are trivially manipulable, what TWAP windows actually buy you, and how to validate off-chain price feeds properly.
Read MoreFlash Loan Attack Detection: Protecting DeFi Protocols
Flash loans don't create vulnerabilities — they remove the capital requirement for exploiting ones that already exist. Here's what that means for detection.
Read MoreTornado Cash Governance Takeover: When Proposals Become Exploits
Analysis 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 MorePlatypus Finance: The $8.5 Million Flash Loan That Exposed Stablecoin Logic
Technical 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 MoreMango Markets: The $114 Million 'Profitable Trading Strategy'
How 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 MoreCream Finance: A Protocol Exploited Three Times in One Year
Analysis 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 MoreThe BadgerDAO Frontend Attack: $120 Million Lost to Malicious Approvals
Analysis 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 MoreThe Poly Network Exploit: $611 Million Stolen, Then Returned
Analysis 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 MoreThe Wintermute Hack: When Vanity Addresses Become Vulnerabilities
Technical 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 MoreThe Ronin Bridge Hack: $625 Million and the Dangers of Centralization
How North Korean attackers compromised 5 of 9 Ronin validator keys to steal $625 million from Axie Infinity's bridge—undetected for six days.
Read MoreThe Wormhole Bridge Exploit: Forged Signatures and $320 Million
How 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 MoreThe Nomad Bridge Exploit: When Zero Becomes Trusted
A 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 MoreThe DAO Hack: The $60 Million Attack That Split Ethereum
A 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 MoreThe Parity Wallet Hacks: When Library Contracts Go Wrong
How two Parity multisig wallet vulnerabilities in 2017 resulted in $30 million stolen and $280 million frozen forever—both caused by mishandled delegatecall proxy patterns.
Read MoreEuler Finance Exploit: A $197 Million DeFi Lesson
Technical breakdown of the March 2023 Euler Finance flash loan attack that exploited a missing health check in the donateToReserves function.
Read MoreThe Curve Vyper Pool Exploit: When Compilers Betray You
Analysis 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 MoreReentrancy Attacks: From the DAO to Read-Only Variants
A technical breakdown of the three reentrancy vulnerability classes — classic, cross-function, and read-only — with real exploit patterns and bytecode-level detection strategies.
Read MoreInteger Overflow and Underflow: The Vulnerability Solidity 0.8 Fixed (and Didn't)
Solidity 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 MoreBytecode Analysis 101: Reading Smart Contracts Without Source Code
A practical guide to understanding EVM bytecode, how decompilation works, and why bytecode-native analysis catches vulnerabilities that source-level tools miss.
Read MoreBeanstalk Governance Attack: When Flash Loans Meet Democracy
Technical 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 MoreIntroducing Sigvex: Multi-Runtime Smart Contract Security for EVM and Solana
Sigvex 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