Post-Mortem — Q1 2026 के सबसे बड़े DeFi Hacks

# Post-Mortem — Q1 2026 के सबसे बड़े DeFi Hacks

Q1 2026 में $347M+ worth crypto हैक हुआ। यह पिछले साल से 45% ज्यादा है। हर hack से क्या सीखें?

1. Bridge Signature Malleability — $89M Loss

Date: January 15, 2026

Protocol: CrossChain Bridge (नाम बदला हुआ)

Loss: $89M USDC + ETH

क्या हुआ?

Bridge validator signatures ECDSA use करते थे। Attacker ने signature malleability exploit किया — same message, different signature, replay attack।

// ❌ Vulnerable code
contract Bridge {
    mapping(bytes32 => bool) public processed;

    function withdraw(
        address token,
        uint amount,
        bytes memory signature
    ) external {
        bytes32 msgHash = keccak256(abi.encode(token, amount, msg.sender));
        address signer = recoverSigner(msgHash, signature);
        require(isValidator[signer], "Invalid validator");

        // ⚠️ msgHash tracking — signature नहीं!
        require(!processed[msgHash], "Already processed");
        processed[msgHash] = true;

        IERC20(token).transfer(msg.sender, amount);
    }
}

Attack Flow

1. Attacker gets valid signature for 1M USDC withdrawal
Creates malleable signature (same msgHash, different r/s/v)
Calls withdraw() with original signature ✅
Calls withdraw() with malleable signature ✅
Same msgHash, but signature different — check bypassed
Repeats 89 times before detection

Root Cause

ECDSA signatures malleable हैं। For every valid (r, s, v), there's another valid (r, n-s, v) where n is curve order।

// Fix: Track signature hash, not message hash
mapping(bytes32 => bool) public processedSignatures;

function withdraw(...) external {
    bytes32 sigHash = keccak256(signature);
    require(!processedSignatures[sigHash], "Signature replayed");
    processedSignatures[sigHash] = true;
    // ...
}

Better Fix: OpenZeppelin ECDSA library use करो — यह automatically malleability check करता है:

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

// ECDSA.recover() rejects malleable signatures
address signer = ECDSA.recover(msgHash, signature);

Lessons Learned

कभी भी raw signature verification manually मत करो

OpenZeppelin ECDSA library use करो

Nonces या unique IDs track करो, message hashes नहीं

---

2. Oracle Manipulation — $52M Loss

Date: February 3, 2026

Protocol: Leveraged Yield Aggregator

Loss: $52M in stablecoins

क्या हुआ?

Protocol ने Uniswap V3 TWAP oracle use किया, लेकिन observation window बहुत छोटा था (5 minutes)। Attacker ने flash loan से price manipulate किया।

// ❌ Vulnerable code
contract YieldVault {
    IUniswapV3Pool public pool;
    uint32 public twapInterval = 300;  // 5 minutes

    function getPrice() public view returns (uint) {
        uint32[] memory secondsAgos = new uint32[](2);
        secondsAgos[0] = twapInterval;
        secondsAgos[1] = 0;

        (int56[] memory tickCumulatives,) = pool.observe(secondsAgos);
        int56 tickDelta = tickCumulatives[1] - tickCumulatives[0];
        int24 avgTick = int24(tickDelta / int56(uint56(twapInterval)));

        return getQuoteAtTick(avgTick);
    }

    function deposit(uint amount) external {
        uint collateralValue = getPrice() * amount;
        // Allow 3x leverage based on manipulated price
        uint borrowLimit = collateralValue * 3;
        // ...
    }
}

Attack Flow

1. Flash loan 100M USDC from Aave
Swap USDC → ETH on Uniswap (price spikes)
Wait 5 minutes (TWAP window contaminated)
Deposit small ETH, borrow 3x based on inflated price
Price returns to normal
Liquidation threshold not met (protocol uses same oracle)
Repeat, drain vault

Root Cause

5-minute TWAP बहुत short है। Attacker 5 minutes wait कर सकता है।

// ✅ Better: Longer TWAP + multiple oracles
contract SecureVault {
    uint32 public twapInterval = 1800;  // 30 minutes
    AggregatorV3Interface public chainlinkOracle;

    function getPrice() public view returns (uint) {
        uint uniswapPrice = getUniswapTWAP(twapInterval);
        uint chainlinkPrice = getChainlinkPrice();

        // Deviation check
        uint diff = abs(uniswapPrice - chainlinkPrice);
        require(diff * 100 / chainlinkPrice < 5, "Price deviation");

        return (uniswapPrice + chainlinkPrice) / 2;
    }
}

