Two Safe multisignature wallets lost their collateral in a single Ethereum transaction. In block 26,098,264, at 15:08 UTC on October 1, 2026, an attacker took 114.09 ETH from both of them, about $305,000 according to the analysis by Verichains , which reconstructed the case step by step.
The hole was in FlashLoopAdapter, a third-party module that opened and closed leveraged positions on Aave v3. It is worth understanding what a module is before going further, because that is the whole issue. A Safe module is a contract that the owners authorize to move funds and execute transactions on behalf of the wallet, without requiring signatures for each operation. That permission carries the same weight as that of a signer, and Safe's own documentation has warned for years that only audited modules should be enabled.
FlashLoopAdapter had no published audit or known external review. Its only access control consisted of asking the caller itself whether it was authorized, a method anyone can fake by answering yes. The module took a fake contract at its word, let it choose the destination and the call data, and ended up executing orders against the two wallets that did trust it. Neither Aave nor Safe's core contracts failed, and that detail is uncomfortable for anyone automating a multisignature with third-party code.
What happened within a single block
The entire attack fits into transaction 0x75328f91, included in block 26,098,264 at 15:08:47 UTC on October 1, 2026. The attacker borrowed 11,537.24 WETH from Morpho Blue in a flash loan, money that is received and repaid within the same operation. It asked for nine times more than it needed and returned the surplus.
With that money it paid off the large wallet's debt on Aave. The pool's Repay event records 1,335.255803 WETH, identifies the Safe as the borrower and the attacker's contract as the payer. Settling the debt was mandatory, because Aave does not release collateral backing a live loan, and that wallet had 1,306.48 weETH locked by a variable debt of 1,335.26 WETH.
With the debt at zero, the attacker used the module to make the large wallet hand over its 1,306.48 weETH. It repeated the move with a second wallet belonging to the same owner, which transferred 6.43 weETH. It then swapped the resulting 1,312.90 weETH for 1,449.3520 WETH through Curve, Fluid and Uniswap, using Velora's AugustusV6 aggregator.
The Morpho loan was repaid in full and the surplus ended up converted into ETH. The balance that reached the attacker's address was 114.096151 ETH, the figure on which the entire net loss calculation rests.
Why did the module trust whoever called it?
The flaw had two halves that fit together afterwards like a single looting tool. The first was in the access control of the open() and close()functions, which checked whether the caller was a Safe with the module enabled. To find out, the module ran isModuleEnabled on the caller itself, that is, it asked the suspect whether it was authorized.
A real Safe answers that query honestly, but any contract can write the same function and always return true. The module checked nothing on its own, accepted the caller's answer and moved on. It is the oldest authorization error in the book, and here it cost real collateral.
The second half was in the swap section. All parameters were supplied by the caller: the flash loan provider, the swap router and the data to be sent to that router. The module approved the router to spend the input token and then forwarded the call with the destination and content it received.
A guard that did not work
The callback guard only verified that the response came from the declared provider and that the parameters matched the hash committed at the start. The attacker made itself the provider and met both conditions without breaking a sweat.
With those two pieces, the rest was mechanical. The attacker set one of the victim wallets as the router and an execTransactionFromModuleorder as the call data, the function a module uses to ask the Safe to execute something. The wallet saw that its own enabled module was speaking to it.
That is the key to the case. On the module path, the Safe does not verify owners' signatures; it executes what the contract it itself authorized asks of it, without asking who is behind that request. With two weETH withdrawals, the collateral left both wallets.
The contextual details complete the diagnosis. The contract was deployed on July 16, 2026, and both wallets activated it the following day, according to Verichains. No other Safe appears in its transaction history, which points to a private tool rather than a public product with many users.
The incident figures
The incident figures are clear and transparent thanks to blockchain:
| Data point |
Value |
| Date and time |
October 1, 2026, 15:08:47 UTC |
| Network |
Ethereum mainnet |
| Net loss |
114.0962 ETH, about $305,000 |
| Vulnerable contract |
FlashLoopAdapter, 0x16bb8B912da187870C23eC6756bB3FAd061283d8 |
| Module deployment |
July 16, 2026 |
| Transaction |
0x75328f91...c616fc4, block 26,098,264 |
| Attacker |
EOA 0x42c26334...5F9353 and auxiliary contract 0xF0916896...4B67ff |
| Victim wallets |
0xCFeDF95a...0D169f and 0xE3b23E47...b28520 |
| Debt settled on Aave |
1,335.255803 WETH |
| Collateral moved |
1,306.48 weETH and 6.43 weETH, not additive to the loss |
| Bounty offer |
10%, sent on October 1 at 21:03 UTC |
The last row deserves a reading warning. The 114.09 ETH is the net profit after repaying the flash loan and covering the Aave debt, not the value of the collateral that was moved. Anyone who adds the 1,306 weETH to the loss will count the same money twice, because that amount left the pool to repay the temporary loan.
Neither Aave nor Safe has a flaw to fix
Stani Kulechov, founder of Aave, came out to limit the scope of the incident: the exploited contract was an external adapter built on top of Aave and did not affect Aave v3. The version matches the on-chain evidence, because the pool lent, collected and released collateral according to its rules with no irregularity in its logic.
On the Safe side the same is true, with a nuance worth underlining. The project's documentation classifies modules as a critical risk element and recommends adding only audited code, because a malicious module can take control of the wallet. The help center is even more explicit about its catalog, since outside of spending limits it maintains no official modules.
Safe has not published a specific statement on FlashLoopAdapter. What it has moved in the same period are two pieces that point to the underlying problem. On September 22, 2026, nine days before the incident, Safe{Wallet} released version 1.5.0 of its contracts with the Module Guard, a mechanism that reviews every module transaction with the same rules as the others. And on October 15, the Safe Foundation launched Safenet Aegis, a transaction verification network whose rulebook includes among the cases it must flag unauthorized changes to a Safe's owners and modules.
A pattern that had already cost millions
Another Safe lost 2,900 rsETH, about $7.8 million, on September 15, 2026, sixteen days before this exploit. The attacker took advantage of a poorly written check in the router hidden behind an enabled module. That check returned true whenever the call destination was the router itself, which was enough to slip in a nested order and execute code in the wallet's context. The operation ended up in the hands of a MEV bot called Yoink, which front-ran the attacker in the same block.
Four months earlier, the SquidRouterModule module drained some 86 Safe wallets on Ethereum and Base and took around $3.2 million in two hours. The most striking detail is that the authorization consisted of a constant, public string written in the verified contract itself, so anyone could copy it, present it and execute whatever they wanted. Squid had to clarify that it had not built or deployed that contract, and the CEO of Safe Labs noted at the time that the affected wallets did not appear to be operated from the official Safe product.
All three cases share the same structure. The multisignature works, the core contracts work, and the money leaves through an extension the owners installed to save themselves manual work. The difference between a module and a signer is that the signer has to approve each operation, while the module receives a permanent permission and exercises it whenever it wants.
The 10% that no one collected
The owner of the two wallets tried to negotiate. On October 1 at 21:03 UTC, the address with the ENS name aavechan.eth sent an on-chain message to the attacker with an offer common in these cases: keep 11.41 ETH as a bounty, 10% of the loot, and return 102.69 ETH before October 3 at 18:00 UTC. If the money came back, the matter would be closed as a white-hat rescue.
The offer received no known response, and as of October 16 no source records a return. The money left the attacker's address in the hours following the hit. The case remains open in DeFiLlama 's accounting with the improper access control label and an estimate of $305,000, the same figure used by Verichains and SlowMist.
Check whether your Safe has modules enabled
The damage can be audited before it happens, and the checks do not require knowledge of Solidity. These are the ones that Safe's documentation and subsequent analyses flag as priorities.
- List the enabled modules with
getModulesPaginated and confirm that you recognize the author of each one. getModulesis not enough, as it returns at most ten entries.
- Disable any module whose author and reviewer you cannot identify. A module you no longer use retains execution permission until you remove it.
- Treat every module as if it were one more signer. If you would not let a person move the treasury without reviewing it, do not let a contract do so without reading it first.
- Distrust modules that accept the swap router and the call data from outside. They should carry an allowlist of routers that excludes the Safe wallets themselves.
- Check where the authorization comes from. If the answer about whether the caller is authorized comes from the caller, there is no real authorization, only a forgeable courtesy.
- Update to version 1.5.0 or higher if you are still on 1.3.0 or 1.4.1. The Module Guard adds a review of every module transaction that did not exist before.
A multisignature is worth as much as the permission you delegate
Safe is right in its defense, because its core contract did not fail and the module architecture is a deliberate design decision, intended for teams and protocols to automate operations without giving up the multisignature. The problem is that this flexibility shifts the risk to a point almost no one reviews, since installing a module looks more like ticking a box in an interface than granting a permanent power over the assets.
The 2026 pattern makes it clear. On one side is the multisignature and on the other all the extensions that act in its name, and the attacker always chooses the weakest. The industry has learned to harden core protocols and monitor signatures, but FlashLoopAdapter shows that the gap has moved to permissions granted once and forgotten forever. A Safe wallet with an unaudited module is not a multisignature with a useful extra, but a multisignature with an anonymous signer.