Crypto Security Incidents

Ronin Network Bridge Exploit: A $12 Million Lesson in Blockchain and Smart Contract Security​

0xEnami

0xEnami

— 2 min read
Ronin Network Bridge Exploit: A $12 Million Lesson in Blockchain and Smart Contract Security​

On August 6th, 2024, the cryptocurrency world witnessed another significant security breach as the Ronin Network Bridge fell victim to a sophisticated exploit. This incident resulted in the loss of $12 million, comprising $2 million in USDC and 4,000 ETH. The attack, executed by an MEV-bot, exploited a vulnerability introduced during a recent contract upgrade.

The Anatomy of the Attack

The exploit was made possible due to a critical oversight in the bridge's smart contract upgrade process. The Ronin team had deployed a faulty upgrade, transitioning from version 2 to version 4 of their bridge manager, which introduced an uninitialized variable.

Key Components of the Exploit:

Unraveling the Smart Contract Vulnerability

The root cause of the exploit can be traced back to the latest upgrade of the Ronin Bridge. In this upgrade, the totalWeight value, previously fetched from the MainchainBridgeManager contract, was moved to be stored directly in the contract's storage under the variable _totalOperatorWeight.

// File: MainchainGatewayV3.sol


function initializeV2(address bridgeManagerContract) external reinitializer(2) {
    _setContract(ContractType.BRIDGE_MANAGER, bridgeManagerContract);
}

function initializeV3() external reinitializer(3) {
    IBridgeManager mainchainBridgeManager = IBridgeManager(getContract(ContractType.BRIDGE_MANAGER));
    (, address[] memory operators, uint256[] memory weights) = mainchainBridgeManager.getFullBridgeOperatorInfos();
    
    uint256 totalWeight;
    for (uint i; i < operators.length; i++) {
        _operatorWeight[operators[i]] = weights[i];
        totalWeight += weights[i];
    }
    _totalOperatorWeight = totalWeight;
}

function initializeV4(address payable wethUnwrapper_) external reinitializer(4) {
    wethUnwrapper = WETHUnwrapper(wethUnwrapper_);
}

Critical Oversight

The Ronin team introduced a new implementation contract, MainchainGatewayV3, but crucially failed to call the initializeV3 function. This function was essential for setting up the _totalOperatorWeight variable.

Consequences of the Oversight

The failure to initialize _totalOperatorWeight left it at its default value of zero. This inadvertently disabled the minimumVoteWeight parameter, a crucial security check for cross-chain verification, leaving the bridge vulnerable to unauthorized withdrawals.

The Exploit in Action


bytes32 receiptDigest = Transfer.receiptDigest(_domainSeparator, receiptHash);

uint256 minimumWeight;
(minimumWeight, locked) = _computeMinVoteWeight(receipt.info.erc, tokenAddr, quantity);

{
    bool passed;
    address signer;
    address lastSigner;
    Signature memory sig;
    uint256 weight;
    for (uint256 i; i < signatures.length; i++) {
        sig = signatures[i];
        signer = ecrecover(receiptDigest, sig.v, sig.r, sig.s);
        if (lastSigner > signer) revert ErrInvalidOrder(msg.sig);

        lastSigner = signer;

        weight += _getWeight(signer);
        if (weight >= minimumWeight) {
            passed = true;
            break;
        }
    }
}

An MEV bot detected the disabled minimumVoteWeight parameter and swiftly executed a withdrawal transaction, draining 4,000 ETH and 2 million USDC from the bridge.

Damage Control and Recovery

The Ronin Bridge's daily withdrawal limit of $12 million proved to be a critical safeguard, preventing an additional $72 million loss. The Ronin team was alerted to the exploit and managed to pause the bridge contract approximately 38 minutes after the first unauthorized transaction.

Fortunately, both the ETH (valued at approximately $10 million) and the USDC have been returned.

In response to the incident, Ronin’s team activated a comprehensive crypto incident response plan, which included notifying their stakeholders, securing the remaining assets, and working with the affected parties to recover funds.

Lessons Learned and Best Practices

  1. Thorough Testing: Implement comprehensive testing processes for all contract upgrades, focusing on proper initialization of critical variables.
  2. Incremental Deployment: Adopt a staged approach for significant upgrades, with built-in safeguards like lower initial withdrawal limits.
  3. Comprehensive Test Cases: Validate code by writing extensive test cases covering all possible business logic scenarios.
  4. Professional Audits: Engage expert smart contract auditing firms to examine contracts for logical issues. Blockhat provides top-tier smart contract security and end-to-end security for web applications and externally exposed networks. Blockhat Blog also regularly publishes insights on front running attacks, crypto incident response, and other blockchain vulnerabilities.

This incident serves as a stark reminder of the critical importance of meticulous smart contract development, crypto incident response, and security practices in the rapidly evolving world of blockchain technology.

Read more