Back to Blog

#7: ParaSpace Incident: A Race Against Time to Thwart the Industry's Most Critical Attack Yet

Code Auditing
February 17, 2024
5 min read
Key Insights
  • Root cause: cAPE’s rebasingIndex used total pooled APE (stakedAmount + pending rewards + buffer), which attackers could inflate via ApeCoinStaking.depositApeCoin() to boost collateral value.

  • Attack path: flash-loaned ~47,352 wstETH, borrowed/deposited cAPE as collateral, inflated its value through an APE deposit, then borrowed other assets against it.

Background

On March 17, 2023, Paraspace (now Parallel Finance), an NFT lending platform, suffered a critical attack due to a vulnerability in its price oracle. Paraspace allows users to deposit NFTs and ERC-20 tokens as collateral to borrow ERC-20 tokens, enabling returns on NFTs without selling them.

Click here to read the tweet
Click here to read the tweet

A key feature of ParaSpace is ApeStaking, which auto-compounds APE rewards. Users staking APE receive cAPE tokens, a cToken representation of APE, which can be used as collateral to borrow assets like USDC and WETH. Depositing cAPE tokens grants pcAPE shares, whose collateral value is calculated by multiplying the pcAPE amount by its rebasingIndex.

The rebasingIndex is derived from the total pooled APE balance and total shares, as shown in the following code snippets:

function _scaledBalanceOf(address user, uint256 rebasingIndex)
    internal
    view
    returns (uint256)
{
    return super.scaledBalanceOf(user).rayMul(rebasingIndex);
}

function lastRebasingIndex() internal view override returns (uint256) {
  return ICApe(_underlyingAsset).getPooledApeByShares(WadRayMath.RAY);
}

function getPooledApeByShares(uint256 sharesAmount)
    public
    view
    returns (uint256)
{
    uint256 totalShares = _getTotalShares();
    if (totalShares == 0) {
        return 0;
    } else {
        return
            sharesAmount.mul(_getTotalPooledApeBalance()).div(totalShares);
    }
}

function _getTotalPooledApeBalance()
    internal
    view
    override
    returns (uint256)
{
    (uint256 stakedAmount, ) = apeStaking.addressPosition(address(this));
    uint256 rewardAmount = apeStaking.pendingRewards(
        APE_COIN_POOL_ID,
        address(this),
        0
    );
    return stakedAmount + rewardAmount + bufferBalance;
}

The _getTotalPooledApeBalance() function sums the staked APE tokens, pending rewards, and a buffer balance from the ApeCoinStaking contract.

Vulnerability Analysis

The vulnerability lies in the manipulation of the rebasingIndex, which artificially inflates the collateral value of cAPE tokens. Specifically, the depositApeCoin() function in the ApeCoinStaking contract increases the stakedAmount for a position. An attacker can exploit this by depositing APE tokens into the cAPE position, inflating the output of _getTotalPooledApeBalance() and thus the rebasingIndex.

function depositApeCoin(uint256 _amount, address _recipient) public {
    if (_amount < MIN_DEPOSIT) revert DepositMoreThanOneAPE();
    updatePool(APECOIN_POOL_ID);

    Position storage position = addressPosition[_recipient];
    _deposit(APECOIN_POOL_ID, position, _amount);

    apeCoin.transferFrom(msg.sender, address(this), _amount);

    emit Deposit(msg.sender, _amount, _recipient);
}

function _deposit(uint256 _poolId, Position storage _position, uint256 _amount) private {
  Pool storage pool = pools[_poolId];
  _position.stakedAmount += _amount;
  pool.stakedAmount += _amount.toUint96();
  _position.rewardsDebt += (_amount * pool.accumulatedRewardsPerShare).toInt256();
}

This design flaw allows the attacker to inflate the collateral value by depositing APE tokens through depositApeCoin() with cAPE as the recipient.

Attack Analysis

The attacker exploited this vulnerability using a flash loan attack in five key steps:

  1. Obtained a flash loan of approximately 47,352 wstETH and supplied about 46,018 wstETH to borrow cAPE via multiple contracts.
  2. Deposited roughly 12,880,000 cAPE tokens as collateral.
  3. Traded approximately 1,205 wstETH for about 492,124 APE tokens and withdrew 1,839,999 cAPE to APE tokens.
  4. Deposited 2,332,214 APE tokens into the cAPE position by calling ApeCoinStaking.depositApeCoin(), increasing the protocol’s stakedAmount from 851,662 to 3,183,876 (a 373% increase).
  5. Leveraged the inflated collateral to borrow large amounts of assets such as USDC and WETH for profit.

This manipulation of the pcAPE price via flash loans exploited the use of spot prices in the oracle calculation.

Get Started with Phalcon Security

Detect every threat, alert what matters, and block attacks.

Try now for free

Summary

The ParaSpace incident underscores the risks of oracle manipulation and flash loan attacks in DeFi protocols. It highlights the critical need for robust, manipulation-resistant price oracles and continuous security monitoring beyond pre-launch audits.

BlockSec’s Phalcon Security system demonstrated the value of active threat detection and prevention by automatically blocking the attack and protecting user assets. This incident serves as a reminder for DeFi protocols to implement comprehensive security measures, including smart contract audits, infrastructure audits, and real-time monitoring.

For more insights on DeFi security incidents and best practices, explore our Security Incident Library and consider our Smart Contract Audit and Infrastructure Audit services.

Explore MetaSleuth Investigation

Trace flows and build evidence for investigations

Try now for free

Best Security Auditor for Web3

Validate design, code, and business logic before launch

Sign up for the latest updates
Beyond Secure Storage, Part 2: Implementing Wallet Cryptography Securely
Security Insights

Beyond Secure Storage, Part 2: Implementing Wallet Cryptography Securely

Can an attacker recover a private key without reading its protected copy? Part 2 of Beyond Secure Storage examines six incidents in which weak randomness, entropy loss, or signing nonce flaws made keys predictable or recoverable. It derives implementation requirements for key generation and signing, then explains how payment institutions can assess them through code review and testing of the deployed system.

Beyond Secure Storage, Part 1: Designing Secure Payment and Signing Workflows
Security Insights

Beyond Secure Storage, Part 1: Designing Secure Payment and Signing Workflows

How can an unauthorized operation obtain a valid signature without the attacker stealing the private key? Part 1 of Beyond Secure Storage uses incidents including Bitget, Bybit and Binance to examine authorization failures across payment requests, transaction construction, signing, execution and settlement. It derives design principles for preventing unauthorized operations and limiting losses, then explains how reviews, audits, penetration tests and exercises can verify those protections.

NEAR Intents Exploit: Refund Flaw and Security Lessons
Security Insights

NEAR Intents Exploit: Refund Flaw and Security Lessons

The NEAR Intents exploit used oversized refund events to preserve internal balances after the deposited assets were returned. This analysis reconstructs the receipt flow and seven BNB Chain withdrawals totaling 3,865,021 USDT, distinguishes those outflows from the project's reported full recovery, and outlines security considerations for developing and auditing NEAR smart contracts.

Best Security Auditor for Web3

Validate design, code, and business logic before launch. Aligned with the highest industry security standards.

BlockSec Audit