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

Missing Claim Status Validation in claimSnowman Allows Infinite Token Re-claiming and Unauthorized NFT Minting

ashrafulshovo8

Description

The contract SnowmanAirdrop.sol defines a state mapping s_hasClaimedSnowman to keep track of users who have successfully claimed their airdrop rewards. Inside the claimSnowman function, the contract successfully updates this mapping to true at the end of a successful execution.

However, the function never validates this state mapping anywhere during execution. There is no conditional check at the beginning of the function to verify whether s_hasClaimedSnowman[receiver] is already true. As a result, an eligible user with a valid Merkle proof and EIP-712 signature can call claimSnowman repeatedly.

// Vulnerable function lacks entry check for s_hasClaimedSnowman
function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
if (receiver == address(0)) { revert SA__ZeroAddress(); }
// @audit - Missing check here!
if (i_snow.balanceOf(receiver) == 0) { revert SA__ZeroAmount(); }
​

Risk

Likelihood:

  • An eligible user already possesses a valid Merkle proof and cryptographic signature generated off-chain.

  • The transaction requires no special state manipulation other than calling the public claimSnowman function multiple times.

Impact:

  • A malicious user can drain or infinitely inflate the Snowman NFT supply via the i_snowman.mintSnowman(receiver, amount) function.

  • It breaks the core fairness and limited tokenomics of the airdrop distribution model.

Proof of Concept

1. First Call: Alice has a valid proof and signature. She calls `claimSnowman(alice, proof, v, r, s)`. The transaction passes, and `s_hasClaimedSnowman[alice]` becomes `true`.
2. Second Call: Alice invokes `claimSnowman(alice, proof, v, r, s)` again with the exact same valid arguments.
3. Because there is no validation check like `if(s_hasClaimedSnowman[receiver]) revert();`, the function passes completely a second time, minting duplicate NFT assets to Alice.
​
/**
* @dev Proof of Concept Explanation:
* The `claimSnowman` function transfers tokens via `safeTransferFrom` and updates `s_hasClaimedSnowman[receiver] = true`.
* However, since there is no initial guard check to evaluate `s_hasClaimedSnowman[receiver]`, the logic flow allows
* a user to enter the function and pass all subsequent cryptographic checks multiple times using the same proof parameters.
*/
​
​

Recommended Mitigation

### Mitigation Explanation
Add a state validation rule to the beginning of the `claimSnowman` function execution pipeline to prevent re-entry by addresses that have already interacted with the distribution contract.
​
### Code Fix:
- if (receiver == address(0)) {
- revert SA__ZeroAddress();
- }
+ if (receiver == address(0)) {
+ revert SA__ZeroAddress();
+ }
+ if (s_hasClaimedSnowman[receiver]) {
+ revert SA__AlreadyClaimed();
+ }
​
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   **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!