The $1.5 billion Bybit hack in February 2025 wasn't caused by a flaw in Safe's smart contract code, but rather by a compromised frontend that deceived signers into approving a malicious contract upgrade they couldn't see. This incident, along with subsequent losses at Drift Protocol and Humanity Protocol totaling roughly $1.8 billion combined, has reframed what "secure multisig" actually means for Ethereum-based treasury management.

What Actually Happened to Bybit's Safe Multisig Wallet?

On February 21, 2025, attackers attributed to North Korea's Lazarus Group compromised a developer machine inside the Safe{Wallet} organization. From there, they hijacked Amazon Web Services (AWS) session tokens and swapped a JavaScript bundle served from Safe's own frontend at app.safe.global, which was hosted on AWS S3 and CloudFront. The attack was surgical: it didn't touch the Safe smart contract at all.

When Bybit's signers attempted to move roughly 401,000 ETH (Ethereum's native token) from cold storage to a warm wallet, a routine operation they had performed many times before, the malicious script detected the transaction was tied to Bybit's cold wallet address. It then silently rewrote what the signers saw on their screens. What appeared to be a simple ETH transfer was actually a delegatecall instruction that upgraded the Safe's implementation contract to one containing backdoor functions called sweepETH and sweepERC20.

The signers used Ledger hardware wallets, which are considered the gold standard for security. It made no difference. A hardware wallet can only display what the software feeding it chooses to show, a problem Ledger's own postmortem called "blind signing." The interface, not the cryptography, became the attack surface. Once the malicious upgrade was approved, attackers drained close to 401,000 ETH equivalent to 51 separate addresses in minutes.

How Common Are Multisig Operational Security Failures?

Bybit was not an isolated case. Between February 2025 and June 2026, roughly $1.8 billion in combined losses occurred across three major multisig incidents, none of them caused by smart-contract bugs. In April 2026, Drift Protocol lost an estimated $285 million after attackers abused pre-signed durable-nonce transactions with no expiration policy, effectively replaying stale signed approvals. In June 2026, Humanity Protocol lost $36.4 million when the keys controlling its multisig were concentrated on a single compromised laptop.

Broader security data underscores the scale of the problem. CertiK's Hack3D report tallied $1.315 billion stolen across 344 on-chain incidents in the first half of 2026 alone, with wallet compromise as the single costliest category at over $444 million, averaging more than $13 million per incident. That represents the highest average loss of any attack category CertiK tracks.

Safe's own statement was direct about where responsibility lay: "the incident stemmed from a compromised developer machine and a disguised transaction, not a flaw in the Safe multisig contract logic itself". The pattern across all major incidents reveals a consistent truth: the multisig math was sound, but the human and interface layer around it was not.

Why Multisig Security Depends on More Than Just Cryptography

The core pitch of a multisig wallet is that no single point of failure can drain the treasury. That promise holds true at the smart-contract layer. It stops being true the moment every signer is looking at the same compromised rendering of a transaction, or the moment those signers' keys all trace back to one physical laptop.

A multisig is only as distributed as its weakest shared dependency, and for most teams that weak dependency turns out to be the software stack everyone uses to interact with the contract, not the contract itself. Safe now secures more assets than any other non-liquidity protocol in decentralized finance (DeFi). Safe Foundation's Q1 2026 report put total assets secured at roughly $35.25 billion, spread across more than 61 million deployed accounts, with a broader lifetime figure north of $60 billion moving through the ecosystem. Major protocols including Uniswap, Ethereum Name Service (ENS), Optimism, and Lido all park treasury funds in Safe accounts.

Steps to Secure a Multisig Wallet Against Operational Failures

• Use Hardware Wallets From Multiple Vendors: Deploy 2 to 3 hardware wallets from at least two different vendors. Mixing brands means a single vendor-side firmware bug doesn't take down every signer at once. Ledger Nano X/S Plus or Trezor Safe 5/7 are both viable options.
• Verify Transactions Independently of the Web App: Do not rely solely on the Safe web interface to display transaction details. Use transaction simulation tools and independent verification methods to confirm what you are actually approving before signing.
• Implement a Timelock Guard for Large Transfers: Add a timelock guard contract that delays execution of large transfers, giving signers time to detect and cancel malicious transactions before they drain the wallet.
• Monitor Pending Transactions From the Command Line: Build or deploy a Python-based monitor that watches your Safe's pending transactions independently of the web interface, reducing reliance on a single point of failure.
• Keep Signer Keys Distributed Across Physical Locations: Never concentrate multisig keys on a single laptop or device. Ensure each signer controls their key material from a separate, air-gapped machine.
• Test on Testnet Before Mainnet Deployment: Deploy a real Safe on a public testnet such as Sepolia, verify it independently of the web app, and wire up all guardrails before moving to mainnet. Budget 90 to 120 minutes for the full walkthrough if doing it for the first time.

The technical stack for a secure setup includes Node.js v20 LTS or newer, the Safe Protocol Kit SDK (version 4.x as of 2026), the ethers library v6.x, Python 3.11 or newer with the requests library, and Safe's core smart contracts currently tagged v1.5.0 in the safe-global/safe-smart-account GitHub repository. A modern browser with no unnecessary extensions is essential, since extension-based wallet phishing remains a real vector for treasury compromise.

What Does This Mean for Ethereum's Institutional Adoption?

Safe's dominance in treasury management across Ethereum and other EVM-compatible blockchains (Ethereum Virtual Machine networks that can run Ethereum-compatible code) reflects institutional confidence in the underlying smart-contract design. However, the Bybit incident and its follow-on failures expose a gap between the security guarantees of the protocol layer and the operational reality of managing large treasuries. For any organization running a decentralized autonomous organization (DAO), a protocol treasury, a company crypto account, or even a family fund large enough to worry about, the lesson is clear: you will likely end up on Safe or something like it, but the setup matters far more than the brand.

The incidents of 2025 and 2026 have forced a reckoning with what "secure multisig" actually means. It is no longer sufficient to deploy a mathematically sound contract and assume the rest will follow. Operational security, frontend integrity, key distribution, and independent transaction verification have become as critical as the cryptography itself. For Ethereum's institutional ecosystem, that shift represents both a challenge and an opportunity to mature the infrastructure that underpins billions of dollars in on-chain assets.