Share on XShare on LinkedInShare on Telegram
Security Decisions/ Before launchWeb3 Security

Aave V3 FlashLoopAdapter $300K Safe Exploit (Explained)

Discover how the FlashLoopAdapter exploit drained approximately $310,000 from two Safe wallets using leveraged Aave v3 positions. This breakdown explains how a forged isModuleEnabled() check bypassed module authentication, enabled unauthorized collateral withdrawals, and exposed critical access control weaknesses in a third-party adapter. Learn key lessons for Safe multisig security, module reviews, smart contract audits, and protecting DeFi treasuries from similar attacks.

Author
QuillAudits Team
•October 30, 2026
Aave V3 FlashLoopAdapter $300K Safe Exploit (Explained)
Share on XShare on LinkedInShare on Telegram

The decision · answer in brief

Discover how the FlashLoopAdapter exploit drained approximately $310,000 from two Safe wallets using leveraged Aave v3 positions. This breakdown explains how a forged isModuleEnabled() check bypassed module authentication, enabled unauthorized collateral withdrawals, and exposed critical access control weaknesses in a third-party adapter. Learn key lessons for Safe multisig security, module reviews, smart contract audits, and protecting DeFi treasuries from similar attacks.

FlashLoopAdapter Exploit Explained: $300K Aave Safe Hack

On October 1, 2026, an attacker drained roughly $310,000 from two Safe wallets running leveraged Aave v3 positions on Ethereum mainnet by spoofing a single access control check inside a third-party module called FlashLoopAdapter. This FlashLoopAdapter exploit explained walkthrough breaks down how a forged isModuleEnabled() call let the attacker impersonate a trusted module and pull collateral straight out of two Safes in one transaction, and what treasury signers should check before they ever click "enable module" again.

FlashLoopAdapter Exploit Explained

FlashLoopAdapter is a third-party Safe module built to open and close leveraged Aave v3 positions on behalf of a Safe, not a contract maintained by Aave or Safe itself. One Safe lost 1,306.48 weETH and the second lost 6.43 weETH; Cryptobriefing reported the combined loss at up to $310,000.

The attacker pulled this off with a flash loan.

Safe Multisig Module Exploit in 2026: Where This Fits

FlashLoopAdapter is the latest entry in a pattern that has been building all year: a Safe multisig module exploit in 2026 rarely targets Safe's core contracts or an audited protocol like Aave v3. It targets the module a treasury enabled to add convenience, because that module inherits the Safe's full execution rights the moment it is turned on.

Safe's module system is intentionally permissive by design. Any address added as a module can call execTransactionFromModule() and move funds or change state without collecting owner signatures, which is exactly why modules exist, to automate recurring actions like leverage management without a manual signing ceremony every time. That convenience is also the attack surface. A module does not need a bug in Safe's code to cause a loss; it only needs a bug in its own code, because the Safe already trusts it completely.

The same structural lesson shows up outside the module context too. QuillAudits' coverage of the Drift Protocol multisig exploit describes a $285 million loss where attackers social-engineered signers into pre-signing malicious transactions, bypassing Drift's audited smart contracts entirely through an operational security gap. Different mechanism, same root lesson: the point of failure sits wherever trust is granted outside the core protocol's own audited logic, whether that trust goes to a module, a signer, or a pre-signed nonce.

Exploit Details: The Forged Safe

FlashLoopAdapter's open() and close() functions decided whether to act on a Safe's behalf by calling isModuleEnabled(msg.sender) back on the caller and trusting whatever answer came back; because any contract can implement that function to return true unconditionally, an attacker could deploy a fake Safe that always confirmed FlashLoopAdapter as "enabled," letting the real module execute privileged withdrawal logic against a victim Safe it had never actually been authorized on.

The function was meant to confirm the reverse relationship, that the Safe had enabled FlashLoopAdapter as a module, before letting it move funds. Instead it asked the caller to vouch for itself. As Verichains put it: "The adapter made that call, so the Safe saw FlashLoopAdapter - its enabled module - as msg.sender and executed the attacker's instructions." Once the attacker's contract satisfied that single check, the module treated every subsequent instruction, including collateral withdrawal from a real, unrelated Safe, as legitimate.

Attack Process

