Daoswap合约邀请奖励漏洞分析

说明

前面分析了两个漏洞，都是获取奖励的漏洞。这些漏洞最大的问题仅仅只是通过balanceOf计算账户的余额，然后根据余额的大小以此发送代币奖励。本篇文章讲解的DaoSwap的漏洞基本上前面两者的漏洞一致，不同的地方是在于，DaoSwap是根据swap的金额的大小，从而发送奖励。

合约分析

DaoRouter，0xf625DF2BE53Cac287fFbaaCbE3A2E5B9d0994885
SwaptoEarn，0xea41bbd80ac69807289d0c4f6582ab73e96834d0
Dao-LP，0xa760dcaa4e907b3cfa8dbeb033207b0100d48219

DaoRouter的设计实现基本上和UniswapV2保持一致，唯一的区别就是所有的swap token增加了一个inviter。当用户完成swap操作之后就会向inviter发送奖励，这个功能就是造成漏洞的原因。

在分析具体攻击交易之前，先分析合约代码，确定漏洞成因。

DaoRouter

DAORouter.sol

function swapTokensForExactTokens(
    uint amountOut,
    uint amountInMax,
    address[] calldata path,
    address to,
    uint deadline, 
    address inviter
) external virtual override ensure(deadline) returns (uint[] memory amounts) {
    amounts = DAOLibrary.getAmountsIn(factory, amountOut, path);
    require(amounts[0] <= amountInMax, 'DAORouter: EXCESSIVE_INPUT_AMOUNT');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, DAOLibrary.pairFor(factory, path[0], path[1]), amounts[0]
    );
    _swap(amounts, path, to, inviter);
}

整个代码逻辑和UniswapV2的代码逻辑一致，只是额外多了一个inviter参数。

继续跟踪进入到_swap()中：

function _swap(uint[] memory amounts, address[] memory path, address _to, address _inviter) internal virtual {
    for (uint i; i < path.length - 1; i++) {
        (address input, address output) = (path[i], path[i + 1]);
        (address token0,) = DAOLibrary.sortTokens(input, output);
        uint amountOut = amounts[i + 1];
        (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        address to = i < path.length - 2 ? DAOLibrary.pairFor(factory, output, path[i + 2]) : _to;

        IDAOPair(DAOLibrary.pairFor(factory, input, output)).swap(
            amount0Out, amount1Out, to
        );

        swap2earnRouter.swapCall(ISwapCallee.Params(msg.sender, DAOLibrary.pairFor(factory, input, output), _inviter, input, output, amounts[i], amountOut));
    }
}

_swap()中的整个交换逻辑和UniswapV2中的_swap()实现完全一致，除了最后一行代码。

1	swap2earnRouter.swapCall(ISwapCallee.Params(msg.sender, DAOLibrary.pairFor(factory, input, output), _inviter, input, output, amounts[i], amountOut));

这行代码就是用来计算给_inviter发送奖励的代码。继续分析swap2earnRouter

// 为了方便说明，对 DAORouter 合约代码进行了精简，仅仅现实和swap2earnRouter有关的代码
interface ISwapCallee {
    struct Params {
        address user;
        address pair;
        address inviter;
        address input;
        address output;
        uint256 amountIn;
        uint256 amountOut;
    }

    function swapCall(Params calldata p) external;
}

ISwapCallee public immutable swap2earnRouter;

constructor(address _factory, address _WETH, address _swap2earnRouter) {
    swap2earnRouter = ISwapCallee(_swap2earnRouter);
}

对应于

1	swap2earnRouter.swapCall(ISwapCallee.Params(msg.sender, DAOLibrary.pairFor(factory, input, output), inviter, input, output, amounts[i], amountOut));

user，当前调用者 msg.sender
pair，配对合约 DAOLibrary.pairFor(factory, input, output)
inviter，邀请人inviter
input，token0 的地址
output，token1的地址
amountIn，token0的输入数额
amountOut，token1的输出金额

后面就需要分析swap2earnRouter中的实现了

SwaptoEarn

顾名思义，通过swap就可以获得奖励。在swapCall()中存在两个逻辑。不仅调用swap本身的合约可以获取到swap的奖励。如果swap中的一个token是Dao代币，inviter还可以获取Dao代币奖励。

user 获取奖励

下面就是user因为swap 之后，根据swap的数量或者是金额获取奖励。查看swapCall函数的基本调用如下：

function swapCall(Params memory p) external {
    address user = p.user;
    address pair = p.pair;
    address inviter = p.inviter;
    address input = p.input;
    address output = p.output;
    uint256 amountIn = p.amountIn;
    uint256 amountOut = p.amountOut;

    require(msg.sender == swapRouter, "not swap router");
    ....
}

swapCall仅仅只是限制了msg.sender需要是swapRouter，对于user和inviter没有任何的限制，所以我们在通过swap获取奖励时，可以将user和inviter同时设置为我们的地址，这样，我们就可以获得更多的奖励。

下面分析user和inviter的奖励算法。

user奖励

// output token has swap rewards
if (tokenRewards[output] > 0) {
	
		// 获得 output 对应token的精度
    uint256 d = uint256(IERC20Metadata(output).decimals());
    // 计算 efficiency 的份额
    uint256 staked = daoStakedInfo[user].staked / (10 ** d);
    //efficiency based 10000
    uint256 efficiency = 10;
    if (staked < 200) {
        efficiency = 10;
    } else if (staked >= 200 && staked < 500) {
        efficiency = 20;
    } else if (staked >= 500 && staked < 1000) {
        efficiency = 30;
    } else if (staked >= 1000 && staked < 5000) {
        efficiency = 40;
    } else if (staked >= 5000) {
        efficiency = 60;
    }
		
		// 获得需要奖励的代币数量
    uint256 amount = amountOut.mul(efficiency).div(10000);
    if (amount > tokenRewards[output]) {
        amount = tokenRewards[output];
    }
    // 更新代币数量
    tokenRewards[output] = tokenRewards[output].sub(amount);
    swapRewards[user][output] = swapRewards[user][output].add(amount);
    IERC20(output).safeTransfer(user, amount);
}

inviter奖励

//inviter
if (inviter != address(0)) {
    // based 10000
    uint256 reward = 10;
    uint256 amount = 0;
    // 要求swap中的任意一个token是DAO，最高是0.1%的奖励
    if (input == address(DAO)) {
        amount = amountIn.mul(reward).div(10000);
    } else if (output == address(DAO)) {
        amount = amountOut.mul(reward).div(10000);
    }
    if (amount > DAO.balanceOf(address(this))) {
        amount = DAO.balanceOf(address(this));
    }
    if (amount > 0) {
        totalInviteRewards = totalInviteRewards.add(amount);
        // 发放奖励
        DAO.safeTransfer(inviter, amount);
        inviteRewards[inviter] = inviteRewards[inviter].add(amount);
    }
}