808bits

The ECDSA tax: GG20, CGGMP21, DKLs23 and FROST compared

2026-08-19 · updated 2026-11-10 · 20 min · keys and signing

On one laptop core, the same Go library signs a 2-of-3 threshold signature in 3 milliseconds with FROST and in 5.1 seconds with threshold ECDSA. Both are sold as an “MPC wallet”. Both keep the key in shares that never meet, both produce ordinary signatures, both have a whitepaper with a lock icon on it. One of them signs in two rounds of 282 bytes. The other one runs nine rounds of Paillier ciphertexts and zero-knowledge proofs, and its protocol family has spent the last five years getting patched against key-extraction attacks. The difference between them is one line of algebra, decided in 1992, long before anyone tried to split a key.

I recently implemented three of these protocols from scratch, FROST, CGGMP and DKLs23, in one codebase, zig-mpc, and benchmarked them against the reference implementations they were ported from. The measurements are further down.

The tax, in one equation

A Schnorr signature, which covers Ed25519 and Bitcoin’s Taproot flavor, is

s = k + e·x

where x is the private key, k is a fresh nonce, and e is a hash everyone can compute. The secrets appear added together, each multiplied only by public values. If three parties hold shares of x that sum to the key, and shares of k that sum to the nonce, then each party computes its own little s_i = k_i + e·x_i, the shares are added up, and the sum is a valid signature. Nobody ever holds x, and nobody has to do anything clever. The entire threshold problem reduces to “agree on the nonce commitment first so nobody can bias it”, which is what FROST spends its two rounds on.

An ECDSA signature is

s = k⁻¹ · (m + r·x)

Same ingredients, arranged so that nothing adds. That k⁻¹ is the inverse of a secret that must never exist in one place, and it multiplies x, a second secret that must never exist in one place. Shares of k do not give you shares of k⁻¹. Shares of k and shares of x do not give you shares of k·x. To sign, the parties must jointly compute products and an inversion of numbers none of them knows, and prove to each other they did it honestly, because a party that cheats here can walk away with the key.

Everything else in this field, the Paillier encryption, the oblivious transfer, the range proofs, the nine-round protocols and most of the CVEs, is the bill for that inversion. That is the ECDSA tax. It is paid because Bitcoin, Ethereum and every EVM chain settled on ECDSA before threshold signing was a requirement anyone had, and no vendor can waive it.

EdDSA and Schnorr sit on the other side of the line, and the three orders of magnitude at the top of this page are the distance between the two sides.

The family tree

Every practical threshold-ECDSA protocol answers one question: how do two parties multiply secrets they don’t have? There are two mainstream answers, and they define the two lineages. Schnorr, the third lineage, never has to answer it.

