← All posts

The key was never the weak point

Crypto hacks target access, not keys. Here’s how Salt’s signing flow keeps them apart.

The biggest crypto hacks don’t break the cryptography. They exploit a quieter design flaw: access to systems that doubles as authority over money.

On 29 October, roughly $6.3 billion left Binance wallets in about 20 minutes. Binance says no private key leaked and has pointed to a compromised laptop as the way in. Bybit’s $1.5 billion loss in 2025 also came from outside the cryptography: a tampered signing interface.

Incidents like these are usually treated as social engineering problems, and better training, sharper phishing awareness and hardened devices all help. But those responses treat the person as the weak point. Yet when one engineer’s laptop can lead to the theft of billions, the weakness is clearly structural.

In a traditional company, spending is delegated deliberately: who can approve what, up to which amount, with whose sign-off. Engineers are not typically included in these delegations.

In crypto, that separation is harder to sustain. Digital assets are bearer assets: whoever can produce a valid signature controls them, and the infrastructure that produces signatures is challenging to run. Authority leaks to whoever can operate it, usually engineers and IT, and each of them becomes a way into its funds.

The fix is to design signing flows so that access to the infrastructure can never be turned into a signature.

Before the signature

The maths behind digital signatures has not been broken in a hack. Where cryptography has failed, the cause was a flawed implementation, such as weak randomness (Coldcard, 2026) or a reused nonce (Anyswap, 2021). Most attacks skip attacking the cryptography directly and go after the process around signing.

A blockchain transaction is final in seconds, so the protection has to sit before the signature. Otherwise, getting funds back depends on someone else being able to freeze them. Binance had that option: it and its partners froze around $3 billion, according to the Associated Press. Most victims don’t. Only a small fraction of Bybit’s $1.5 billion was ever frozen.

Protection before signing is the job of whoever is responsible for an organisation’s assets. Three questions underpin good signing flow design:

  • Who can propose a transaction, and what would an attacker need to impersonate them?
  • What is checked before a transaction is signed, and who or what does the checking?
  • Who can change those checks, and how hard is it to do so without anyone noticing?

A finance team would expect clear answers to all three for a bank account, and a crypto treasury deserves the same. If answering them means asking your engineers, the answer is probably already a problem.

How Salt splits trust across every transaction

Getting this right is hard. Distributed signing, policy enforcement and key recovery are each serious engineering problems, which is why so many teams end up leaking authority to those running the infrastructure. Salt was built so that signing authority can be distributed across an organisation without anyone who runs the infrastructure gaining authority over the money. That includes Salt, which holds no key material.

To achieve this, Salt rearchitected institutional MPC wallets so that the organisation runs all the signing nodes itself, and treasury teams sign through a simple, clean interface, without engineers in the flow. Salt’s role is to coordinate cosigning. Each signer’s shard is encrypted to their wallet and held by a smart contract on Arbitrum, so signers can move to new hardware, or recover the account without Salt, at any time. Organisation owners set the rules, every transaction is checked against them before it is signed, and nobody can move funds beyond what they were delegated.

Here is what a signing flow looks like end to end.

  1. Propose. A proposer submits a transaction. Proposers can be people or bots, and each authenticates with their own wallet and holds their own key shard.
  2. Check. Salt checks the proposal against the account’s policies. If it breaches any of them, the transaction stops and the attempt is recorded.
  3. Cosign. If the proposal passes, the organisation’s automated cosigners, which we call Robo Guardians, add their signatures until the signing threshold is met.
  4. Broadcast. The signed transaction is sent to the chain.
Salt signing flow A proposer submits a transaction. Salt checks it against the account’s policies. If it passes, the Robo Guardians cosign and the transaction is broadcast; if it fails, it is blocked and the attempt is recorded. 1Proposeperson or bot2Checkagainst policyPasses?3CosignRobo Guardians4Broadcastto the chainyesnoBlockedattempt recorded Salt signing flow A proposer submits a transaction. Salt checks it against the account’s policies. If it passes, the Robo Guardians cosign and the transaction is broadcast; if it fails, it is blocked and the attempt is recorded. 1Proposeperson or bot2Checkagainst policyPasses?3CosignRobo Guardians4Broadcastto the chainyesnoBlockedrecorded

Owners set the policies. A proposal that fails them is blocked and recorded; only one that passes reaches the Robo Guardians.

The full private key does not exist at any point in this process. Each signer generates its shard on its own hardware, never Salt’s, and signs with that shard alone. Underneath sits Silent Shard from Silence Labs, an implementation of the DKLs23 protocol audited by Cure53 and Trail of Bits. No proposer can complete a signature alone, so nothing moves until a proposal has cleared policy and the Robo Guardians have signed too.

What an attacker can and can’t do

Attacks over the past year have come through hardware wallet firmware, software bugs and tampered devices. Each found one point that was insecure enough. We build Salt assuming any one component can fail, whether that is a person, a device, a server or Salt itself. Here is what an attacker gets, and doesn’t get, for each part they break into.

If this is compromised What happens
A proposer’s key shard. The attacker holds that one shard. Without the proposer’s wallet, the attacker cannot authenticate and propose a transaction. And one shard cannot cryptographically meet the threshold.
A proposer’s wallet. The wallet they sign in with, which also unlocks their key shard. The attacker can propose, but every proposal is still checked against policy, and anything that fails is blocked and logged. Strict policies protect in this scenario and keeping this wallet on a hardware device makes it far harder to steal. If a proposer’s wallet is suspected to be compromised, a “denied proposers” policy can be applied to block all their transactions. Note that the one shard alone cannot cryptographically meet the threshold.
A Robo Guardian. The attacker holds a minority of key shards. A minority of shards cannot meet the threshold. The organisation can disconnect its Robo Guardians at any time and migrate its assets.
A trading bot or delegate. The attacker holds proposal rights on one account. The damage is confined to that account and its policies. An Owner can revoke proposal rights with the denied proposer policy and remove the bot or delegate from the organisation.
An organisation member who tries to alter a policy. The attacker can do whatever their role allows. Only Owners can change policies. Each change needs an Owner’s signature, and is recorded and visible across the organisation. Multi-Owner approval, coming soon, will let an organisation require more than one Owner for policy edits.
Salt’s backend. The attacker holds coordination infrastructure, which holds no usable key shards. The attacker gains no key material and cannot propose or cosign transactions. They may be able to interfere with policies and orchestration flows in flight, but cannot contribute to or initiate a signing ceremony without a key shard.
Salt goes offline permanently. No attacker gains anything. Signing through Salt stops. The encrypted shards remain on Arbitrum. Signers unlock their own shards with their wallet keys, and the open-source Salt Recovery Tool recombines them into the account private key, reading only public on-chain data. Funds can then move to a new wallet using any standard EVM wallet.

The core protections hold however an account is set up: the full key never exists, Salt never signs, and no single shard can complete a signature. Policies are where an organisation tunes the rest to its own risk.

Before the next incident

More will come out about the Binance incident over the coming weeks. The questions it raises can be put to any signing setup today: who can propose, what is checked before signing, who can change those checks, and what happens if any single part fails, including your infrastructure provider.

To experiment with self-sovereign infrastructure that doesn’t require an onerous engineering setup, spin up Salt. It takes under 15 minutes and needs no IT team. Get started with the Salt docs, or book a walkthrough of a signing setup for your organisation.

Written by

  • Tamlyn Rudolph

    Co-founder, Salt

Subscribe for the latest content and updates from Salt.

Subscribe Read more posts Follow Salt on X