Verichains' analysis traces the exploit through a single atomic transaction:

  1. The attacker deployed a malicious contract whose isModuleEnabled() function always returned true, regardless of which address was actually being checked.
  2. The attacker took a flash loan of roughly 11,537 WETH from Morpho Blue to fund the attack.
  3. Using the spoofed module path, the attacker triggered FlashLoopAdapter to repay a victim Safe's outstanding Aave v3 debt with the borrowed WETH.
  4. With the debt cleared, the attacker called FlashLoopAdapter again to withdraw the now-unencumbered collateral, 1,306.48 weETH from one Safe and 6.43 weETH from a second Safe, through the same forged authentication path.
  5. The freed weETH was routed through Curve, Fluid, and Uniswap via an aggregator to convert it toward WETH.
  6. The attacker repaid the Morpho Blue flash loan and kept the remaining funds, all inside the same transaction.

No signature from either victim Safe's actual owners was ever requested or needed. The entire sequence ran on FlashLoopAdapter's authority as an enabled module.

Root Cause: Unvalidated Module Trust

The root cause was not a reentrancy bug, an oracle manipulation, or a rounding error, the usual suspects in DeFi hack writeups. It was a single authentication check that trusted the wrong party. FlashLoopAdapter needed to know "has this Safe enabled me as a module," and it asked the caller to answer that question about itself instead of checking the Safe's own module registry directly.

This is a narrower failure than it sounds, but it is also a common one in adapter contracts that sit between a wallet standard and a lending protocol: the integration glue is often written and reviewed with less scrutiny than the core contracts it connects. Aave v3's lending logic was never touched. Safe's module framework worked exactly as designed, it granted execution rights to whatever address the Safe owner enabled, and FlashLoopAdapter was that address. The victims' real mistake, if there was one, was trusting a third-party adapter's internal logic as much as they trusted Safe's own audited core.

Prevention Measures Before Enabling a Safe Module

Enabling a module is not a convenience setting, it is an unconditional grant of your Safe's execution rights to that contract's code, forever, until someone removes it. Before a treasury signer enables any third-party module, including a leverage adapter like FlashLoopAdapter, the checklist should include:

  • Read the module's authentication logic line by line. Confirm it checks the Safe's own module registry (via the Safe contract itself) rather than trusting a value the caller supplies about itself.
  • Confirm the module has had an independent smart contract audit covering its access control paths specifically, not just its intended business logic.
  • List every module already enabled on a Safe before adding a new one. Treasuries accumulate modules from past integrations that nobody is actively monitoring, and each one is a live attack surface.
  • Treat module removal as routine maintenance, not an emergency-only action. A module that is no longer actively used should be disabled.
  • Review pending transactions in plain language before signing, since a transaction that looks routine can route through a module path no one intended to use.

QuillAudits' Safe Inspector guide walks through pulling a Safe's owners, threshold, modules, and guards directly from chain in under a minute, the exact check that would have surfaced FlashLoopAdapter sitting on a Safe's module list before the exploit. The underlying tool, Multisig Inspector, reads a Safe's current module list, owners, and signature threshold straight from the blockchain and runs read-only with no wallet connection or signature required, so a treasury can check its own configuration without exposing a key. Its companion Transaction Inspector decodes a pending transaction's target, call type, and value before anyone signs, instead of leaving a signer to approve raw calldata blind.

Neither tool would have caught a bug buried inside FlashLoopAdapter's own open() function, that is what a full smart contract audit of the adapter itself is for. And a configuration check only works if someone actually runs it before a module is enabled or a transaction is signed; it cannot undo a withdrawal that already cleared. What it does reliably catch is the setup step that made this exploit possible in the first place: a module sitting enabled on a Safe that nobody had re-examined since the day it was added.

Conclusion

Aave v3's lending markets and Safe's core multisig contracts both came through the FlashLoopAdapter incident unaffected; the $300,000-plus loss sat entirely inside a third-party adapter's authentication logic. For treasury operators, the lesson generalizes past this one module: every address with module rights on a Safe deserves the same scrutiny as the protocols it touches, because the Safe will execute its instructions without asking twice. A comprehensive Blockchain Audit can help identify weaknesses in third-party adapters and modules before they reach a production treasury Safe. For more insights on securing Web3 projects, visit QuillAudits' research hub.

Explore more Security Decisions

Contents

Tell Us About Your Project
Subscribe to Newsletter
hashing bits image
Loading...

WE SECURE EVERYTHING YOU BUILD.

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.

QuillAudits Logo


ISO 27001Circle Alliance Program
Uniswap FoundationAethiropt-collectivePolygon SPNBNB Chain Kickstart

All Rights Reserved. © 2026. QuillAudits - LLC