Solidity Security

Master smart contract security best practices, vulnerability prevention, and secure Solidity development patterns.

When to Use This Skill

Writing secure smart contracts
Auditing existing contracts for vulnerabilities
Implementing secure DeFi protocols
Preventing reentrancy, overflow, and access control issues
Optimizing gas usage while maintaining security
Preparing contracts for professional audits
Understanding common attack vectors

Critical Vulnerabilities

1. Reentrancy

Attacker calls back into your contract before state is updated.

Vulnerable Code:

// VULNERABLE TO REENTRANCY
contract VulnerableBank {
    mapping(address => uint256) public balances;
 
    function withdraw() public {
        uint256 amount = balances[msg.sender];
 
        // DANGER: External call before state update
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
 
        balances[msg.sender] = 0;  // Too late!
    }
}

Secure Pattern (Checks-Effects-Interactions):

contract SecureBank {
    mapping(address => uint256) public balances;
 
    function withdraw() public {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "Insufficient balance");
 
        // EFFECTS: Update state BEFORE external call

Alternative: ReentrancyGuard

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 
contract SecureBank is ReentrancyGuard {
    mapping(address => uint256) public balances;
 
    function withdraw() public nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount

2. Integer Overflow/Underflow

Vulnerable Code (Solidity < 0.8.0):

// VULNERABLE
contract VulnerableToken {
    mapping(address => uint256) public balances;
 
    function transfer(address to, uint256 amount) public {
        // No overflow check - can wrap around
        balances[msg.sender] -= amount;  // Can underflow!
        balances[to] +=

Secure Pattern (Solidity >= 0.8.0):

// Solidity 0.8+ has built-in overflow/underflow checks
contract SecureToken {
    mapping(address => uint256) public balances;
 
    function transfer(address to, uint256 amount) public {
        // Automatically reverts on overflow/underflow
        balances[msg.sender] -= amount;
        balances[to] += amount;

For Solidity < 0.8.0, use SafeMath:

import "@openzeppelin/contracts/utils/math/SafeMath.sol";
 
contract SecureToken {
    using SafeMath for uint256;
    mapping(address => uint256) public balances;
 
    function transfer(address to, uint256 amount) public {
        balances[msg.sender

3. Access Control

Vulnerable Code:

// VULNERABLE: Anyone can call critical functions
contract VulnerableContract {
    address public owner;
 
    function withdraw(uint256 amount) public {
        // No access control!
        payable(msg.sender).transfer(amount);
    }
}

Secure Pattern:

import "@openzeppelin/contracts/access/Ownable.sol";
 
contract SecureContract is Ownable {
    function withdraw(uint256 amount) public onlyOwner {
        payable(owner()).transfer(amount);
    }
}
 
// Or implement custom role-based access
contract RoleBasedContract {

4. Front-Running

Vulnerable:

// VULNERABLE TO FRONT-RUNNING
contract VulnerableDEX {
    function swap(uint256 amount, uint256 minOutput) public {
        // Attacker sees this in mempool and front-runs
        uint256 output = calculateOutput(amount);
        require(output >= minOutput, "Slippage too high");
        // Perform swap
    }
}

Mitigation:

contract SecureDEX {
    mapping(bytes32 => bool) public usedCommitments;
 
    // Step 1: Commit to trade
    function commitTrade(bytes32 commitment) public {
        usedCommitments[commitment] = true;
    }
 
    // Step 2: Reveal trade (next block)
    function

Security Best Practices

Checks-Effects-Interactions Pattern

contract SecurePattern {
    mapping(address => uint256) public balances;
 
    function withdraw(uint256 amount) public {
        // 1. CHECKS: Validate conditions
        require(amount <= balances[msg.sender], "Insufficient balance");
        require(amount

Pull Over Push Pattern

// Prefer this (pull)
contract SecurePayment {
    mapping(address => uint256) public pendingWithdrawals;
 
    function recordPayment(address recipient, uint256 amount) internal {
        pendingWithdrawals[recipient] += amount;

Input Validation

contract SecureContract {
    function transfer(address to, uint256 amount) public {
        // Validate inputs
        require(to != address(0), "Invalid recipient");
        require(to != address(this), "Cannot send to contract"

Emergency Stop (Circuit Breaker)

import "@openzeppelin/contracts/security/Pausable.sol";
 
contract EmergencyStop is Pausable, Ownable {
    function criticalFunction() public whenNotPaused {
        // Function logic
    }
 
    function emergencyStop() public onlyOwner {
        _pause();
    }
 
    function resume()

Gas Optimization

Use `uint256` Instead of Smaller Types

// More gas efficient
contract GasEfficient {
    uint256 public value;  // Optimal
 
    function set(uint256 _value) public {
        value = _value;
    }
}
 
// Less efficient
contract GasInefficient {
    uint8 public value;  // Still uses 256-bit slot
 
    function

Pack Storage Variables

// Gas efficient (3 variables in 1 slot)
contract PackedStorage {
    uint128 public a;  // Slot 0
    uint64 public b;   // Slot 0
    uint64 public c;   // Slot 0
    uint256 public d;  // Slot 1
}
 
// Gas inefficient (each variable in separate slot)
contract UnpackedStorage {
    uint256 public a;  // Slot 0

Use `calldata` Instead of `memory` for Function Arguments

contract GasOptimized {
    // More gas efficient
    function processData(uint256[] calldata data) public pure returns (uint256) {
        return data[0];
    }
 
    // Less efficient
    function processDataMemory(uint256[] memory data) public

Use Events for Data Storage (When Appropriate)

contract EventStorage {
    // Emitting events is cheaper than storage
    event DataStored(address indexed user, uint256 indexed id, bytes data);
 
    function storeData(uint256 id, bytes calldata data) public {
        emit DataStored(msg.sender

Common Vulnerabilities Checklist

// Security Checklist Contract
contract SecurityChecklist {
    /**
     * [ ] Reentrancy protection (ReentrancyGuard or CEI pattern)
     * [ ] Integer overflow/underflow (Solidity 0.8+ or SafeMath)
     * [ ] Access control (Ownable, roles, modifiers)
     * [ ] Input validation (require statements)
     * [ ] Front-running mitigation (commit-reveal if applicable)
     * [ ] Gas optimization (packed storage, calldata)
     * [ ] Emergency stop mechanism (Pausable)
     * [ ] Pull over push pattern for payments
     * [ ] No delegatecall to untrusted contracts
     * [ ] No tx.origin for authentication (use msg.sender)

Testing for Security

// Hardhat test example
const { expect } = require("chai");
const { ethers } = require("hardhat"

Audit Preparation

contract WellDocumentedContract {
    /**
     * @title Well Documented Contract
     * @dev Example of proper documentation for audits
     * @notice This contract handles user deposits and withdrawals
     */
 
    /// @notice Mapping of user balances
    mapping(address

Resources

references/reentrancy.md: Comprehensive reentrancy prevention
references/access-control.md: Role-based access patterns
references/overflow-underflow.md: SafeMath and integer safety
references/gas-optimization.md: Gas saving techniques
references/vulnerability-patterns.md: Common vulnerability catalog
assets/solidity-contracts-templates.sol: Secure contract templates
assets/security-checklist.md: Pre-audit checklist
scripts/analyze-contract.sh: Static analysis tools

Tools for Security Analysis

Slither: Static analysis tool
Mythril: Security analysis tool
Echidna: Fuzzing tool
Manticore: Symbolic execution
Securify: Automated security scanner

Common Pitfalls

Using tx.origin for Authentication: Use msg.sender instead
Unchecked External Calls: Always check return values
Delegatecall to Untrusted Contracts: Can hijack your contract
Floating Pragma: Pin to specific Solidity version
Missing Events: Emit events for state changes
Excessive Gas in Loops: Can hit block gas limit
No Upgrade Path: Consider proxy patterns if upgrades needed

solidity-security

CLI Install

Skill Instructions

Run with Cloud Agent

Solidity Security

When to Use This Skill

Critical Vulnerabilities

1. Reentrancy

2. Integer Overflow/Underflow

3. Access Control

4. Front-Running

Security Best Practices

Checks-Effects-Interactions Pattern

Pull Over Push Pattern

Input Validation

Emergency Stop (Circuit Breaker)

Gas Optimization

Use `uint256` Instead of Smaller Types

Pack Storage Variables

Use `calldata` Instead of `memory` for Function Arguments

Use Events for Data Storage (When Appropriate)

Common Vulnerabilities Checklist

Testing for Security

Audit Preparation

Resources

Tools for Security Analysis

Common Pitfalls

solidity-security

CLI Install

Skill Instructions

Run with Cloud Agent

Solidity Security

When to Use This Skill

Critical Vulnerabilities

1. Reentrancy

2. Integer Overflow/Underflow

3. Access Control

4. Front-Running

Security Best Practices

Checks-Effects-Interactions Pattern

Pull Over Push Pattern

Input Validation

Emergency Stop (Circuit Breaker)

Gas Optimization

Use uint256 Instead of Smaller Types

Pack Storage Variables

Use calldata Instead of memory for Function Arguments

Use Events for Data Storage (When Appropriate)

Common Vulnerabilities Checklist

Testing for Security

Audit Preparation

Resources

Tools for Security Analysis

Common Pitfalls

Use `uint256` Instead of Smaller Types

Use `calldata` Instead of `memory` for Function Arguments