Glossary

Nonce Commitment

A nonce commitment is a cryptographic pledge to a random value used in the first round of multi-party signing, preventing signers from manipulating the final signature.

Key Takeaways

  • A nonce commitment is a cryptographic pledge to a secret random value that each signer publishes before any nonces are revealed. In protocols like FROST and MuSig2, this prevents any participant from choosing their nonce adaptively to manipulate the final signature.
  • Commitments take different forms depending on the protocol: FROST uses elliptic curve point commitments (publishing R = r·G), while the original MuSig protocol used hash-based commitments. MuSig2 eliminated the separate commitment round by using two nonces per signer combined with a binding coefficient.
  • Without nonce commitments, a rogue signer could observe honest signers' nonces and craft their own to forge signatures or extract secret keys. This is why all commitments must be collected before any raw nonce value is disclosed.

What Is a Nonce Commitment?

A nonce commitment is a value that binds a signer to a specific random nonce without revealing it. In multi-party Schnorr signature schemes, each participant must contribute a random nonce to construct the aggregate signature. If a malicious signer could see everyone else's nonces before choosing their own, they could compute a nonce that cancels out the honest contributions and forges a valid signature. Nonce commitments solve this by forcing every signer to commit to their nonce first: once committed, they cannot change it.

The concept builds on the general commitment scheme pattern in cryptography: a two-phase protocol where you first publish a value that locks you in (the commitment), and later reveal the underlying secret (the opening). Applied to signing, it ensures that the nonce generation process is fair and that no participant gains an information advantage over others.

How It Works

The specifics of nonce commitments differ across protocols, but the core idea is the same: every signer must irrevocably commit to their nonce before any nonce value is shared. Two main approaches exist in modern Bitcoin-related protocols.

FROST: Elliptic Curve Point Commitments

In FROST (Flexible Round-Optimized Schnorr Threshold Signatures), standardized as RFC 9591, each signer generates two secret nonces per signing session: a "hiding" nonce (d) and a "binding" nonce (e). The commitments are the corresponding elliptic curve points:

// FROST Round 1: each signer i generates commitments
d_i = random_scalar()     // hiding nonce (secret)
e_i = random_scalar()     // binding nonce (secret)

D_i = d_i · G             // hiding commitment (public)
E_i = e_i · G             // binding commitment (public)

// Signer broadcasts (D_i, E_i) to the coordinator

Publishing the curve points commits each signer to their nonces without revealing the underlying scalars. Due to the discrete logarithm problem, no one can recover d or e from D or E. After all commitments are collected, the coordinator computes a binding factor for each signer by hashing all commitments together with the message and the signer's identifier:

// Binding factor computation (RFC 9591 Section 4.4)
ρ_i = H("rho", i, msg, commitment_list)

// Group commitment (aggregate nonce)
R = Σ (D_i + ρ_i · E_i)  for all participating signers

The binding factor links each signer's contribution to the full set of commitments and the message being signed. Because the binding factor cannot be computed until every commitment is published, no signer can retroactively adjust their contribution to influence the aggregate nonce R.

MuSig1: Hash-Based Commitments

The original MuSig protocol used a simpler but more round-intensive approach. Each signer generated a single nonce r, computed R = r·G, then broadcast a hash commitment H(R) in the first round. Only after all hash commitments were collected would signers reveal their actual R values in a second round. The verifiers checked that each revealed R matched its earlier hash commitment. This required three rounds total: commit, reveal, then sign.

MuSig2: Eliminating the Commitment Round

MuSig2, formalized in BIP-327, reduces signing to two rounds by eliminating the separate commitment phase. Instead of one nonce, each signer generates two nonces and broadcasts both public nonce points simultaneously. The two nonces are combined using a coefficient derived from all published nonce points:

// MuSig2: each signer publishes two nonce points
R1_i = r1_i · G
R2_i = r2_i · G

// Nonce aggregation with binding coefficient
b = H("MuSig/noncecoef", agg_pk, R1_list, R2_list, msg)
R = Σ (R1_i + b · R2_i)

The two-nonce construction achieves the same security as a commitment round: an attacker who tries to adaptively choose their nonce pair after seeing others' nonce pairs cannot control the aggregate nonce, because the binding coefficient b depends on all nonce pairs including the attacker's own. This design is proven secure under the algebraic one-more discrete logarithm assumption and supports concurrent signing sessions as long as nonces are never reused.

Why Nonce Commitments Matter

