Bridge Smart Contracts - Dynex

The BridgeEVM contract contains a critical vulnerability in its implementation of the minSend check. The check is performed on the amountWithFee instead of the actual amount being sent, allowing for potential bypass of the minimum send limit.

The _sendTokens function checks the minSend requirement against amountWithFee:

if (minSend != 0 && amountWithFee < minSend) revert NotReachedMinLimit();

The actual amount sent is calculated as:

amount = amountWithFee - fee;

This implementation allows for a scenario where:

• amountWithFee equals fee

• fee is greater than or equal to minSend

• The resulting amount sent is zero

Modify the _sendTokens function to check the minSend requirement against the actual amount being sent, not amountWithFee:

uint256 actualAmount = amountWithFee - fee;
if (minSend != 0 && actualAmount < minSend) revert NotReachedMinLimit();

SOLVED: A new check was added which ensures that minSend is always greater than fee:

if (_minSend <= _fee) revert IncorrectMinSend();

The BridgeEVM::sendTokensWithPermit function processes a permit, suggesting support for third-party transfers.

• However, in the _sendTokens function (called by sendTokensWithPermit), tokens are always transferred from and burned from the msg.sender:

  if (fee != 0) dnx.safeTransferFrom(msg.sender, feeWallet, fee);
  dnx.burnFrom(msg.sender, amount);

• This implementation requires the function caller to be the token owner, negating the primary benefit of using a permit.

To address this vulnerability, properly implement the permit functionality.

ACKNOWLEDGED: The Dynex team acknowledged the finding with the following comment: "The idea of using permit in our case was to allow the user to send tokens by calling 1 transaction (send Tokens With Permit) instead of 2 (approve + sendTokens) for better UX."

The receiveTokensBatch function in the BridgeEVM contract lacks a check to ensure that the lengths of the transactions and signatures arrays match. This oversight could lead to unexpected behavior and potential security risks.

function receiveTokensBatch(Transaction[] calldata transactions, bytes[] memory signatures) external {
    uint256 length = signatures.length;
    for (uint256 i = 0; i < length; ++i) {
        receiveTokens(transactions[i], signatures[i]);
    }
}

Add a check at the beginning of the function to ensure array lengths match:

function receiveTokensBatch(Transaction[] calldata transactions, bytes[] memory signatures) external {
    require(transactions.length == signatures.length, "Array length mismatch");
    uint256 length = signatures.length;
    for (uint256 i = 0; i < length; ++i) {
        receiveTokens(transactions[i], signatures[i]);
    }
}

SOLVED: The suggested mitigation was implemented by the Dynex team.

uint256 length = signatures.length;
if(length != transactions.length) revert IncorrectParameterLength();