Real-Life Denial of Service Attacks on Smart Contracts

What you will learn

• Real audit findings from competitive auditing platforms
• Five distinct DoS attack vectors with code examples and recommended fixes
• How seemingly innocent design choices can freeze entire protocols

DoS caused by underflow

See also: For a broader look at overflow and underflow vulnerabilities — including silent overflow during type casting and real high/medium audit findings — read Overflow & Underflow in Solidity.

The vulnerability: harvestFees() pushes borrowed USDC above borrow cap

1if (_seniorVaultWethRewards > state.wethConversionThreshold) {
2    uint256 minUsdcAmount = _getTokenPricsdc(state, state.weth).mulDivDown(
3        _seniorVaultWethRewards * (MAX_BPS - state.slippageThresholdSwapEthBps),
4        MAX_BPS * PRICE_PRECISION
5    );
6    // swaps weth into usdc
7    (uint256 aaveUsdcAmount, ) = state._swapToken(
8        address(state.weth),
9        _seniorVaultWethRewards,
10        minUsdcAmount
11    );
12    // supplies usdc into AAVE
13    state._executeSupply(address(state.usdc), aaveUsdcAmount);
14    // resets senior tranche rewards
15    state.seniorVaultWethRewards = 0;
16}

1function getUsdcBorrowed() public view returns (uint256 usdcAmount) {
2    return uint256(
3        state.aUsdc.balanceOf(address(this)).toInt256() -
4            state.dnUsdcDeposited -
5            state.unhedgedGlpInUsdc.toInt256()
6    );
7}

1function availableBorrow(address borrower) public view returns (uint256 availableAUsdc) {
2    uint256 availableBasisCap =
3        borrowCaps[borrower] - IBorrower(borrower).getUsdcBorrowed(); // underflow here
4    uint256 availableBasisBalance = aUsdc.balanceOf(address(this));
5    availableAUsdc = availableBasisCap < availableBasisBalance
6        ? availableBasisCap
7        : availableBasisBalance;
8}

Recommendation

1function availableBorrow(address borrower) public view returns (uint256 availableAUsdc) {
2    uint256 borrowCap = borrowCaps[borrower];
3    uint256 borrowed = IBorrower(borrower).getUsdcBorrowed();
4
5    if (borrowed > borrowCap) return 0;
6
7    uint256 availableBasisCap = borrowCap - borrowed;
8    uint256 availableBasisBalance = aUsdc.balanceOf(address(this));
9    availableAUsdc = availableBasisCap < availableBasisBalance
10        ? availableBasisCap
11        : availableBasisBalance;
12}

DoS caused by gas limit

The vulnerability: unbounded arrays grow indefinitely

1Receipt[] public deposits;
2mapping(address => uint256[]) public userDepositsIndex;

1function depositUSDC(uint256 _amount) external {
2    require(_amount >= minUSDCAmount, "deposit amount smaller than minimum OTC amount");
3    IERC20(usdc).transferFrom(msg.sender, address(this), _amount);
4
5    usdBalance[msg.sender] = usdBalance[msg.sender] + _amount;
6    deposits.push(Receipt(msg.sender, _amount));
7    userDepositsIndex[msg.sender].push(deposits.length - 1);
8
9    emit USDCQueued(msg.sender, _amount, usdBalance[msg.sender], deposits.length - 1);
10}

1uint256 toRemove = _amount;
2uint256 lastIndexP1 = userDepositsIndex[msg.sender].length;
3for (uint256 i = lastIndexP1; i > 0; i--) {
4    Receipt storage r = deposits[userDepositsIndex[msg.sender][i - 1]];
5    if (r.amount > toRemove) {
6        r.amount -= toRemove;
7        toRemove = 0;
8        break;
9    } else {
10        toRemove -= r.amount;
11        delete deposits[userDepositsIndex[msg.sender][i - 1]];
12    }
13}

Recommendation

DoS caused by nonReentrant modifier

The vulnerability: internal call chain triggers reentrancy guard on itself

11. HighStreetPoolBase.unstake()          (nonReentrant)
22.   └─ HighStreetCorePool._unstake()
33.       └─ HighStreetPoolBase._unstake()
44.           ├─ HighStreetPoolBase._sync()
55.           └─ HighStreetCorePool._processRewards()
66.               └─ HighStreetCorePool._processVaultRewards()
77.                   └─ HighStreetCorePool.transferHighToken()  (nonReentrant)

1function _processVaultRewards(address _staker) private {
2    User storage user = users[_staker];
3    uint256 pendingVaultClaim = pendingVaultRewards(_staker);
4    if (pendingVaultClaim == 0) return;
5
6    uint256 highBalance = IERC20(HIGH).balanceOf(address(this));
7    require(highBalance >= pendingVaultClaim, "contract HIGH balance too low");
8
9    if (poolToken == HIGH) {
10        poolTokenReserve -= pendingVaultClaim > poolTokenReserve
11            ? poolTokenReserve
12            : pendingVaultClaim;
13    }
14    user.subVaultRewards = weightToReward(user.totalWeight, vaultRewardsPerWeight);
15
16    // this call reverts because unstake() already holds the reentrancy lock
17    transferHighToken(_staker, pendingVaultClaim);
18}

Recommendation

See also: To understand why nonReentrant exists and how it prevents actual reentrancy attacks, read our deep-dive on Reentrancy Attacks in Solidity — covering the CEI pattern, single-function guards, and the GlobalReentrancyGuard for cross-contract protection.

DoS caused by external call

The vulnerability: blocked Chainlink oracle reverts all dependent functions

1function viewPrice(address token, uint collateralFactorBps) external view returns (uint) {
2    if (fixedPrices[token] > 0) return fixedPrices[token];
3    if (feeds[token].feed != IChainlinkFeed(address(0))) {
4        uint price = feeds[token].feed.latestAnswer();
5        require(price > 0, "Invalid feed price");
6        // normalize price ...
7    }
8}

Recommendation

1try feeds[token].feed.latestAnswer() returns (int256 price) {
2    // process price normally
3} catch Error(string memory) {
4    // fallback to alternative price source or cached value
5}

DoS caused by malicious receiver

The vulnerability: attacker-controlled supportsInterface reverts critical functions

1function buyoutLien(ILienToken.LienActionBuyout calldata params) external {
2    // ... validation logic ...
3    _transfer(ownerOf(lienId), address(params.receiver), lienId);
4}

1for (uint256 i = 0; i < liensRemaining.length; i++) {
2    ILienToken.Lien memory lien = LIEN_TOKEN.getLien(liensRemaining[i]);
3    if (
4        PublicVault(LIEN_TOKEN.ownerOf(i)).supportsInterface(
5            type(IPublicVault).interfaceId
6        ) // attacker reverts here
7    ) {
8        PublicVault(LIEN_TOKEN.ownerOf(i)).decreaseYIntercept(lien.amount);
9    }
10}

Recommendation

Key takeaways

Get in touch

FAQ: Denial of Service attacks on smart contracts

Glossary

Is Your Protocol Exposed to DoS Vectors?