claimSnowman never checks s_hasClaimedSnowman and derives amount from live balance — a single Merkle allocation can be claimed repeatedly
Root + Impact
Description
Normal behavior: The Merkle tree caps each whitelisted recipient at exactly one allocation: leaf = keccak256(keccak256(abi.encode(receiver, amount))) where amount is the snapshotted Snow balance. The s_hasClaimedSnowman mapping and its getter exist precisely to enforce one claim per address.
Issue: claimSnowman writes s_hasClaimedSnowman[receiver] = true but never reads it anywhere in the claim path — the only guard against a second claim is the zero-balance check. Snow balances are freely re-acquirable via earnSnow() (1 token per week) or buySnow, and because the leaf is derived from the live balanceOf(receiver), restoring the snapshotted amount makes the original Merkle proof and EIP-712 signature valid again.
Risk
Likelihood:
Every whitelisted recipient can re-acquire Snow weekly via
earnSnow(); the moment their balance returns to the snapshot value, the same proof and signature succeed again — no attacker involvement required.
Impact:
The one-time airdrop cap is broken: users mint more NFTs than their Merkle allocation, once per re-acquisition cycle, inflating supply against other recipients.
The signature digest is a pure function of
(receiver, live balance)with no nonce, so a recipient's old signature can be replayed by anyone holding it whenever an allowance is still open, force-staking tokens without consent.
Proof of Concept
The following Foundry test shows Alice claiming her single allocation, re-earning 1 Snow a week later, and claiming again with the original proof and signature. Run with forge test --match-test test_F2_MultipleClaims -vv.
Result: PASS — getClaimStatus(alice) is true yet the second claim succeeds, leaving Alice with 2 NFTs from an allocation of 1.
Recommended Mitigation
Check the flag at the top of the claim path; additionally bind the signature to a snapshot amount or nonce:
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.