Lessons Learned

TWAP interval कम से कम 30 minutes

Multiple oracles use करो (Chainlink + Uniswap)

Price deviation checks add करो

Circuit breakers — large price swings पर pause

---

3. Restaking Griefing — $23M Loss

Date: February 18, 2026

Protocol: EigenLayer-style Restaking

Loss: $23M in slashed ETH

क्या हुआ?

Malicious operator ने intentionally slashing condition trigger किया। Protocol में slashing penalties restakers पर equally distributed थे — operator को कोई loss नहीं।

// ❌ Vulnerable design
contract RestakingProtocol {
    mapping(address => uint) public stakedAmount;
    mapping(address => address) public operatorOf;

    function slash(address operator, uint slashAmount) external {
        // Find all stakers of this operator
        address[] memory stakers = getStakersOf(operator);

        // ⚠️ Slash distributed across all stakers
        uint slashPerStaker = slashAmount / stakers.length;

        for (uint i = 0; i < stakers.length; i++) {
            stakedAmount[stakers[i]] -= slashPerStaker;
        }

        // Operator has no skin in the game!
    }
}

Attack Flow

1. Attacker creates operator, stakes 0.1 ETH
Convinces users to delegate 10,000 ETH
Intentionally misbehaves (double-signs)
Slashing triggered: 10% penalty = 1,000 ETH
Loss distributed: users lose 1,000 ETH, operator loses 0.01 ETH
Attacker shorts restaking token, profits from FUD

Root Cause

Operator को कोई penalty नहीं। Bad incentive alignment।

// ✅ Fix: Operator bond + priority slashing
contract SecureRestaking {
    mapping(address => uint) public operatorBond;
    mapping(address => uint) public delegatedStake;

    function slash(address operator, uint slashAmount) external {
        // Slash operator bond first
        uint operatorSlash = min(operatorBond[operator], slashAmount);
        operatorBond[operator] -= operatorSlash;

        uint remaining = slashAmount - operatorSlash;

        // Then slash delegators (if needed)
        if (remaining > 0) {
            slashDelegators(operator, remaining);
        }
    }
}

Lessons Learned

Operators को significant bond stake करना चाहिए

Operator slashing first, delegators second

Reputation systems — bad operators blacklist

---

4. LST Depeg Flash Crash — $67M Loss

Date: March 8, 2026

Protocol: Leveraged LST Vault

Loss: $67M liquidations

क्या हुआ?

Liquid Staking Token (stETH) briefly depegged to 0.92 ETH। Protocol ने instant price use किया, mass liquidations trigger हुए।

// ❌ Vulnerable: Instant price from AMM
contract LSTVault {
    function getLSTPrice() public view returns (uint) {
        // Curve stETH/ETH pool
        return curvePool.get_dy(0, 1, 1 ether);  // Instant price
    }

    function checkLiquidation(address user) external {
        uint collateral = userCollateral[user];
        uint debt = userDebt[user];
        uint collateralValue = collateral * getLSTPrice() / 1e18;

        if (collateralValue * 100 / debt < 110) {
            liquidate(user);  // 10% buffer
        }
    }
}

Attack Flow

1. Market panic — stETH sells off to 0.92
Protocol reads instant price
Users with 1.1x collateralization get liquidated
Liquidations dump more stETH → price drops further
Death spiral: more liquidations → lower price
$67M liquidated in 15 minutes

Root Cause

Instant AMM prices volatile हैं। LSTs temporarily depeg हो सकते हैं, especially during market stress।

// ✅ Fix: Grace period + redemption peg
contract SecureLSTVault {
    mapping(address => uint) public liquidationGracePeriod;

    function markForLiquidation(address user) external {
        uint price = getLSTPrice();
        uint redemptionRate = getLSTRedemptionRate();  // 1:1 long-term

        // Use better of AMM price vs redemption rate
        uint safePrice = max(price, redemptionRate * 95 / 100);

        uint collateralValue = userCollateral[user] * safePrice / 1e18;

        if (collateralValue * 100 / userDebt[user] < 110) {
            liquidationGracePeriod[user] = block.timestamp + 6 hours;
        }
    }

    function liquidate(address user) external {
        require(block.timestamp > liquidationGracePeriod[user]);
        // Allow time to add collateral or repay
    }
}

Lessons Learned

LST prices को redemption rate से compare करो

Grace periods — immediate liquidation मत करो

Circuit breakers — large depegs पर pause

Higher collateral ratios for volatile assets (150%+)

---

5. Cross-Chain Intent Frontrun — $116M Loss

Date: March 22, 2026

