cryptonist
A bank vault standing open, its door thickness and locking mechanism visible

Wallets

Multisig wallets: what m-of-n control protects against

A multisig wallet replaces a single key with a rule: of n keys, any m must sign before anything moves. The rule does one job well, which is surviving the loss or theft of a key. It does nothing about the other route by which funds leave, where every required signer approves the same harmful transaction because none of them could see what it did. Both routes have been taken at scale, and the gap between them is what this piece is about.

What the numbers buy

In an m-of-n arrangement there are n keys, and any m of them can authorise a spend. The two numbers pull against each other. A 2-of-3 survives one key being lost, because two remain, and one key being stolen, because a thief holding one key is still a signature short. A 2-of-2 survives the theft of either key and the loss of neither: lose one and the funds stay where they are, permanently. A 1-of-2 is two people who can each spend alone, which is convenient and no protection against theft at all.

Raising m makes theft harder and loss more dangerous. Adding keys at the same m tolerates more losses and gives a thief more keys to aim at. Every version assumes the keys fail independently. Three keys kept in one drawer, or generated on one compromised laptop, behave like one key, and the arithmetic stops meaning anything.

The routes by which single-key wallets lose funds are set out in how crypto wallets actually fail. Multisig closes some of them and leaves the rest exactly where they were.

Multisig in Bitcoin’s script

Bitcoin enforces multisig in its own transaction rules. BIP-11, assigned in October 2011, made m-of-n outputs a standard transaction type, with a script of the form m {pubkey}...{pubkey} n OP_CHECKMULTISIG, for n of three or fewer. It also records a quirk every such spend still carries: the opcode “pops one too many items off the execution stack”, so a dummy OP_0 has to sit in front of the signatures.

That bare form put every public key into the output, which the sender had to build. BIP-16, pay-to-script-hash, moved the burden to whoever spends. The output holds only a 20-byte hash of the script, short enough to fit an ordinary address (BIP-13 defines the format), and the spender supplies the full script, the redeemScript, with the signatures. Validation hashes the script, “fails immediately if it does not match the hash in the outpoint”, and then runs it.

Segregated witness kept the idea and changed the container. Under BIP-141, a pay-to-witness-script-hash (P2WSH) output commits to the 32-byte SHA256 of the script, there called the witnessScript, and the script and signatures travel in the witness. Taproot’s script rules, BIP-342, disable OP_CHECKMULTISIG and add OP_CHECKSIGADD, which expresses the same thresholds in a form that can be verified in batches.

The consequence that catches people out sits in BIP-16’s rule. To spend, you present the whole script, and the script contains all n public keys. Two seed phrases from a 2-of-3 are not enough by themselves: without the third public key the script cannot be rebuilt, its hash will not match the output, and two valid signatures move nothing. Order matters as well. BIP-383, which defines the output descriptors wallets use to record a multisig, separates multi(), which keeps the keys in the order given, from sortedmulti(), which sorts them, and the same keys in a different order make a different script. A multisig backup is therefore the seeds plus that descriptor, and a restore on separate software is the only test that the set is complete. Everything in where to store a seed phrase applies to each seed, with the descriptor added to the list.

Multisig as a contract

An ordinary Ethereum account has one key and no script, so multisig on Ethereum and chains built like it is a smart contract that holds the funds and checks signatures itself. Safe’s documentation describes accounts operated by several owners, in which “a threshold number of owners required to confirm a transaction for it to be executed can be specified and modified”. Owners sign first, and the signatures are “combined into a single bytes and transmitted to the contract when a transaction should be executed” (Safe, signatures).

The policy is code, and two things follow. The first is that the people it governs can change it. Safe’s owner management contract exposes addOwnerWithThreshold, removeOwner, swapOwner and changeThreshold, each marked authorized, a modifier that lets only the Safe call them on itself (SelfAuthorized.sol). In practice that means a transaction which has already met the current threshold. A 3-of-5 can approve its way down to a 1-of-5, and the Pepe coin piece covers a treasury whose threshold had been cut from five of eight to two of eight. The note on shared wallets at the end of what a wallet connection approves makes the same point: a multisig is a rule about who must agree. Safe can also be extended with modules, and its own modules page warns that “a malicious module can take over a Safe”.

The second is that the code can fail on its own, with every key intact. Bitcoin’s multisig rules are part of consensus. A contract wallet’s rules are whatever its code says, mistakes included, and 2017 showed what that means in practice.

Multi-party computation: one key in pieces

Multi-party computation, usually shortened to MPC, spreads control by a different route. NIST’s call for multi-party threshold schemes, published in January 2026, describes the idea: a signing operation is “computed in a distributed manner, while its private/secret key is or becomes secret-shared across various parties”, and the output is interchangeable with an ordinary signature. RFC 9591, which specifies the FROST threshold signing protocol, states the assumption underneath: the security of such schemes “assumes that an adversary can corrupt strictly fewer than a threshold number of signer participants”.

Because the output is one ordinary signature from one public key, the chain cannot tell an MPC wallet from a single-key wallet. That is the attraction. It works on chains with no native multisig, a transaction costs what a single-signer one costs, and nothing about the arrangement is visible on-chain.

