AirDropper
AI First Flight #5
Beginner FriendlyDeFiFoundry
EXP
View results
Previous Next
Submission Details
Severity: high
Valid

Reusable Merkle proofs let a single recipient drain the airdrop

joshuapaul1

Description

The airdrop is intended to distribute a single fixed allocation to each address represented by a leaf in the Merkle tree.
claim() validates that (account, amount) belongs to the tree, then transfers tokens to that account. However, the contract does not record that the leaf has already claimed. The same valid proof can therefore be submitted repeatedly until the airdrop’s token balance is exhausted.
function claim(address account, uint256 amount, bytes32[] calldata merkleProof) external payable {
if (msg.value != FEE) {
revert MerkleAirdrop__InvalidFeeAmount();
}

bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount))));
if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {
revert MerkleAirdrop__InvalidProof();
}
​
// @> No claimed-leaf state is checked or updated.
emit Claimed(account, amount);
i_airdropToken.safeTransfer(account, amount); // @> The same allocation can be transferred repeatedly.
}

Risk

Likelihood:

  • An eligible recipient obtains their Merkle proof as part of the normal airdrop process.

    The recipient repeatedly calls claim() with the same account, amount, and proof while the airdrop holds sufficient tokens.

Impact:

  • A single eligible recipient can collect more than their intended allocation.

    The recipient can drain the entire airdrop token balance, preventing other eligible recipients from claiming their allocations.

#Proof of Concept
An airdrop funded with 100e6 token units and four allocations of 25e6 can be drained by claiming the first allocation four times:
function testEligibleUserCanClaimRepeatedly() public {
uint256 fee = airdrop.getFee();
vm.deal(collectorOne, fee * 4);

vm.startPrank(collectorOne);
​
for (uint256 i; i < 4; ++i) {
airdrop.claim{value: fee}(collectorOne, amountToCollect, proof);
}
​
vm.stopPrank();
​
// collectorOne was entitled to 25e6, but receives the full 100e6 airdrop balance.
assertEq(token.balanceOf(collectorOne), amountToCollect * 4);
assertEq(token.balanceOf(address(airdrop)), 0);
}

Recommended Mitigation

Track each claimed allocation and reject subsequent claims. Mark the leaf as claimed before transferring tokens.
mapping(bytes32 leaf => bool claimed) private s_claimed;

error MerkleAirdrop__AlreadyClaimed();

function claim(address account, uint256 amount, bytes32[] calldata merkleProof) external payable {
if (msg.value != FEE) revert MerkleAirdrop__InvalidFeeAmount();

bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount))));
if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {
revert MerkleAirdrop__InvalidProof();
}
if (s_claimed[leaf]) revert MerkleAirdrop__AlreadyClaimed();
​
s_claimed[leaf] = true;
emit Claimed(account, amount);
i_airdropToken.safeTransfer(account, amount);
}
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge 2 days ago
Submission Judgement Published
Validated
Assigned finding tags:

[H-02] Eligible users can claim their airdrop amounts over and over again, draining the contract

## Description A user eligible for the airdrop can verify themselves as being part of the merkle tree and claim their airdrop amount. However, there is no mechanism enabled to track the users who have already claimed their airdrop, and the merkle tree is still composed of the same user. This allows users to drain the `MerkleAirdrop` contract by calling the `MerkleAirdrop::claim()` function over and over again. ## Impact **Severity: High**<br/>**Likelihood: High** A malicious user can call the `MerkleAirdrop::claim()` function over and over again until the contract is drained of all its funds. This also means that other users won't be able to claim their airdrop amounts. ## Proof of Code Add the following test to `./test/MerkleAirdrop.t.sol`, ```javascript function testClaimAirdropOverAndOverAgain() public { vm.deal(collectorOne, airdrop.getFee() * 4); for (uint8 i = 0; i < 4; i++) { vm.prank(collectorOne); airdrop.claim{ value: airdrop.getFee() }(collectorOne, amountToCollect, proof); } assertEq(token.balanceOf(collectorOne), 100e6); } ``` The test passes, and the malicious user has drained the contract of all its funds. ## Recommended Mitigation Use a mapping to store the addresses that have claimed their airdrop amounts. Check and update this mapping each time a user tries to claim their airdrop amount. ```diff contract MerkleAirdrop is Ownable { using SafeERC20 for IERC20; error MerkleAirdrop__InvalidFeeAmount(); error MerkleAirdrop__InvalidProof(); error MerkleAirdrop__TransferFailed(); + error MerkleAirdrop__AlreadyClaimed(); uint256 private constant FEE = 1e9; IERC20 private immutable i_airdropToken; bytes32 private immutable i_merkleRoot; + mapping(address user => bool claimed) private s_hasClaimed; ... function claim(address account, uint256 amount, bytes32[] calldata merkleProof) external payable { + if (s_hasClaimed[account]) revert MerkleAirdrop__AlreadyClaimed(); if (msg.value != FEE) { revert MerkleAirdrop__InvalidFeeAmount(); } bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount)))); if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) { revert MerkleAirdrop__InvalidProof(); } + s_hasClaimed[account] = true; emit Claimed(account, amount); i_airdropToken.safeTransfer(account, amount); } ``` Now, let's unit test the changes, ```javascript function testCannotClaimAirdropMoreThanOnceAnymore() public { vm.deal(collectorOne, airdrop.getFee() * 2); vm.prank(collectorOne); airdrop.claim{ value: airdrop.getFee() }(collectorOne, amountToCollect, proof); vm.prank(collectorOne); airdrop.claim{ value: airdrop.getFee() }(collectorOne, amountToCollect, proof); } ``` The test correctly fails, with the following logs, ```shell Failing tests: Encountered 1 failing test in test/MerkleAirdropTest.t.sol:MerkleAirdropTest [FAIL. Reason: MerkleAirdrop__AlreadyClaimed()] testCannotClaimAirdropMoreThanOnceAnymore() (gas: 96751) ```

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!