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

MerkleAirdrop::claim lacks a claimed-check

georgibuilds

Root + Impact

Description

  • MerkleAirdrop::claim is intended to allow each eligible address to collect their airdrop allocation exactly once by verifying a Merkle proof against a fixed root

  • The function contains no mechanism to record that an address has already claimed. Because i_merkleRoot is immutable and the proof is purely mathematical, a valid (account, amount, proof) tuple remains valid forever. An eligible address can call claim() repeatedly, receiving amount tokens on every call until the contract's entire token balance is exhausted.Risk

Likelihood:

  • Any eligible address that has claimed once already possesses a valid proof and can immediately replay it

  • The cost per additional claim is exactly 1e9 wei (~$0.000003 at any realistic ETH price), making repeated calls economically free

Impact:

  • The entire contract token balance can be drained by a single eligible address in totalBalance / amountPerClaim transactions

  • All other eligible addresses are permanently denied their allocation once the balance reaches zero

Proof of Concept

The following tests demonstrate the vulnerability in two stages. The first test shows that a single address can claim twice in sequence using the same proof with no revert. The second test shows the worst case: four consecutive calls drain the entire contract balance to zero, permanently blocking all other eligible claimants from receiving their allocation. Both tests are runnable against the deployed contract with no modifications.

function testPoc_DoubleClaim() public {
uint256 fee = airdrop.getFee();
vm.deal(collectorOne, fee * 2);
​
vm.startPrank(collectorOne);
​
// First claim — legitimate
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
assertEq(token.balanceOf(collectorOne), amountToCollect); // 25 USDC
​
// Second claim — same proof, should revert but does not
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
assertEq(token.balanceOf(collectorOne), amountToCollect * 2); // 50 USDC
​
vm.stopPrank();
}
​
function testPoc_FullDrain() public {
uint256 fee = airdrop.getFee();
vm.deal(collectorOne, fee * 4);
​
vm.startPrank(collectorOne);
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
airdrop.claim{ value: fee }(collectorOne, amountToCollect, proof);
vm.stopPrank();
​
// Contract is empty — all other claimants are denied
assertEq(token.balanceOf(address(airdrop)), 0);
assertEq(token.balanceOf(collectorOne), amountToSend); // holds 100 USDC
}

Recommended Mitigation

Introduce a mapping(address => bool) that permanently records each address that has successfully claimed. Set the flag before the external token transfer to follow the Checks-Effects-Interactions pattern. Add a corresponding custom error so callers receive a clear revert reason.

+ mapping(address => bool) private s_hasClaimed;
​
function claim(address account, uint256 amount, bytes32[] calldata merkleProof) external payable {
if (msg.value != FEE) {
revert MerkleAirdrop__InvalidFeeAmount();
}
+ if (s_hasClaimed[account]) {
+ revert MerkleAirdrop__AlreadyClaimed();
+ }
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);
}
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 4 hours 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!