It is also the limitation. The threshold lives off-chain, so nobody can check it from the chain, including the people relying on it; it is enforced by whatever software runs the protocol, and by whoever operates that software. NIST’s “is or becomes secret-shared” covers two very different cases: a key generated jointly, so that it never existed in one place, and a key generated whole and then split, which RFC 9591 includes as a “trusted dealer” option. Nor is there yet a finished standard to hold a provider to. The RFC says of itself that “it is not an IETF product and is not a standard”, and NIST’s process was at the call-for-submissions stage in 2026, so whether your shares work anywhere else is a question to put to the provider, in writing, before relying on the answer.

What MPC shares with script and contract multisig is the point this piece turns on. Each party signs whatever it is given.

How multisig has failed

Parity’s multi-sig wallet failed twice in 2017. It split its logic into a small stub deployed for each wallet and a shared library holding most of the code. On 19 July 2017, Parity’s post-mortem records, a bug in that code was exploited: two functions meant to run only once, when a wallet was created, “were entirely unguarded, which allowed the attacker to reset the ownership and usage parameters of existing wallets”. Three wallets were drained. A self-described White Hat Group used the same flaw to take control of the rest of the 596 vulnerable wallets, with the stated aim of returning them.

Parity redeployed the library on 20 July, and the replacement had a flaw of its own, which surfaced in November. The second post-mortem explains that the library “had the same functionality as a regular wallet and required initialization”, that it had not been initialised, and that it still contained the self-destruct function of the original wallet code. On 6 November 2017 a user initialised it, became its owner and destroyed it. Every Parity multi-sig wallet deployed after 20 July depended on that library, and Parity wrote that the destruction “blocked funds in 587 wallets holding a total amount of 513,774.16 Ether as well as additional tokens”. DefiLlama’s hacks record files both Parity incidents under Access Control.

In neither case was a key stolen or a signer fooled. The keys were sound; the code that interpreted them was not.

The theft from Bybit in February 2025 ran the other way: the contract did what it was told, and the signers were deceived. The FBI’s public service announcement I-022625-PSA, of 26 February 2025, states that North Korea “was responsible for the theft of approximately $1.5 billion USD in virtual assets” from the exchange on or about 21 February 2025, and names this North Korean activity TraderTraitor. A statement from the Safe{Wallet} team, published by the Safe Ecosystem Foundation on 28 February, said the forensic review concluded that the attack on the Bybit Safe “was achieved through a compromised Safe{Wallet} developer machine resulting in the proposal of a disguised malicious transaction”, and that the review by external researchers did not indicate any vulnerabilities in the Safe smart contracts or in the source code of the frontend and services. Bybit’s update of 26 February said the credentials of a Safe developer had been compromised, which let the attacker into the Safe{Wallet} infrastructure to “totally deceive signers into approving a malicious transaction”.

What the transaction did is set out in NCC Group’s technical analysis. Its operation type was set to delegatecall, the contract it called was dressed as an ERC-20 transfer, and running it rewrote the storage slot holding the address of the wallet’s implementation, after which “the proxy implementation pointed to a completely different code controlled by the attackers”. NCC’s conclusion is that the signers “blind-signed the messages without carefully checking their contents, trusting what the Safe Web3 Application displayed”. That is NCC’s reading; the statements from Safe and Bybit quoted here do not describe what each signer’s device showed. DefiLlama files the incident under Social Engineering, with the technique Signer Phishing.

What more keys do and do not buy

Set the two kinds of failure side by side and the property is clear. More keys raise the number of things an attacker has to steal. They do not raise the number of things an attacker has to fool when every signer reads the transaction through the same window. At Bybit the threshold was met and each signature was valid. The required number of people approved the same thing because one compromised interface showed all of them the same thing.

So the independence that matters extends to verification. Three questions test it:

  1. Does each signer see the transaction somewhere the proposer cannot draw? A hardware device that decodes the call is such a place; one that shows only a hash is not, and NCC adds that EIP-712 display “is insufficient for nested operations” of the kind used at Bybit. How hardware wallets work covers what a device screen can and cannot show.
  2. Can the transaction be checked with a second, separately built tool before anyone signs? If one application proposes and every signer reviews in that same application, a single compromise speaks for all of them.
  3. Are changes to the wallet itself treated as the most dangerous transactions it can sign? Owners, threshold, modules and the implementation address define what the wallet is. A transaction that touches them deserves more scrutiny than any transfer, and a delegatecall to an unfamiliar contract is such a transaction.

The Safe{Wallet} team’s statement committed Safe to lead an industry-wide initiative to “increase verifiability of transactions, which is an ecosystem-wide challenge”.

The same logic applies to one person holding all three keys of a 2-of-3. If one laptop proposes every transaction and the same habits approve it, the single point of failure has moved out of storage and into signing, which is where wallet drainers work.

Before relying on one

  • The backup is keys plus policy. For Bitcoin, the descriptor with every public key; for a contract wallet, its address and chain as well as the owner keys; for MPC, whatever the provider says recovery requires. Test a restore before funding.
  • Know who can change the rule. In a contract wallet the threshold can be changed by the threshold. In MPC the rule lives with the software that enforces it.
  • Keep the keys apart. Separate places, and devices that do not share one point of compromise.
  • Plan for the other keyholders. Multisig is often proposed for inheritance, where the people holding the second and third keys need instructions as much as keys; crypto inheritance covers that case.