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

Excess Balance Blocks Airdrop Claim in `SnowmanAirdrop.sol`

emokprime

Excess Balance Blocks Airdrop Claim in SnowmanAirdrop.sol

Description

  • The SnowmanAirdrop.sol contract validates airdrop eligibility by generating a Merkle leaf based on the user's address and their amount of Snow tokens to be claimed. Normally, a user with a valid airdrop allotment should be able to claim their NFTs as long as they meet the required balance.

  • The claimSnowman function calculates the amount for the Merkle leaf by calling i_snow.balanceOf(receiver). This means the Merkle proof is only valid if the user's exact current balance matches the amount stored in the Merkle root at the time of airdrop generation.

// src/SnowmanAirdrop.sol
​
84: uint256 amount = i_snow.balanceOf(receiver);
85:
@> bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));
86:
@> if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) {
revert SA__InvalidProof();
}

Risk

Likelihood: High

  • If a user earning a free Snow token or buying extra tokens increases their balance above their pre-allocated airdrop amount, they will be unable to claim their NFTs.

  • Because the protocol encourages earning "free" tokens weekly, many users will naturally increase their balances, inadvertently disqualifying themselves from claiming their airdrop without a way to "burn" the excess tokens.

Proof of Concept

The following PoC demonstrates how a user with an allotment of 1 NFT becomes unable to claim because they earned 1 extra Snow token, bringing their total balance to 2.

// test/AuditPoC.t.sol
​
function test_excessBalanceBlocksClaim() public {
// 1. Setup a receiver with a Merkle allotment for 1 NFT
address receiver = vm.addr(0xabc);
uint256 airdropAmount = 1;
​
// ... setup Merkle root for amount=1 ...
​
// 2. User buys 1 token and then earns 1 free token (Total balance = 2)
vm.prank(receiver);
snow.buySnow{value: 1 ether}(1);
vm.prank(receiver);
snow.earnSnow(); // Balance is now 2
// 3. The claim fails because the balance (2) does not match the airdrop amount (1)
vm.prank(receiver);
vm.expectRevert(SnowmanAirdrop.SA__InvalidProof.selector);
airdrop.claimSnowman(receiver, proof, v, r, s);
console2.log("Claim failed: Excess balance blocked the airdrop claim");
}

Recommended Mitigation

Store the intended airdrop amount in the function parameters or a mapping instead of reading the user's current token balance from the Snow contract. This allows users to hold more tokens than their airdrop amount while still being able to claim their specific allotment.

- function claimSnowman(address receiver, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
+ function claimSnowman(address receiver, uint256 amount, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s)
external
nonReentrant
{
- uint256 amount = i_snow.balanceOf(receiver);
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount))));

(Note: This change requires the user to specify their correct allotment and only transfers that amount from their balance).

Updates

Lead Judging Commences

ai-first-flight-judge Lead Judge about 2 hours ago
Submission Judgement Published
Validated
Assigned finding tags:

[M-01] DoS to a user trying to claim a Snowman

# Root + Impact ## Description * Users will approve a specific amount of Snow to the SnowmanAirdrop and also sign a message with their address and that same amount, in order to be able to claim the NFT * Because the current amount of Snow owned by the user is used in the verification, an attacker could forcefully send Snow to the receiver in a front-running attack, to prevent the receiver from claiming the NFT.  ```Solidity function getMessageHash(address receiver) public view returns (bytes32) { ... // @audit HIGH An attacker could send 1 wei of Snow token to the receiver and invalidate the signature, causing the receiver to never be able to claim their Snowman uint256 amount = i_snow.balanceOf(receiver); return _hashTypedDataV4( keccak256(abi.encode(MESSAGE_TYPEHASH, SnowmanClaim({receiver: receiver, amount: amount}))) ); ``` ## Risk **Likelihood**: * The attacker must purchase Snow and forcefully send it to the receiver in a front-running attack, so the likelihood is Medium **Impact**: * The impact is High as it could lock out the receiver from claiming forever ## Proof of Concept The attack consists on Bob sending an extra Snow token to Alice before Satoshi claims the NFT on behalf of Alice. To showcase the risk, the extra Snow is earned for free by Bob. ```Solidity function testDoSClaimSnowman() public { assert(snow.balanceOf(alice) == 1); // Get alice's digest while the amount is still 1 bytes32 alDigest = airdrop.getMessageHash(alice); // alice signs a message (uint8 alV, bytes32 alR, bytes32 alS) = vm.sign(alKey, alDigest); vm.startPrank(bob); vm.warp(block.timestamp + 1 weeks); snow.earnSnow(); assert(snow.balanceOf(bob) == 2); snow.transfer(alice, 1); // Alice claim test assert(snow.balanceOf(alice) == 2); vm.startPrank(alice); snow.approve(address(airdrop), 1); // satoshi calls claims on behalf of alice using her signed message vm.startPrank(satoshi); vm.expectRevert(); airdrop.claimSnowman(alice, AL_PROOF, alV, alR, alS); } ``` ## Recommended Mitigation Include the amount to be claimed in both `getMessageHash` and `claimSnowman` instead of reading it from the Snow contract. Showing only the new code in the section below ```Python function claimSnowman(address receiver, uint256 amount, bytes32[] calldata merkleProof, uint8 v, bytes32 r, bytes32 s) external nonReentrant { ... bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(receiver, amount)))); if (!MerkleProof.verify(merkleProof, i_merkleRoot, leaf)) { revert SA__InvalidProof(); } // @audit LOW Seems like using the ERC20 permit here would allow for both the delegation of the claim and the transfer of the Snow tokens in one transaction i_snow.safeTransferFrom(receiver, address(this), amount); // send ... } ```

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.

Give us feedback!