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

Airdrop claim flag is set but never checked, so a user can claim repeatedly after restoring their Snow balance

coolteddy141

Root + Impact

Description

// src/SnowmanAirdrop.sol - the claimed flag is written but never read
@> function claimSnowman(address receiver, uint256 amount, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external {
@> bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));
@> if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {
@> revert SA__InvalidMerkleProof();
@> }
@> // ... signature check, then:
@> i_snow.safeTransferFrom(receiver, address(this), amount);
@> s_hasClaimedSnowman[receiver] = true;
@> i_snowman.mintSnowman(receiver, amount);
@> }
​
s_hasClaimedSnowman is set to true on every claim, but it is never read anywhere in the contract: there is no check such as if (s_hasClaimedSnowman[receiver]) revert ... in claimSnowman() or elsewhere. The only things stopping a second claim are that the first claim transfers the receiver's whole Snow balance to the airdrop contract (so getMessageHash() then reverts with SA__ZeroAmount) and that the Merkle leaf is built from the receiver's current balance. Both are restorable: if the receiver re-acquires exactly the leaf amount of Snow, by earning again, buying again, or receiving a transfer, the same leaf, the same Merkle proof and the same signature are valid again, because the signature has no nonce and is not bound to a single use.
​
Impact: the one-claim-per-user rule that the flag was written to enforce does not hold. An eligible user can mint extra NFTs from the airdrop allocation, and the airdrop accounting breaks.

Risk

Likelihood:

Impact:

Proof of Concept

// Steps to reproduce (manual trace against src/SnowmanAirdrop.sol):
// 1. Alice is a leaf (aliceSB, 1 Snow) with the proof from
// test/TestSnowmanAirdrop.t.sol, and holds 1 Snow.
// 2. Alice signs getMessageHash(aliceSB) and calls claimSnowman().
// She receives 1 Snowman NFT and her Snow balance becomes 0.
// 3. Alice earns 1 Snow again (earnSnow, after a week), buys 1 Snow,
// or receives 1 Snow by transfer from another user.
// 4. Alice calls claimSnowman() again with the SAME proof and the SAME
// signature. getMessageHash() returns the same digest (the balance
// is 1 again), the Merkle proof verifies, the signature verifies,
// and s_hasClaimedSnowman is never checked.
// 5. Alice receives a second Snowman NFT. The loop can be repeated.
// The project's tests only claim once per user
// (test/TestSnowmanAirdrop.t.sol), so repeat claims are untested.

Recommended Mitigation

function claimSnowman(address receiver, uint256 amount, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external {
+ if (s_hasClaimedSnowman[receiver]) {
+ revert SA__AlreadyClaimed();
+ }
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));
​
Add a new error SA__AlreadyClaimed to the contract, and check the flag at the start of claimSnowman(), before the Snow transfer and the mint. Consider also adding a nonce to the signed message so that signatures cannot be replayed.
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!