Smart Contract Security & Auditing

3.1 Security Landscape

Smart contract security is uniquely challenging: code is immutable once deployed, transactions are irreversible, and exploits can drain millions in seconds. Understanding vulnerabilities is essential for legal due diligence and risk assessment.

Why Smart Contract Security Matters

• Immutability: Bugs cannot be patched after deployment (usually)
• High Value Targets: Contracts often hold millions in assets
• Pseudonymity: Attackers are difficult to identify and prosecute
• Complexity: Interactions between contracts create emergent vulnerabilities
• Financial Incentives: Hackers can profit directly from exploits

3.2 Common Vulnerabilities

Reentrancy Attacks

// VULNERABLE: State updated AFTER external call
function withdraw(uint256 amount) external {
    require(balances[msg.sender] >= amount);

    // DANGER: External call before state update
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);

    // State updated AFTER call - attacker can re-enter
    balances[msg.sender] -= amount;  // TOO LATE!
}

// SECURE: Checks-Effects-Interactions pattern
function withdraw(uint256 amount) external {
    // 1. CHECKS
    require(balances[msg.sender] >= amount);

    // 2. EFFECTS - Update state BEFORE external call
    balances[msg.sender] -= amount;

    // 3. INTERACTIONS - External call LAST
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
}

Integer Overflow/Underflow

Prior to Solidity 0.8.0, arithmetic operations could overflow or underflow silently.

// uint8 max value is 255
uint8 balance = 255;
balance = balance + 1;  // Overflows to 0!

uint8 amount = 0;
amount = amount - 1;    // Underflows to 255!

// Attack: Transfer more than you have
function transfer(address to, uint256 amount) {
    // If balance is 0 and amount is 1:
    // 0 - 1 = MAX_UINT256 (underflow!)
    balances[msg.sender] -= amount;  // No check!
    balances[to] += amount;
}

Access Control Flaws

// VULNERABLE: Missing access control
function setOwner(address newOwner) external {
    owner = newOwner;  // Anyone can call!
}

// VULNERABLE: tx.origin instead of msg.sender
function withdraw() external {
    require(tx.origin == owner);  // Can be phished!
    // If owner calls malicious contract, attacker can call this
}

Flash Loan Attacks

Flash loans enable attacks by temporarily providing attackers with enormous capital to manipulate prices or governance votes within a single transaction.

3.3 Smart Contract Auditing

A security audit is a systematic examination of smart contract code to identify vulnerabilities, logic errors, and deviations from best practices. Understanding audit processes helps evaluate their quality and limitations.

Audit Process

1. Scoping: Define what contracts are in scope, expected behavior, and threat model
2. Documentation Review: Review whitepapers, specifications, and design documents
3. Manual Code Review: Line-by-line analysis by security experts
4. Automated Analysis: Static analyzers, fuzzers, and symbolic execution tools
5. Testing: Unit tests, integration tests, and invariant testing
6. Report Generation: Document findings with severity ratings
7. Remediation: Developers fix issues, auditors verify fixes

Severity Classification

Leading Audit Firms

• Trail of Bits: Known for rigorous, research-oriented audits
• OpenZeppelin: Major contributor to security standards and libraries
• Consensys Diligence: Ethereum ecosystem specialists
• Certik: High-volume auditing with automated tooling
• Spearbit: Decentralized network of security researchers

3.4 Formal Verification

Approaches to Formal Verification

• Model Checking: Exhaustively explore all possible states
• Theorem Proving: Mathematical proofs of correctness
• Symbolic Execution: Analyze code with symbolic inputs
• SMT Solving: Use satisfiability solvers to find violations

Formal Verification Tools

3.5 Smart Contract Insurance

DeFi insurance protocols provide coverage against smart contract failures, offering risk transfer mechanisms for users and protocols.

Insurance Protocols