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

SnowmanAirdrop.claimSnowman Does Not Enforce One-Time Claim Allowing Repeat Airdrop Claims

mahmudonblock

Root + Impact:
The claimed flag s_hasClaimedSnowman is written but never checked, so a whitelisted user can claim the NFT repeatedly by re-acquiring exactly 1 Snow, minting far more than the intended single NFT per user.

Description:
After a successful claim the receiver's Snow is burned (balance 0), but s_hasClaimedSnowman[receiver] = true is never used as a guard. The mapping is only read by the getClaimStatus view, so nothing prevents a second claim once the user again holds 1 Snow (e.g. via buySnow(1), which has no per-user cooldown).

// src/SnowmanAirdrop.sol
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; // BUG: written but never checked before a claim
emit SnowmanClaimedSuccessfully(receiver, amount);
i_snowman.mintSnowman(receiver, amount);
}

Risk: Missing state guard / double-claim.

Likelihood: Repeatedly, a whitelisted user re-acquires exactly 1 Snow and submits a valid proof+signature again.
Impact: A single whitelisted address mints unlimited Snowmen instead of one, breaking the core airdrop invariant.

Proof of Concept:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
​
import {Test} from "forge-std/Test.sol";
import {stdJson} from "forge-std/StdJson.sol";
import {Snow} from "../src/Snow.sol";
import {Snowman} from "../src/Snowman.sol";
import {SnowmanAirdrop} from "../src/SnowmanAirdrop.sol";
import {MockWETH} from "../src/mock/MockWETH.sol";
​
contract PoC is Test {
using stdJson for string;
Snow snow; Snowman snowman; SnowmanAirdrop airdrop; MockWETH weth;
address alice; uint256 aliceKey; address satoshi;
bytes32 root; bytes32[] proofAlice;
​
function setUp() public {
weth = new MockWETH();
snow = new Snow(address(weth), 5, makeAddr("collector"));
snowman = new Snowman("data:image/svg+xml;base64,xxx");
string memory output = vm.readFile(string.concat(vm.projectRoot(), "/script/flakes/output.json"));
root = output.readBytes32("[0].root");
proofAlice = output.readBytes32Array("[0].proof");
airdrop = new SnowmanAirdrop(root, address(snow), address(snowman));
(alice, aliceKey) = makeAddrAndKey("alice");
satoshi = makeAddr("satoshi");
}
function _mintOneSnow(address who) internal { vm.deal(who, 1000 ether); vm.prank(who); snow.buySnow{value: snow.s_buyFee()}(1); }
function _approveAirdrop(address who) internal { vm.prank(who); snow.approve(address(airdrop), type(uint256).max); }
function _sign(address who, uint256 key) internal returns (uint8 v, bytes32 r, bytes32 s) { (v, r, s) = vm.sign(key, airdrop.getMessageHash(who)); }
​
function test_high_noClaimOnceGuard() public {
_mintOneSnow(alice);
_approveAirdrop(alice);
(uint8 v, bytes32 r, bytes32 s) = _sign(alice, aliceKey);
vm.prank(satoshi);
airdrop.claimSnowman(alice, proofAlice, v, r, s);
assertEq(snowman.balanceOf(alice), 1);
​
// Re-acquire exactly 1 Snow and claim AGAIN (no once-guard blocks it)
_mintOneSnow(alice);
_approveAirdrop(alice);
(v, r, s) = _sign(alice, aliceKey);
vm.prank(satoshi);
airdrop.claimSnowman(alice, proofAlice, v, r, s);
assertEq(snowman.balanceOf(alice), 2); // impossible if one-time enforced
}
}

Recommended Mitigation (Solidity):

// src/SnowmanAirdrop.sol
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(); // enforce one-time claim
if (i_snow.balanceOf(receiver) == 0) revert SA__ZeroAmount();
// ... rest unchanged
}
Updates

Lead Judging Commences

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