LChe(iM+onPnGGPprmcadGGreorie12/efmyll80sropllCierti1(Ggspie7t+Gnhhor-iaMi,in)(odbPnc2feo2g+--nr1,UonttChf)i)+o-fppw2irr)aoodbaoolcfetsyi)ovuemDDDuKKKlLLLtotsssibr112pla893linyvs(((if2t3toe--wuroorosffo--us2nnh))dasr)edsecrEedtF2s(RR5T?yhSOF5aoacSC1puvhT9ren9,odo5ootr9stnor1e')ctp,
Threshold signing protocols, by how they multiply secrets.

The Paillier lineage encrypts one secret under Paillier, an encryption scheme where you can multiply a ciphertext by a known number and the plaintext gets multiplied too. Party A sends an encryption of k_A, party B multiplies it by x_B inside the ciphertext, adds a mask, and sends it back. Neither learned the other’s secret, and together they now hold additive shares of the product. The catch is that Paillier needs an RSA-sized modulus per party, generating one needs safe primes, and a maliciously crafted modulus is a weapon, so the protocols wrap everything in zero-knowledge range proofs and the setup ceremony proves your modulus is well-formed before anyone will talk to you. Lindell’s 2017 protocol did this for two parties and made MPC wallets practical. GG18 reached t-of-n on the same primitive a year later. It is a separate design and not an extension of Lindell’s, and a second t-of-n paper, from Lindell and Nof, appeared the same year. GG20 added identifiable aborts (when signing fails, you learn who broke it). CMP and CGGMP21 rebuilt it with UC security proofs, presigning, and proactive share refresh. CGGMP21 has been revised repeatedly since publication, and the 2024 revision is what I implemented.

The OT lineage replaces the encryption with oblivious transfer, a primitive where a receiver picks one of two values a sender offers, the sender doesn’t learn which, and the receiver doesn’t learn the other. Chain a few hundred of these and you can build multiplication out of what is essentially binary long multiplication, using only elliptic-curve and hash operations, with no RSA and no aux ceremony. Doerner, Kondi, Lee and shelat built the 2-of-2 version in 2018, t-of-n in 2019, and DKLs23 is the current form. The trade is that OT-based signing moves a lot more bytes.

The Schnorr lineage is FROST, now RFC 9591. Two rounds, tiny messages, and the code is small enough to actually read in an afternoon. If your chain verifies Ed25519 (Solana, Cardano, TON) or BIP-340 Schnorr (Bitcoin Taproot), the tax doesn’t apply to you. I walked through a live in-browser FROST ceremony in an earlier article, including what happens when a participant cheats.

There’s a fourth answer, class-group-based encryption, which removes the RSA modulus while keeping the homomorphic approach. It is elegant and has seen little production uptake, so I’ll leave it as a pointer.

Vendors blur one more distinction. A 2-of-2 protocol is a different problem from t-of-n. Lindell17 and DKLs18 are two-party protocols, your phone and the vendor’s server, each useless alone. They are much simpler than general threshold schemes, which is why they shipped first and why several “2-of-N” products are really a two-party protocol run against N different counterparties. Simpler is fine. It is a different trust model from 3-of-5 across your own infrastructure, and the marketing rarely tells you which one you bought.

Who actually ships what

These are the implementations anyone who goes looking will find. I cloned and built each of them in August 2026. The audit claims are from the repos and reports themselves, as they stood then.

Lindell17: Unbound’s blockchain-crypto-mpc (C++, protocols designed by Yehuda Lindell, archived read-only since September 2021 with the notice “Unbound will not provide any security updates”. The company was later acquired by Coinbase) and ZenGo’s gotham-city two-party wallet. Several of the “2-of-N” products described above run this protocol.

GG18: bnb-chain/tss-lib (Go), the implementation behind Binance’s TSS and half the bridges you’ve used. Audited by Kudelski Security in October 2019. Its signing protocol runs nine rounds plus finalization, and you can count the round_1.go through round_9.go files.

GG18 + GG20 + Lindell17 in one box: ZenGo’s multi-party-ecdsa (Rust), the research library much of the ecosystem learned from, audited in 2019 and now unmaintained, with a note that deserves quoting: “This repository is no longer maintained… Zengo will not provide any security updates or hotfixes (should an issue arise).” It is still being forked into production systems today.

CMP: Fireblocks’ mpc-lib (C++), their open-sourced production algorithms, MPC-CMP for ECDSA plus threshold EdDSA, audited by NCC per the repo’s SECURITY.md. It built cleanly for me, though its benchmark harness is shaped around their cosigner service, so I didn’t extract a comparable number.

CGGMP21: Taurus’ multi-party-sig (Go), the cleanest open CGGMP implementation, with both the online and presigning variants, and a disclaimer in the README: “needs further testing and auditing to be production-ready.”

DKLs23: two independent implementations, and the contrast between them taught me more than any paper. Silence Labs’ dkls23 (Rust, audited by Trail of Bits, who date the review to October 2023 and whose report in the repo is dated April 2024, non-commercial license) and 0xCarbon’s dkls23-core (Rust, MIT/Apache, unaudited). Same paper, different engineering choices, more on that below.

FROST: Zcash Foundation’s frost crates (Rust, RFC 9591, audited by NCC Group at v0.6.0 with the report published in October 2023, the Taproot crate not included), plus FROST implementations inside Taurus’ library and mine.

Where the bodies are buried

Threshold ECDSA’s attack history has little to do with sloppy programmers. The protocols have so many moving parts that audited implementations kept falling to the same class of bug: a missing check on something an honest party would never send.

September 2020, Attacking Threshold Wallets (Aumasson and Shlomovits): three attacks on implementations in production, aimed at the software built around the protocols and not at the papers. One of the targets, the authors write, was “the cold wallet system of the biggest cryptocurrency exchange”, fixed after they reported it.

December 2021, Alpha-Rays (Tymokhanov and Shlomovits): two key-extraction attacks on GG18/GG20 implementations. The worse one exploits implementations that ran the multiplication step without range proofs, a documented performance option, and pulls the full key with eight signatures. The other uses a deliberately small Paillier key, a value no honest party would generate and which nothing in most implementations rejected. The GG18 paper on eprint was revised three days after the attack went up, with the changelog “Fixes some issues in the protocol and security proof.”

Also December 2021, the sharing layer (Trail of Bits): two bugs in the secret-sharing code of Binance’s tss-lib and most of its forks, Keep Network, Swingby, THORChain and ZenGo among them. The code checked that a participant’s ID was not zero and forgot to check it modulo the curve order, so a participant who chose the order as an ID was handed the other parties’ secrets during key generation or resharing. All but one of the projects had patched by the time the bugs were published.

March 2023, BitGo (Fireblocks): the zero-knowledge proofs were missing altogether from BitGo’s Ethereum TSS wallet. Fireblocks says a crafted Paillier modulus got it the other party’s whole key share from a single signature and a few seconds of computation, and that it did this against BitGo’s production service in December 2022. BitGo shipped a fix in February 2023. This is one custody vendor’s account of another.

Also March 2023, four CVEs (Kudelski Security) from an audit of io.finnet’s Go implementation of CGGMP: proofs that could be replayed because the challenge left out the session ID, a hash with easy collisions feeding those challenges, and arithmetic on secrets that was not constant time. These are audit findings with no attack published, and io.finnet chose to make them public.

August 2023, TSSHOCK (Verichains, presented at Black Hat): three attacks, α-shuffle, c-split and c-guess, against GG18/GG20/CGGMP21 implementations, several of them enabling full key extraction from a single malicious participant. The line from their disclosure that should be printed on every vendor’s slide deck: nearly all implementations they examined were vulnerable “despite having undergone multiple security audits.”

Also August 2023, BitForge (Fireblocks): CVE-2023-33241, the missing small-factor check on the Paillier modulus in GG18/GG20, which Fireblocks says was “found at the pseudocode level” of the papers and not only in code, key extraction in 16-bit chunks and the full key in sixteen signatures in the easiest case (the report says other parameter choices could take as many as a billion), and CVE-2023-33242, against Lindell17 implementations that mishandled aborts and kept signing, leaking a bit at a time until roughly 200 signatures gave up the key. Fireblocks’ report on the first lists BitGo’s BitGoJS and ZenGo’s multi-party-ecdsa among the affected code. Its report on the second says the bug was found in ZenGo’s wallet and then verified in Coinbase’s Wallet as a Service library, and that both patched. ZenGo’s GG18 and GG20 library code is listed as “not actively maintained and not patched”. The paper version is eprint 2023/1234, and the openings it describes are mundane.

September 2023, the OT side (Trail of Bits): a key-recovery bug in an OT-based threshold ECDSA implementation they do not name. A malicious party forces selective aborts in the OT extension step and learns a few secret bits from each one, and the implementation kept reusing the same base setup afterwards. The papers discuss selective aborts and are vague about what to do after one.

All but two of these are in Paillier-lineage protocols or the code that implements them. The 2020 paper does not sort its targets that way, and the last one is on the OT side. That is partly age and deployment share, since attackers go where the money is, but it is also surface area. The security of GG-style protocols rests on a stack of number-theoretic side conditions (modulus well-formed, no small factors, ranges proved, aborts handled) and each unchecked condition was someone’s CVE. The OT lineage’s checks are fewer and more mechanical, and FROST has few to forget. It still forgot one: Trail of Bits found ten implementations, the FROST reference code and the Zcash Foundation’s among them, that never checked the length of a commitment vector in key generation, which let one participant raise the threshold unnoticed. That costs availability and no keys. And “audited” means someone looked, once. The TSSHOCK targets were audited, tss-lib was audited in 2019, and Alpha-Rays and BitForge both landed afterward. The reference implementations are a related problem: ZenGo’s library and Unbound’s are explicitly unmaintained, with attack papers published after maintenance ended, and the forks did not all get the memo.

The operational question this leaves is which protocol your vendor runs, which implementation it descends from, and what their story was in August 2023. A vendor who can’t answer the first can’t have answered the other two. I’ve written before about what vendor recovery tooling does and doesn’t prove, and protocol disclosure belongs on the same checklist.

Numbers from one machine

Benchmarks in papers are run on the authors’ hardware with the authors’ favorite parameters. These are all from my workstation in August 2026, an i7-10510U laptop core with everything pinned to a single CPU so concurrency can’t flatter anyone, and every number is the total across all parties. Absolute values are modest (it’s a laptop) and the ratios are the point.

First, the tax itself, measured inside one codebase, Taurus’ multi-party-sig in Go, three parties, two signers, their own example harness with timing added:

operation (same library, same machine)time
FROST keygen6 ms
FROST sign3 ms
CGGMP keygen40.2 s
CGGMP sign (no presigning)5.1 s
CGGMP presign3.5 s
CGGMP sign after presigning1 ms

Same authors, same language, same curve. Threshold ECDSA costs three orders of magnitude more than threshold Schnorr until presigning hides the cost, a trade I’ll come back to because it isn’t free.

Second, the three families side by side in my own codebase, same harness, 2-of-3 with two signers throughout:

zig-mpc, one coresetup (once)per signaturewire bytes per signature
FROST Ed255192.3 ms DKG0.9 ms~280 per signer
FROST secp256k1 (Taproot)1.2 ms DKG0.7 ms~284 per signer
DKLs23 ECDSA1.25 s27 ms~80 KB per pair
CGGMP24 ECDSA (reduced params)2.9 s aux ceremony2.7 s presign + 0.1 msKBs of Paillier ciphertexts

The CGGMP row needs an asterisk. Those numbers use a 1152-bit Paillier modulus, a demo parameter set. At production size, meaning a 2048-bit modulus with safe primes and 80 proof repetitions, the same harness measured 5.9 minutes per party just to generate the safe primes, a 31-second aux ceremony, and a 9.8-second presign. NCC Group’s walk through Paillier in threshold ECDSA says the modulus “should be at least 3072 bits” to match a 128-bit key, which I did not measure and which can only be slower. Prime generation is the long pole, which is why every serious deployment generates primes offline and why tss-lib ships precomputed test fixtures. For calibration: tss-lib’s GG18 keygen for five parties took 56 seconds on this machine with the expensive Paillier parameters already precomputed, and its 3-of-5 signing took 2.6 seconds end to end. The ZF frost crates, for contrast, sign in sub-millisecond steps (63 µs round one, 220 µs round two, 304 µs aggregation in their seven-signer Ed25519 criterion bench).

Third, one protocol, three implementations, because the implementation decides almost as much as the protocol. DKLs23, keygen-through-first-signature, three parties:

DKLs23 implementationkeygen + OT setupper signature
Silence Labs dkls23 (Rust, ToB-audited)0.71 s20 ms
zig-mpc (Zig, mine)1.25 s27 ms
0xCarbon dkls23-core (Rust)2.7 s24 ms

The audited one is fastest for a reason. The same base-OT paper can be instantiated with or without per-instance zero-knowledge proofs, and Silence Labs chose without, leaning on the random-oracle structure instead. About 1,500 elliptic-curve operations per direction, 3,000 per party-pair, exist in my implementation solely to carry proofs theirs doesn’t send. I kept the proof-carrying variant anyway, because it matches the reference implementation byte for byte, which means every random oracle in my port is cross-checked against an independent codebase. Faster, or checkable against someone else’s bugs, is a real tradeoff, and there are good implementations on both sides of it.

The tradeoffs nobody puts on the pricing page

Rounds. A nine-round protocol between a phone in Berlin and an HSM in Virginia pays nine WAN round trips. At 100 ms each, the network dwarfs every benchmark above. This is why round count was the headline metric in every paper from GG18 onward, and why DKLs23’s three rounds and FROST’s two count for more in production than their CPU times. Conversely, if your signers share a rack, rounds are nearly free and you should stop paying for round-reduction with complexity.

Presigning. CGGMP’s party trick, grinding the expensive part before the message exists and signing in one message when it arrives, is valuable for trading systems. But a presignature is a nonce that already exists, stored on disk, waiting. Use one twice and two signatures share a nonce, which hands anyone watching the full key, not a share of it. Every presigning deployment needs presignature state management with the same seriousness as key management. FROST has the same property in miniature (its round-one commitments are nonces), which is why RFC 9591 spends so many words on never reusing them.

Identifiable abort. GG20 and CGGMP can tell you which party broke a signing session. GG18 and plain DKLs generally abort without blame. In DKLs one case cannot be left that way. Trail of Bits’ review of the Silence Labs library found its handling of a selective abort crashed before it could name the party, and wrote that to “blame or punish no one” after such an abort “could lead to a key extraction attack”. With three parties in one company this is a debugging nicety, but with five parties across four organizations and an SLA, “the ceremony failed and we can’t say who caused it” is a governance incident.

Setup. The Paillier lineage front-loads minutes of ceremony and then signs relatively cheaply forever. The OT lineage front-loads about a second and pays ~25 ms and ~80 KB per signature. FROST front-loads nothing worth mentioning. A custody vault signing twice a week and an infra wallet signing ten times a second should not choose the same protocol, and neither should copy a market maker’s presigning architecture because a blog said it was fast.

Bytes. FROST messages fit in a text message. DKLs signing moves ~80 KB per pair, fine on any real network and awkward over Bluetooth to a hardware signer. GG-style messages are Paillier-ciphertext-sized but the protocols are chatty across many rounds. If your transport is constrained or metered, this row of the table can dominate the decision.

What I’d actually pick

If your chain verifies Schnorr or EdDSA, use FROST and collect the refund. This is the consensus position and an RFC, and the remaining excuses are inertia. Taproot means Bitcoin qualifies.

If you need threshold ECDSA for a 2-of-2 wallet product, Lindell17-style protocols remain a defensible choice if you inherit a maintained implementation and treat abort handling as the security boundary BitForge proved it is. What you should not do is fork an archived research repo whose own authors promise you nothing.

If you need t-of-n ECDSA and are building fresh, I would go DKLs-family first (small assumption set, no Paillier ceremony, mechanical checks), CGGMP where presigning or identifiable abort is a hard requirement (and budget for the state management that comes with it), and GG18/GG20 not at all in 2026. Whether the papers or the code were at fault is argued case by case, and Fireblocks blames the pseudocode for BitForge. Either way the implementation ecosystem around them is where four years of key-extraction papers went hunting, and the successor exists.

Whichever row of the table you buy, the protocol name is a question your vendor should answer in one word, and “what did BitForge and TSSHOCK mean for you?” is one they should answer in one paragraph.

Correction. An earlier version credited the DKLs23 paper with dynamic quorums (a Silence Labs implementation feature), said a reused presignature leaks a key share (it leaks the key), called GG18 an extension of Lindell’s protocol, which it is not, and said the papers were not refuted without noting that Fireblocks places the BitForge gap in the pseudocode. It named Coinbase WaaS as affected by BitForge on the strength of Fireblocks’ overview post, which does not say so. Fireblocks’ technical report on CVE-2023-33242 does name it, and the link goes to that report. It gave sixteen signatures for CVE-2023-33241 without saying it is the easiest case, said the vendors patched when the report lists ZenGo’s GG code as unpatched, and said every break was in the Paillier lineage. It started the attack history in December 2021 and left out the 2020 paper, the tss-lib sharing bugs, Fireblocks’ BitGo disclosure, Kudelski’s four CVEs and the September 2023 bug on the OT side. The Taurus, tss-lib and CGGMP timings are the August measurements and reran faster on 30 October (CMP keygen 15 to 18 s, CMP sign 3.0 s, tss-lib keygen 29.5 s) on the same machine.

About the implementation. The zig-mpc numbers come from a codebase I built implementing FROST (RFC 9591), CGGMP24 and DKLs23 in Zig, with DKLs23’s random oracles kept byte-compatible with 0xCarbon’s Rust implementation so the two can check each other. It is unaudited, pre-production software: the benchmarks are measured, the security claims are not yet backed by anyone else’s review. The interactive companion piece, a live threshold ceremony in your browser, runs the same code as WebAssembly. Benchmark harnesses for the other libraries are their own: tss-lib’s end-to-end tests, Taurus’ example driver with timing added, and ZF frost’s criterion suite, all pinned to one core of an i7-10510U.