Without nonce commitments (or an equivalent mechanism like MuSig2's two-nonce design), multi-party Schnorr signing is fundamentally insecure. Two specific attacks motivate the commitment requirement.

Rogue Nonce Attack

In a naive multi-party signing protocol where signers simply broadcast their nonce points one after another, the last signer to publish can choose their nonce adaptively. Suppose signers 1 through n-1 have published their nonce points R_1, ..., R_{n-1}. Signer n can compute:

// Rogue nonce selection
R_n = R_target - (R_1 + R_2 + ... + R_{n-1})

// The aggregate nonce becomes exactly R_target
R = R_1 + R_2 + ... + R_n = R_target

By steering the aggregate nonce to a chosen value, the malicious signer can produce a valid signature without cooperation from the other parties, or extract their secret key shares.

Nonce Reuse and Key Extraction

Even outside multi-party settings, nonce reuse in Schnorr signatures is catastrophic. If a signer uses the same nonce r to sign two different messages m_1 and m_2, an observer can extract the private key through simple algebra:

// Two Schnorr signatures with the same nonce r:
s_1 = r + e_1 · x    (where e_1 = H(R, P, m_1))
s_2 = r + e_2 · x    (where e_2 = H(R, P, m_2))

// Subtract to eliminate r:
s_1 - s_2 = (e_1 - e_2) · x

// Solve for the private key:
x = (s_1 - s_2) / (e_1 - e_2)

In multi-party protocols, the risk is amplified. For the original MuSig, a single nonce reuse can expose a signer's key share. MuSig2 is slightly more resilient due to its two-nonce structure: approximately three partial signatures under the same nonce pair are needed to extract the key. Regardless, all protocols require that nonces be generated fresh for each session and destroyed after use.

Use Cases

Threshold Signing on Spark

Spark uses FROST threshold signatures to enable cooperative signing across distributed parties. During each signing session, participants exchange nonce commitments in Round 1 before producing signature shares in Round 2. This two-round structure ensures that no single party (including the coordinator) can manipulate the resulting signature. For a deeper look at how Spark optimizes this process, see the FROST signing round performance analysis.

Bitcoin Multisignature Wallets

MuSig2 enables n-of-n key aggregation for Bitcoin Taproot transactions. Each co-signer publishes their two nonce points in Round 1. The coordinator aggregates them and distributes the result. In Round 2, each signer produces a partial signature. The combined output is a standard BIP-340 Schnorr signature indistinguishable from a single-signer transaction on-chain.

Distributed Key Generation Ceremonies

During a FROST DKG ceremony, participants use commitment schemes similar to nonce commitments: each party commits to their polynomial coefficients before revealing them. This prevents adversarial participants from biasing the resulting key shares. The commitment pattern extends beyond signing into any multi-party protocol where fairness in random value generation is essential.

Cross-Chain Atomic Swaps

Protocols like adaptor signatures and scriptless scripts rely on Schnorr nonce commitments to coordinate swaps across chains. Each party commits to their nonce, then reveals an adapted signature that can only be completed when the counterparty claims funds on the other chain. The commitment phase ensures neither party can cheat by adapting their nonce after learning the other's.

Risks and Considerations

Session Abort and Nonce Disposal

If a signing session aborts after nonce commitments have been exchanged, the nonces must be permanently discarded. Reusing a committed nonce in a subsequent session with different co-signers or a different message can expose the signer's secret share. RFC 9591 Section 7.3 explicitly warns against this: implementations must generate fresh nonces for every new session, with no exceptions.

Coordinator Trust

In both FROST and MuSig2, a coordinator typically collects and redistributes commitments. While the coordinator cannot forge signatures (they lack the secret nonces and key shares), a malicious coordinator could selectively withhold commitments, stalling the protocol. They could also attempt to present different commitment lists to different signers. Mitigations include peer-to-peer commitment broadcast and requiring signers to independently verify the commitment list hash.

Deterministic vs. Random Nonce Generation

Some implementations use deterministic nonces derived from the secret key and message (as in RFC 6979 for ECDSA). In multi-party settings, this is dangerous: if two sessions sign the same message, deterministic nonces would be identical, enabling key extraction. FROST and MuSig2 require randomized nonce generation, optionally mixed with deterministic components for defense-in-depth, but never purely deterministic.

Timing and Network Reliability

The commitment-before-reveal ordering is a strict protocol requirement. If network delays cause a signer to receive another signer's raw nonce before all commitments are collected, the security guarantee breaks down. Implementations must enforce that Round 2 (signature share generation) only proceeds after all Round 1 commitments have been received and validated. For protocols operating over unreliable networks, this can introduce latency.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.