Protocol: Cross-Chain DEX Aggregator

Loss: $116M stolen via MEV

क्या हुआ?

Protocol ने cross-chain intents use किए — users sign order, solvers fill। Solvers ने intents frontrun किए।

// ❌ Vulnerable: No deadline, no slippage protection
struct Intent {
    address user;
    address tokenIn;
    address tokenOut;
    uint amountIn;
    uint minAmountOut;
    uint chainId;
    bytes signature;
}

function fillIntent(Intent memory intent) external {
    // Verify signature
    require(verifySignature(intent), "Invalid sig");

    // ⚠️ No deadline — intent valid forever
    // ⚠️ minAmountOut set when intent created, not when filled

    // Execute swap
    uint amountOut = swap(intent.tokenIn, intent.tokenOut, intent.amountIn);
    require(amountOut >= intent.minAmountOut, "Slippage");

    // Send to user on destination chain
    bridge.send(intent.chainId, intent.user, intent.tokenOut, amountOut);
}

Attack Flow

1. User signs intent: swap 100 ETH → 200K USDC (current market)
Attacker monitors mempool
Before solver fills, attacker frontrun-swaps:
   - Buys USDC → price spikes
Solver fills intent at worse price (100 ETH → 190K USDC)
Attacker backruns:
   - Sells USDC → profit 10K USDC
Repeated 1000+ times in 2 weeks

Root Cause

Intents में deadline नहीं था। Signature time और execution time के बीच market move हो सकता है।

// ✅ Fix: Deadline + oracle-based slippage
struct SecureIntent {
    address user;
    address tokenIn;
    address tokenOut;
    uint amountIn;
    uint minAmountOut;
    uint deadline;  // ✅ Add deadline
    bytes32 priceCommitment;  // ✅ Commit to oracle price
    bytes signature;
}

function fillIntent(SecureIntent memory intent) external {
    require(block.timestamp <= intent.deadline, "Expired");

    // Verify price hasn't moved >1% from oracle
    uint currentPrice = getOraclePrice(intent.tokenIn, intent.tokenOut);
    uint committedPrice = parseCommitment(intent.priceCommitment);
    require(abs(currentPrice - committedPrice) * 100 / committedPrice < 1);

    // Execute with fresh slippage check
    uint expectedOut = intent.amountIn * currentPrice / 1e18;
    uint amountOut = swap(intent.tokenIn, intent.tokenOut, intent.amountIn);
    require(amountOut >= expectedOut * 99 / 100, "Frontrun detected");
}

Lessons Learned

सभी user signatures में deadline add करो

Intent execution पर fresh price checks

Oracle-based slippage, not user-set

Private mempools for sensitive operations

---

Common Themes

सभी Q1 2026 hacks में recurring patterns:

1. Time Dependencies

• Bridge: Signature replay over time

• Oracle: Short TWAP window

• LST: Instant prices vs long-term peg

• Intents: No deadline

Fix: Deadlines, nonces, longer observation windows।

2. Price Manipulation

• Oracle manipulation via flash loans

• AMM price frontrunning

• LST depeg exploitation

Fix: Multiple oracles, TWAP, circuit breakers।

3. Incentive Misalignment

• Restaking operators no skin in game

• Solvers profit from user MEV

Fix: Bonds, slashing, reputation systems।

Protect Kaise Karen?

// Security checklist हर protocol के लिए

contract SecureProtocol {
    // ✅ 1. Reentrancy guards
    modifier nonReentrant() { /* ... */ }

    // ✅ 2. Deadlines on signatures
    mapping(bytes32 => uint) public deadlines;

    // ✅ 3. Multiple oracles
    function getPrice() public view returns (uint) {
        return median(chainlink, uniswap, pyth);
    }

    // ✅ 4. Circuit breakers
    function pause() external onlyGuardian {
        // Pause on anomalies
    }

    // ✅ 5. Slippage protection
    function swap(uint minOut) external {
        uint out = _swap();
        require(out >= minOut, "Slippage");
    }

    // ✅ 6. Rate limits
    function withdraw(uint amount) external {
        require(amount <= dailyLimit[msg.sender]);
    }
}

Conclusion

Q1 2026 costly था, लेकिन educational भी। Most hacks preventable थे — proper testing, audits, और best practices follow करके।

Key Takeaways:

• OpenZeppelin libraries use करो

• Multiple oracles + TWAP

• Deadlines on सभी signatures

• Circuit breakers + pause mechanisms

• Incentive alignment check करो

• Extensive testing + formal verification

DeFi evolve कर रहा है। Security practices भी evolve होने चाहिए। 🛡️