All field notes

Security · Retrospective

What a multisig protects, and what it does not

A white safe with three keyholes, two keys inserted and one keyhole empty.
Concept illustration · AI-generated

On 18 July, the Indian exchange WazirX said that one of its multisig wallets had been breached, with losses reported at about US$230 million. According to TechCrunch's report that day, the wallet had six signatories, and WazirX said the information displayed on its wallet provider's interface did not match what was actually signed. The provider said its preliminary investigation found that a wallet created outside its own system had been compromised. The early accounts disagreed, and I have nothing to add to them.

What I took from the reports was narrower. A multisig is often described as the safe choice, as if the word settled the question. In March, before taking PYM to Solana, we locked 100 million PYM in a Gnosis Safe contract on Polygon and published its address. July was a good month to be exact about what that lock promises.

What a Safe is

A Safe is a smart-contract account. It holds a list of owners and a threshold: the number of owner signatures a transaction needs before it can run. Each signature covers the exact transaction, including a nonce, so a signature collected for one transaction cannot be replayed for another.

That design protects against three real things:

  • One stolen key moves nothing on its own.
  • One person, inside or outside the team, cannot act alone.
  • If the threshold is lower than the number of owners, losing one key does not strand the funds.

A published address adds a fourth property, which is not about keys at all: anyone can watch it. If the tokens move, the movement is public on a block explorer as soon as the block is produced.

What "locked" means

Our March announcement used the word "locking", and it is worth being precise about it. Tokens locked this way are held by a contract that will move them whenever enough of its owners sign. There is no timer in it and no rule that refuses a valid set of signatures. The real promise is the word itself: a public statement that the tokens will stay where they are, and an address where anyone can see whether they do.

That is a useful promise. It rests on people rather than on code, though, and I would rather say so plainly than let "locked" suggest more than it does.

What a multisig does not protect

The WazirX account points at the main gap: signers approving what they cannot read. Every signer sees a transaction through software, whether a web interface, a wallet extension or a hardware device. If that software shows one thing and asks for a signature over another, three honest signers approve the wrong transaction as easily as one. A threshold multiplies keys. It does not multiply judgement when everyone is looking through the same window.

Several related gaps follow from the same idea:

  • Blind signing. A hardware wallet asked to sign a Safe transaction may show only a hash, and no person can check a hash against what they meant to do. A signer needs another way to decode the transaction: what it calls, with what data and what value.
  • The kind of call. A Safe transaction can be an ordinary call or a delegatecall. A delegatecall runs another contract's code inside the Safe's own storage, which can rewrite the owner list or the account's logic. WazirX said it suspected the payload had been replaced to transfer control of the wallet to an attacker. Any transaction that is not a plain transfer or contract call deserves a stop and a second reading.
  • Modules. A Safe can enable modules that execute transactions without collecting the owners' signatures. Enabling one needs the threshold, but once it is enabled it is another route to the funds. Knowing who can move assets means listing the modules as well as the owners.
  • Shared fate. Keys on the same laptop model, on the same network or in one person's drawer behave like one key. The threshold counts signatures, not independence.

The questions I keep

None of this changes my view that a multisig was the right home for a published lock. It changes the questions I ask of one:

  1. Who has to agree, and do they depend on the same device, interface or person?
  2. Can each signer read what they are signing without trusting the screen that proposed it?
  3. Is the operation a plain call, and if not, why not?
  4. Which modules are enabled?
  5. What has been published, so that people outside the team can check?

A multisig turns "who holds the key?" into "who has to agree, and what did each of them actually see?" The contract answers the first half of that question. The second half is the part no contract can answer on the signers' behalf.