1.1 재진입 공격 동작 원리

// ❌ 취약한 컨트랙트 — 재진입 공격에 노출
contract VulnerableBank {
    mapping(address => uint256) public balances;

    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    // 취약점: ETH 전송 후에 잔액을 0으로 업데이트 → 재진입 가능
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");
        
        // ⚠️ 위험: 외부 호출 먼저 (ETH 전송)
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        // ⚠️ 상태 업데이트가 외부 호출 이후 → 재진입 공격 허용
        balances[msg.sender] = 0;
    }
}

// ❌ 공격자 컨트랙트
contract Attacker {
    VulnerableBank public bank;
    uint256 public attackAmount = 1 ether;

    constructor(address _bank) {
        bank = VulnerableBank(_bank);
    }

    function attack() external payable {
        require(msg.value >= attackAmount, "Need ETH");
        bank.deposit{value: attackAmount}();
        bank.withdraw(); // 첫 withdraw 호출
    }

    // ETH 수신 시 자동 실행되는 fallback
    receive() external payable {
        // bank.balances[this] 가 아직 0이 안 됐으므로 재호출 가능!
        if (address(bank).balance >= attackAmount) {
            bank.withdraw(); // 재진입!!! 반복 탈취
        }
    }
}

// ✅ 방어 1: CEI (Checks-Effects-Interactions) 패턴
contract SafeBank_CEI {
    mapping(address => uint256) public balances;

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");
        
        // ✅ Effects 먼저 — 상태 변경
        balances[msg.sender] = 0;
        
        // ✅ Interactions 나중에 — 외부 호출
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// ✅ 방어 2: ReentrancyGuard (뮤텍스 잠금)
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SafeBank_Guard is ReentrancyGuard {
    mapping(address => uint256) public balances;

    // nonReentrant: 함수 실행 중 재진입 완전 차단
    function withdraw() external nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");
        balances[msg.sender] = 0;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// ✅ 방어 3: Pull Payment 패턴 (가장 안전)
import "@openzeppelin/contracts/security/PullPayment.sol";

contract SafeBank_Pull is PullPayment {
    function refund(address payee, uint256 amount) internal {
        // ETH를 직접 보내지 않고 escrow에 보관
        _asyncTransfer(payee, amount);
    }
    // 수령자가 직접 withdrawPayments() 호출하여 출금
}

1.2 크로스 함수 & 크로스 컨트랙트 재진입

// ⚠️ 크로스 함수 재진입 예시
contract CrossFunctionVulnerable {
    mapping(address => uint256) public balances;

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        // ETH 전송 (여기서 공격자의 receive()가 실행됨)
        payable(msg.sender).transfer(amount);
        balances[msg.sender] = 0; // 아직 0이 아님!
    }

    // 공격자는 receive()에서 transfer()를 호출 → balances 복사 가능
    function transfer(address to, uint256 amount) external {
        require(balances[msg.sender] >= amount); // 아직 잔액이 있음!
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }
}

// ✅ 해결: 모든 관련 함수에 nonReentrant 적용 OR 전역 잠금 사용
contract CrossFunctionSafe is ReentrancyGuard {
    mapping(address => uint256) public balances;

    function withdraw() external nonReentrant {
        uint256 amount = balances[msg.sender];
        balances[msg.sender] = 0; // CEI 패턴 적용
        payable(msg.sender).transfer(amount);
    }

    function transfer(address to, uint256 amount) external nonReentrant {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }
}

2.1 실제 공격 사례와 피해액

// ❌ 취약한 오라클 — Uniswap spot price 직접 사용
contract VulnerableOracle {
    IUniswapV2Pair public pair; // WETH/USDC 쌍

    // 현재 블록의 spot price만 읽음 → 조작 가능
    function getPrice() external view returns (uint256) {
        (uint112 reserve0, uint112 reserve1, ) = pair.getReserves();
        // token0=WETH, token1=USDC
        return (uint256(reserve1) * 1e18) / uint256(reserve0); // USDC per WETH
    }
}

// ✅ 방어 1: Chainlink Price Feed (가장 권장)
contract ChainlinkOracle {
    AggregatorV3Interface immutable priceFeed;

    constructor(address _feed) { priceFeed = AggregatorV3Interface(_feed); }

    function getPrice() external view returns (uint256) {
        (, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
        require(block.timestamp - updatedAt < 1 hours, "STALE"); // 신선도 검증
        require(price > 0, "INVALID");
        return uint256(price); // 8 decimals
    }
}

// ✅ 방어 2: TWAP (시간 가중 평균 가격) — Uniswap V3
contract UniswapTWAP {
    IUniswapV3Pool public pool;
    uint32 public twapInterval = 1800; // 30분 평균

    function getTWAP() external view returns (uint256) {
        uint32[] memory secondsAgos = new uint32[](2);
        secondsAgos[0] = twapInterval; // 30분 전
        secondsAgos[1] = 0;            // 현재

        (int56[] memory tickCumulatives, ) = pool.observe(secondsAgos);
        
        int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
        int24 avgTick = int24(tickCumulativesDelta / int56(uint56(twapInterval)));
        
        // tick → price 변환
        uint160 sqrtPriceX96 = TickMath.getSqrtRatioAtTick(avgTick);
        return FullMath.mulDiv(uint256(sqrtPriceX96) ** 2, 1e18, 2**192);
    }
}

// ✅ 방어 3: 다중 오라클 + 편차 검증
contract MultiOracle {
    AggregatorV3Interface immutable chainlink;
    uint256 constant MAX_DEVIATION = 5; // 5% 이상 편차 시 거래 거부

    function getVerifiedPrice() external view returns (uint256) {
        uint256 chainlinkPrice = _getChainlinkPrice();
        uint256 twapPrice      = _getTWAP();
        
        // 두 오라클 가격 편차 검증
        uint256 deviation = chainlinkPrice > twapPrice
            ? ((chainlinkPrice - twapPrice) * 100) / chainlinkPrice
            : ((twapPrice - chainlinkPrice) * 100) / twapPrice;
        
        require(deviation <= MAX_DEVIATION, "ORACLE_MANIPULATION_DETECTED");
        return (chainlinkPrice + twapPrice) / 2; // 평균값 사용
    }
}

// 정수 오버플로우 — Solidity 0.8.0 이전의 주요 취약점
// Solidity 0.8.0+는 기본적으로 오버플로우 시 revert

// ❌ 취약: Solidity ^0.7.x
contract VulnerableToken {
    mapping(address => uint256) balances;

    function transfer(address to, uint256 amount) external {
        // uint256 underflow: balances[msg.sender]가 amount보다 작으면
        // 0 - 1 = 2^256-1 (엄청난 양!)
        balances[msg.sender] -= amount; // ❌ 언더플로우 가능
        balances[to] += amount;
    }
}

// ✅ 방어 1: Solidity 0.8+ 사용 (자동 체크)
// ✅ 방어 2: SafeMath (0.8 이전 버전)
// ✅ 방어 3: unchecked는 오버플로우 불가능한 경우에만 사용
contract SafeArithmetic {
    // 가스 최적화: for 루프에서 unchecked 사용 (i < arr.length 보장됨)
    function sumArray(uint256[] calldata arr) external pure returns (uint256 total) {
        uint256 len = arr.length;
        for (uint256 i = 0; i < len; ) {
            total += arr[i];
            unchecked { ++i; } // overflow 불가 (len < 2^256)
        }
    }
}

// ===== 접근 제어 취약점 =====

// ❌ tx.origin 사용 (피싱 공격 가능)
contract TxOriginVulnerable {
    address public owner;

    function transferOwnership(address newOwner) external {
        // tx.origin은 트랜잭션 최초 발신자
        // 중간 컨트랙트 경유 시 조작 가능
        require(tx.origin == owner, "NOT_OWNER"); // ❌ 위험!
        owner = newOwner;
    }
}
// 공격 시나리오: owner가 악성 컨트랙트를 실행 →
// 악성 컨트랙트가 transferOwnership 호출 → tx.origin = owner 통과!

// ✅ msg.sender 사용
contract SafeAccessControl {
    address public owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_OWNER"); // ✅ 안전
        _;
    }

    // RBAC (역할 기반 접근 제어) — OpenZeppelin AccessControl
    // DEFAULT_ADMIN_ROLE, MINTER_ROLE, PAUSER_ROLE 등 세분화
}

// ❌ 초기화 취약점 (Uninitialized Proxy Storage)
contract UninitializedVulnerable {
    address public owner;
    bool public initialized;

    function initialize() external {
        // 초기화 여부 체크 없음 → 누구나 initialize() 재호출 가능
        owner = msg.sender; // ❌ 공격자가 owner 탈취 가능
    }
}

// ✅ initializer 수정자 (OpenZeppelin Initializable)
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract SafeInitialize is Initializable {
    address public owner;

    function initialize() external initializer {
        // initializer 수정자: 단 1회만 실행 가능
        owner = msg.sender; // ✅ 안전
    }
}

// 플래시 론 거버넌스 공격 시나리오:
// 1. Aave에서 대량 거버넌스 토큰 플래시 론
// 2. 자기 자신에게 delegate() → 대량 투표권 획득
// 3. 악성 프로포절 즉시 통과 (정족수 초과)
// 4. Treasury 자금 전액 인출 실행
// 5. 거버넌스 토큰 상환 → 모든 것이 1 트랜잭션

// ✅ 방어 1: 스냅샷 기반 투표 (ERC20Votes)
// ERC20Votes는 프로포절 생성 시점의 블록 스냅샷 사용
// 플래시 론으로 토큰을 빌려도 해당 블록 이전 잔액이 0이면 투표권 없음

// ✅ 방어 2: Timelock (2일 이상 대기)
// 거버넌스 공격이 성공해도 실행 전 커뮤니티가 발견 가능

// ✅ 방어 3: Quorum 상향 + Voting Period 연장
// 최소 정족수를 높게 설정, 투표 기간을 길게 (최소 1주일)

// ✅ 방어 4: 고가치 작업에 추가 Timelock
function executeHighValueAction(uint256 amount) external {
    require(amount <= dailyLimit, "EXCEEDS_DAILY_LIMIT");
    require(block.timestamp >= lastExecution + 1 days, "TOO_FREQUENT");
    // ...
}

5.1 Slither 설치 및 기본 사용법

# Slither 설치
pip3 install slither-analyzer

# 기본 분석 실행
slither contracts/MyToken.sol

# 특정 탐지기만 실행
slither contracts/ --detect reentrancy-eth,reentrancy-no-eth

# JSON 리포트 출력
slither contracts/ --json slither-report.json

# 상세 정보 출력
slither contracts/ --print call-graph
slither contracts/ --print cfg
slither contracts/ --print inheritance-graph

# Hardhat 프로젝트에서 실행
slither . --hardhat-ignore-compile

5.2 Slither 주요 탐지기 분류

# 커스텀 Slither 탐지기 작성 (Python)
# detectors/custom_reentrancy.py

from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification
from slither.core.cfg.node import NodeType

class CustomReentrancyDetector(AbstractDetector):
    ARGUMENT = "custom-reentrancy"
    HELP = "Custom reentrancy detector"
    IMPACT = DetectorClassification.HIGH
    CONFIDENCE = DetectorClassification.MEDIUM

    WIKI = "https://example.com/wiki"
    WIKI_TITLE = "Custom Reentrancy"
    WIKI_DESCRIPTION = "Detects potential reentrancy"
    WIKI_EXPLOIT_SCENARIO = "..."
    WIKI_RECOMMENDATION = "Use CEI pattern or ReentrancyGuard"

    def _detect(self):
        results = []
        for contract in self.contracts:
            for function in contract.functions:
                # ETH 전송 후 storage 쓰기 패턴 탐지
                if self._has_eth_transfer_before_storage(function):
                    result = self.generate_result([
                        "Potential reentrancy in ", function, "
"
                    ])
                    results.append(result)
        return results

// ERC-20 토큰 Echidna 퍼징 테스트
// echidna_test.sol

pragma solidity ^0.8.19;
import "./MyToken.sol";

contract EchidnaTest is MyToken {
    address internal constant USER1 = address(0x10000);
    address internal constant USER2 = address(0x20000);

    constructor() {
        // 초기 상태 설정
        _mint(USER1, 1000 * 10**18);
        _mint(USER2, 500  * 10**18);
    }

    // ===== 불변량 1: 총 공급량은 항상 민팅 합계와 같아야 한다 =====
    function echidna_total_supply_constant() public view returns (bool) {
        return totalSupply() == 1500 * 10**18;
    }

    // ===== 불변량 2: 잔액 합 <= 총 공급량 =====
    function echidna_balance_sum() public view returns (bool) {
        return balanceOf(USER1) + balanceOf(USER2) <= totalSupply();
    }

    // ===== 불변량 3: 잔액은 절대 음수가 될 수 없다 (uint이므로 당연) =====
    function echidna_no_negative_balance() public view returns (bool) {
        return balanceOf(msg.sender) >= 0; // uint256은 항상 true
    }

    // ===== 불변량 4: approve 후 allowance는 정확해야 한다 =====
    function echidna_allowance_after_approve(address spender, uint256 amount) 
        public returns (bool) 
    {
        approve(spender, amount);
        return allowance(msg.sender, spender) == amount;
    }

    // ===== 불변량 5: transfer 후 잔액 보존 =====
    function echidna_transfer_balance_preservation(address to, uint256 amount)
        public returns (bool)
    {
        uint256 senderBefore   = balanceOf(msg.sender);
        uint256 receiverBefore = balanceOf(to);
        
        if (senderBefore >= amount && to != msg.sender) {
            transfer(to, amount);
            return balanceOf(msg.sender) == senderBefore - amount
                && balanceOf(to) == receiverBefore + amount;
        }
        return true;
    }
}

# Echidna 실행
# echidna-test echidna_test.sol --contract EchidnaTest
# echidna-test echidna_test.sol --contract EchidnaTest --config echidna.yaml

# echidna.yaml 설정 파일
testLimit: 50000       # 최대 테스트 횟수
seqLen: 100           # 시퀀스당 최대 트랜잭션 수
timeout: 300          # 제한 시간 (초)
workers: 4            # 병렬 워커 수

# 테스트 모드
testMode: "property"  # property | assertion | exploration

# 커버리지 출력
coverage: true

# 가스 최적화
gasEnabled: false     # 가스 계산 비활성화로 속도 향상

# corpusDir: "./corpus" # 이전 실행 결과 재사용

// Foundry 불변량(Invariant) 테스트 — 현업 수준
// test/invariant/InvariantBank.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "forge-std/Test.sol";
import "forge-std/InvariantTest.sol";
import "../../src/Bank.sol";

// Handler: Foundry가 호출할 수 있는 함수들을 정의
// Ghost Variables: 테스트에서 추적하는 가상의 상태 변수
contract BankHandler is Test {
    Bank public bank;

    // Ghost variables — 우리가 직접 추적하는 상태
    uint256 public ghost_depositSum;   // 모든 예금 합계
    uint256 public ghost_withdrawSum;  // 모든 출금 합계

    address[] public actors;
    address internal currentActor;

    constructor(Bank _bank) {
        bank = _bank;
        // 테스트 액터 설정
        actors.push(makeAddr("user1"));
        actors.push(makeAddr("user2"));
        actors.push(makeAddr("user3"));
    }

    modifier useActor(uint256 actorSeed) {
        currentActor = actors[actorSeed % actors.length];
        vm.startPrank(currentActor);
        _;
        vm.stopPrank();
    }

    // Foundry가 무작위로 호출할 함수들
    function deposit(uint256 actorSeed, uint256 amount) external useActor(actorSeed) {
        amount = bound(amount, 0.01 ether, 100 ether); // 범위 제한
        deal(currentActor, amount);
        
        bank.deposit{value: amount}();
        ghost_depositSum += amount;
    }

    function withdraw(uint256 actorSeed, uint256 amount) external useActor(actorSeed) {
        uint256 balance = bank.balances(currentActor);
        if (balance == 0) return;
        
        amount = bound(amount, 0, balance);
        bank.withdraw(amount);
        ghost_withdrawSum += amount;
    }
}

// 불변량 테스트 컨트랙트
contract InvariantBank is Test, InvariantTest {
    Bank bank;
    BankHandler handler;

    function setUp() external {
        bank    = new Bank();
        handler = new BankHandler(bank);

        // Foundry에게 handler의 함수만 호출하도록 지정
        targetContract(address(handler));
    }

    // ===== 불변량 1: ETH 잔액 = 총 예금 - 총 출금 =====
    function invariant_bankBalance() external {
        assertEq(
            address(bank).balance,
            handler.ghost_depositSum() - handler.ghost_withdrawSum(),
            "Bank balance mismatch"
        );
    }

    // ===== 불변량 2: 개별 잔액 합 = 컨트랙트 ETH 잔액 =====
    function invariant_solvency() external {
        uint256 sumOfBalances;
        address[] memory actors = handler.getActors();
        for (uint256 i = 0; i < actors.length; i++) {
            sumOfBalances += bank.balances(actors[i]);
        }
        assertEq(address(bank).balance, sumOfBalances, "Solvency broken");
    }

    // 실행: forge test --match-contract InvariantBank -v
    // 출력: runs: 256, μ: 127341, ~: 129043
}

8.1 감사 보고서 구조 & 심각도 분류

# 감사 보고서 템플릿 (Code4rena / Sherlock 스타일)

## [H-01] ReentrancyGuard 미적용으로 인한 ETH 탈취 가능

**심각도:** High  
**컨트랙트:** Bank.sol  
**함수:** withdraw()  

### 취약점 설명
withdraw() 함수에서 ETH 전송 후 잔액 업데이트 순서가 잘못되어 재진입 공격에 취약합니다.

### 공격 경로 (PoC)
1. 공격자가 1 ETH를 Bank에 예금
2. withdraw() 호출
3. ETH 수신 시 receive() 함수에서 withdraw() 재호출
4. bank.balance가 소진될 때까지 반복
5. 공격자는 1 ETH 예금으로 전체 ETH 탈취

### PoC 코드
```solidity
contract AttackTest is Test {
    Bank bank;
    Attacker attacker;

    function setUp() public {
        bank = new Bank();
        // 다른 사용자 예금 설정
        vm.deal(address(bank), 10 ether);
        attacker = new Attacker(address(bank));
    }

    function test_reentrancyAttack() public {
        vm.deal(address(attacker), 1 ether);
        uint256 bankBalanceBefore = address(bank).balance;
        
        attacker.attack{value: 1 ether}();
        
        // 공격자가 bank 전체 자금 탈취
        assertEq(address(bank).balance, 0);
        assertGt(address(attacker).balance, bankBalanceBefore);
    }
}
```

### 권장 수정사항
CEI 패턴 적용 및 ReentrancyGuard 추가:
```solidity
function withdraw() external nonReentrant {
    uint256 amount = balances[msg.sender];
    require(amount > 0);
    balances[msg.sender] = 0; // Effects 먼저
    (bool ok,) = msg.sender.call{value: amount}(""); // Interaction 나중
    require(ok);
}
```

8.2 버그 바운티 참여 전략