Vulnerability Patterns Skill

Reference skill for common Solidity vulnerability patterns. This skill references detailed checklists in the security-audit skill.

When to Use

Use this skill when:

• •Learning about common vulnerabilities
• •Reviewing code for security issues
• •Understanding exploit techniques
• •Preventing known vulnerabilities

Related Skills

For comprehensive security auditing, see:

• •security-audit: Complete audit methodology and checklists
• •testing-patterns: Security testing approaches
• •contract-patterns: Secure implementation patterns

Common Vulnerability Categories

Critical Vulnerabilities

1. •

   Reentrancy - See security-audit/checklists/common-vulnerabilities.md

   • •Classic reentrancy (same function)
   • •Cross-function reentrancy
   • •Read-only reentrancy
2. •

   Access Control - See security-audit/checklists/access-control-checklist.md

   • •Missing access modifiers
   • •Incorrect authorization
   • •Privilege escalation
3. •

   Integer Issues - See security-audit/checklists/common-vulnerabilities.md

   • •Overflow/underflow (pre-0.8)
   • •Division by zero
   • •Precision loss
4. •

   Oracle Manipulation - See security-audit/checklists/defi-checklist.md

   • •Flash loan attacks
   • •Price manipulation
   • •Stale price data

High Severity

1. •Unchecked External Calls
2. •Delegatecall Injection
3. •Signature Replay
4. •Front-Running
5. •Denial of Service

Medium Severity

1. •Timestamp Dependence
2. •Tx.origin Authentication
3. •Floating Pragma
4. •Uninitialized Storage

Quick Vulnerability Reference

Reentrancy

// ❌ Vulnerable
function withdraw() public {
    uint amount = balances[msg.sender];
    (bool success, ) = msg.sender.call{value: amount}("");
    balances[msg.sender] = 0;  // Too late!
}

// ✅ Secure
function withdraw() public nonReentrant {
    uint amount = balances[msg.sender];
    balances[msg.sender] = 0;  // Update first
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
}

Access Control

// ❌ Missing modifier
function mint(address to, uint amount) public {
    _mint(to, amount);
}

// ✅ Protected
function mint(address to, uint amount) public onlyOwner {
    _mint(to, amount);
}

Integer Overflow

// ❌ Pre-0.8 vulnerable
pragma solidity 0.7.6;
uint256 balance = type(uint256).max;
balance += 1;  // Overflows silently

// ✅ Solidity 0.8+ safe
pragma solidity 0.8.30;
uint256 balance = type(uint256).max;
balance += 1;  // Reverts

Testing for Vulnerabilities

Reentrancy Test

contract Attacker {
    Target public target;

    function attack() external payable {
        target.deposit{value: msg.value}();
        target.withdraw();
    }

    receive() external payable {
        if (address(target).balance > 0) {
            target.withdraw();
        }
    }
}

function test_ReentrancyAttack() public {
    vm.expectRevert();  // Should revert
    attacker.attack{value: 1 ether}();
}

Access Control Test

function test_RevertWhen_UnauthorizedMint() public {
    vm.prank(attacker);
    vm.expectRevert("Ownable: caller is not the owner");
    token.mint(attacker, 1000);
}

Resources

Detailed Vulnerability Information:

• •SWC Registry - Smart Contract Weakness Classification
• •ConsenSys Best Practices
• •Rekt News - DeFi exploit analysis

Related Skills:

• •security-audit/checklists/common-vulnerabilities.md - Complete vulnerability checklist
• •security-audit/checklists/defi-checklist.md - DeFi-specific vulnerabilities
• •security-audit/checklists/upgrade-checklist.md - Upgrade-related issues

Note: This is a reference skill. For comprehensive security auditing, use the security-audit skill which contains detailed checklists and methodologies.