Snowman Merkle Airdrop
AI First Flight #10
Beginner FriendlyFoundrySolidityNFT
EXP
View results
Previous Next
Submission Details
Severity: low
Valid

Missing claim state validation allows arbitrary recursive proof/signature replay to drain or infinitely mint collection items

oneside

Root + Impact

Description

  • Describe the normal behavior in one or more sentences

  • Explain the specific issue or problem in one or more sentences

### Description
The `SnowmanAirdrop::claimSnowman` function validates a claimant's EIP-712 cryptographic signature and verifies their eligibility via a Merkle tree proof before transferring tokens and minting a `Snowman` NFT.
​
However, the contract completely lacks a check to see if an address has already claimed an item before executing the function logic. Although `s_hasClaimedSnowman[receiver] = true;` is set at the end of the transaction, this state variable is never queried or enforced anywhere within the contract code.
​
### Code Snippet Reference
```solidity
// src/SnowmanAirdrop.sol -> claimSnowman function
function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
external
nonReentrant
{
// 🔴 BUG: Missing s_hasClaimedSnowman[receiver] check here!
if (receiver == address(0)) {
revert SA__ZeroAddress();
}
// ... validation steps ...
​
i_snow.safeTransferFrom(receiver, address(this), amount);
​
s_hasClaimedSnowman[receiver] = true; // Set but never validated on entry
​
emit SnowmanClaimedSuccessfully(receiver, amount);
i_snowman.mintSnowman(receiver, amount);
}
```
​
### Risk
#### Likelihood:
* Authorized users can easily re-acquire `Snow` tokens after a claim by waiting for the 1-week farming timer using `Snow::earnSnow()` or purchasing them directly via `Snow::buySnow()`.
* Re-acquiring the identical historical balance causes the generated Merkle leaf and original EIP-712 message signatures to evaluate as completely valid on repeated calls.
​
#### Impact:
* Any eligible airdrop recipient can recursively replay their proof and signature parameters to mint an infinite number of `Snowman` NFTs.
* This breaks the intended supply mechanics and devalues the collection.
​

Risk

Likelihood:

  • Reason 1 // Describe WHEN this will occur (avoid using "if" statements)

  • Reason 2

Impact:

  • Impact 1

  • Impact 2

Proof of Concept

function test_InfiniteAirdropReplayExploit() public {
// 1. Initial baseline verification
assertEq(nft.balanceOf(alice), 0);
// Generate valid signature and execute the initial legitimate claim
vm.prank(alice);
snow.approve(address(airdrop), 1);
bytes32 alDigest = airdrop.getMessageHash(alice);
(uint8 alV, bytes32 alR, bytes32 alS) = vm.sign(alKey, alDigest);
​
vm.prank(satoshi);
airdrop.claimSnowman(alice, AL_PROOF, alV, alR, alS);
assertEq(nft.balanceOf(alice), 1);
​
// 2. Replay loop: Bypassing single-claim constraints recursively
for (uint256 i = 0; i < 5; i++) {
vm.warp(block.timestamp + 1 weeks + 1);
vm.prank(alice);
snow.earnSnow(); // Restore balance back to original leaf amount
assertEq(snow.balanceOf(alice), 1);
​
vm.prank(alice);
snow.approve(address(airdrop), 1);
​
// Replay identical signature parameters and Merkle proofs successfully
vm.prank(satoshi);
airdrop.claimSnowman(alice, AL_PROOF, alV, alR, alS);
}
​
// 3. Alice successfully minted 6 total NFTs instead of her intended limit of 1
assertEq(nft.balanceOf(alice), 6);
}
​

Recommended Mitigation

// 1. Define a custom tracking error
error SA__AlreadyClaimed();
​
// 2. Apply a strict entry check at the top of the function
function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
external
nonReentrant
{
if (s_hasClaimedSnowman[receiver]) {
revert SA__AlreadyClaimed();
}
if (receiver == address(0)) {
revert SA__ZeroAddress();
}
// ... remaining logic ...
}
​
Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 1 hour ago
Submission Judgement Published
Validated
Assigned finding tags:

[L-01] Missing Claim Status Check Allows Multiple Claims in SnowmanAirdrop.sol::claimSnowman

# Root + Impact &#x20; **Root:** The [`claimSnowman`](https://github.com/CodeHawks-Contests/2025-06-snowman-merkle-airdrop/blob/b63f391444e69240f176a14a577c78cb85e4cf71/src/SnowmanAirdrop.sol#L44) function updates `s_hasClaimedSnowman[receiver] = true` but never checks if the user has already claimed before processing the claim, allowing users to claim multiple times if they acquire more Snow tokens. **Impact:** Users can bypass the intended one-time airdrop limit by claiming, acquiring more Snow tokens, and claiming again, breaking the airdrop distribution model and allowing unlimited NFT minting for eligible users. ## Description * **Normal Behavior:** Airdrop mechanisms should enforce one claim per eligible user to ensure fair distribution and prevent abuse of the reward system. * **Specific Issue:** The function sets the claim status to true after processing but never validates if `s_hasClaimedSnowman[receiver]` is already true at the beginning, allowing users to claim multiple times as long as they have Snow tokens and valid proofs. ## Risk **Likelihood**: Medium * Users need to acquire additional Snow tokens between claims, which requires time and effort * Users must maintain their merkle proof validity across multiple claims * Attack requires understanding of the missing validation check **Impact**: High * **Airdrop Abuse**: Users can claim far more NFTs than intended by the distribution mechanism * **Unfair Distribution**: Some users receive multiple rewards while others may receive none * **Economic Manipulation**: Breaks the intended scarcity and distribution model of the NFT collection ## Proof of Concept Add the following test to TestSnowMan.t.sol  ```Solidity function testMultipleClaimsAllowed() public { // Alice claims her first NFT vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest = airdrop.getMessageHash(alice); (uint8 v, bytes32 r, bytes32 s) = vm.sign(alKey, aliceDigest); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v, r, s); assert(nft.balanceOf(alice) == 1); assert(airdrop.getClaimStatus(alice) == true); // Alice acquires more Snow tokens (wait for timer and earn again) vm.warp(block.timestamp + 1 weeks); vm.prank(alice); snow.earnSnow(); // Alice can claim AGAIN with new Snow tokens! vm.prank(alice); snow.approve(address(airdrop), 1); bytes32 aliceDigest2 = airdrop.getMessageHash(alice); (uint8 v2, bytes32 r2, bytes32 s2) = vm.sign(alKey, aliceDigest2); vm.prank(alice); airdrop.claimSnowman(alice, AL_PROOF, v2, r2, s2); // Second claim succeeds! assert(nft.balanceOf(alice) == 2); // Alice now has 2 NFTs } ``` ## Recommended Mitigation **Add a claim status check at the beginning of the function** to prevent users from claiming multiple times. ```diff // Add new error + error SA__AlreadyClaimed(); function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external nonReentrant { + if (s_hasClaimedSnowman[receiver]) { + revert SA__AlreadyClaimed(); + } + if (receiver == address(0)) { revert SA__ZeroAddress(); } // Rest of function logic... s_hasClaimedSnowman[receiver] = true; } ```

Support

FAQs

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

Give us feedback!