claimSnowman() never checks s_hasClaimedSnowman, so the same allocation can be claimed repeatedly and the same signature replays
Root + Impact
The airdrop keeps a s_hasClaimedSnowman mapping precisely to make each allocation claimable once, and claimSnowman even writes it (s_hasClaimedSnowman[receiver] = true). But it never reads it. Nothing stops a receiver from claiming again as soon as their Snow balance matches their allocated amount again, which they can restore trivially by earning or buying Snow. The claim amount is the receiver's live balance, and the signed message is only (receiver, amount), so when the balance returns to the allocated value, literally the same Merkle proof and the same signature (v, r, s) verify again; the "claim via someone else with a signature" flow makes the replay usable by anyone holding one observed signature. Each repeat run mints another full set of NFTs for the same allocation, so one leaf of the tree pays out an unbounded number of times.
Description
Risk
Likelihood: High - any eligible receiver can repeat their claim at will; restoring the required balance costs one weekly earn or a purchase at the configured buy fee, and the proof and signature from the first claim can be reused byte-for-byte.
Impact: High - a single Merkle allocation mints its NFT amount over and over, inflating the Snowman supply and breaking the one-claim-per-allocation guarantee the airdrop is built on; observed claim signatures become reusable minting vouchers for third parties as well.
Proof of Concept
Verified with Foundry (test passes). Alice has a 1-Snow allocation (single-leaf tree, empty proof). She claims and receives 1 NFT. She buys 1 Snow to restore her balance to the allocated amount, and claims again with the same (empty) proof and the exact same signature; the second claim succeeds and she holds 2 NFTs while getClaimStatus(alice) was already true.
Recommended Mitigation
Enforce the flag at the start of claimSnowman:
Lead Judging Commences
[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; } ```
Rewards breakdown
Live
The contest is live. Earn rewards by submitting a finding.
Judging
Submissions are being reviewed by our AI judge. Results will be available in a few minutes.
View all submissionsRewards Distribution
The contest is complete and the rewards are being distributed.