Delete 2024-08-wildcat.json

2024-08-wildcat.json

@@ -1,10 +0,0 @@
-[
-    {
-		"Title": "User could withdraw more than supposed to, forcing last user withdraw to fail",
-        "Function_Vulnerability": "function _executeWithdrawal( MarketState memory state, address accountAddress, uint32 expiry, uint baseCalldataSize ) internal returns (uint256) { WithdrawalBatch memory batch = _withdrawalData.batches[expiry]; \/\/ If the market is closed, allow withdrawal prior to expiry. if (expiry >= block.timestamp && !state.isClosed) { revert_WithdrawalBatchNotExpired(); } AccountWithdrawalStatus storage status = _withdrawalData.accountStatuses[expiry][ accountAddress ]; uint128 newTotalWithdrawn = uint128( MathUtils.mulDiv(batch.normalizedAmountPaid, status.scaledAmount, batch.scaledTotalAmount) ); uint128 normalizedAmountWithdrawn = newTotalWithdrawn - status.normalizedAmountWithdrawn; if (normalizedAmountWithdrawn == 0) revert_NullWithdrawalAmount(); hooks.onExecuteWithdrawal(accountAddress, normalizedAmountWithdrawn, state, baseCalldataSize); status.normalizedAmountWithdrawn = newTotalWithdrawn; state.normalizedUnclaimedWithdrawals -= normalizedAmountWithdrawn; if (_isSanctioned(accountAddress)) { \/\/ Get or create an escrow contract for the lender and transfer the owed amount to it. \/\/ They will be unable to withdraw from the escrow until their sanctioned \/\/ status is lifted on Chainalysis, or until the borrower overrides it. address escrow = _createEscrowForUnderlyingAsset(accountAddress); asset.safeTransfer(escrow, normalizedAmountWithdrawn); \/\/ Emit `SanctionedAccountWithdrawalSentToEscrow` event using a custom emitter. emit_SanctionedAccountWithdrawalSentToEscrow( accountAddress, escrow, expiry, normalizedAmountWithdrawn ); } else { asset.safeTransfer(accountAddress, normalizedAmountWithdrawn); } emit_WithdrawalExecuted(expiry, accountAddress, normalizedAmountWithdrawn); return normalizedAmountWithdrawn; }",
-        "Description": "Within Wildcat, withdraw requests are put into batches. Users first queue their withdraws and whenever there’s sufficient liquidity, they’re filled at the current rate. Usually, withdraw requests are only executable after the expiry passes and then all users within the batch get a cut from the batch.normalizedAmountPaid proportional to the scaled amount they’ve requested a withdraw for. uint128 newTotalWithdrawn = uint128( MathUtils.mulDiv(batch.normalizedAmountPaid, status.scaledAmount, batch.scaledTotalAmount) ); This makes sure that the sum of all withdraws doesn’t exceed the total batch.normalizedAmountPaid. However, this invariant could be broken, if the market is closed as it allows for a batch’s withdraws to be executed, before all requests are added. Consider the market is made of 3 lenders - Alice, Bob and Laurence. Alice queues a larger withdraw with an expiry time 1 year in the future. Market gets closed. Alice executes her withdraw request at the current rate. Bob makes queues multiple smaller requests. As they’re smaller, the normalized amount they represent suffers higher precision loss. Because they’re part of the whole batch, they also slightly lower the batch’s overall rate. Bob executes his requests. Laurence queues a withdraw for his entire amount. When he attempts to execute it, it will fail. This is because Alice has executed her withdraw at a higher rate than the current one and there’s now insufficient state.normalizedUnclaimedWithdrawals Note: marking this as High severity as it both could happen intentionally (attacker purposefully queuing numerous low-value withdraws to cause rounding down) and also with normal behaviour in high-value closed access markets where a user’s withdraw could easily be in the hundreds of thousands. Also breaks core invariant: The sum of all transfer amounts for withdrawal executions in a batch must be less than or equal to batch.normalizedAmountPaid",
-		"Severity": "High",
-		"POC_Foundry_Hardhat": "function test_deadrosesxyzissue() external { parameters.annualInterestBips = 3650; _deposit(alice, 1e18); _deposit(bob, 0.5e18); address laurence = address(1337); _deposit(laurence, 0.5e18); fastForward(200 weeks); vm.startPrank(borrower); asset.approve(address(market), 10e18); asset.mint(borrower, 10e18); vm.stopPrank(); vm.prank(alice); uint32 expiry = market.queueFullWithdrawal();       \/\/ alice queues large withdraw vm.prank(borrower); market.closeMarket();                               \/\/ market is closed market.executeWithdrawal(alice, expiry);     \/\/ alice withdraws at the current rate vm.startPrank(bob); for (uint i; i < 10; i++) { market.queueWithdrawal(1);        \/\/ bob does multiple small withdraw requests just so they round down the batch's overall rate } market.queueFullWithdrawal(); vm.stopPrank(); vm.prank(laurence); market.queueFullWithdrawal(); market.executeWithdrawal(bob, expiry);     \/\/ bob can successfully withdraw all of his funds vm.expectRevert(); market.executeWithdrawal(laurence, expiry);    \/\/ laurence cannot withdraw his funds. Scammer get scammed. }",
-		"Recommended": "Although it’s not a clean fix, consider adding a addNormalizedUnclaimedRewards function which can only be called after a market is closed. It takes token from the user and increases the global variable state.normalizedUnclaimedRewards. The invariant would remain broken, but it will make sure no funds are permanently stuck."
-    }
-]