Key Refresh
Key refresh replaces existing key shares with new ones while preserving the same aggregate public key, limiting the window of compromise in threshold signature schemes.
Key Takeaways
- Key refresh replaces every participant's key share with a new one while keeping the aggregate public key (and any associated on-chain addresses) unchanged.
- The protocol works by adding shares of zero: each participant generates a random polynomial with a zero constant term, so the underlying group secret stays the same while every individual share becomes a fresh, unrelated value.
- Refreshing limits the damage from a compromised share and enables changes to the signer set, making it a core building block for protocols like FROST and systems like Spark.
What Is Key Refresh?
Key refresh is a cryptographic sub-protocol that re-randomizes the key shares held by participants in a threshold signature scheme. After a refresh, every participant holds a brand-new share that is mathematically unrelated to the one it replaced, yet the group's aggregate public key remains identical. Any Bitcoin address, smart contract, or on-chain commitment tied to that public key continues to work exactly as before.
This distinguishes key refresh from a full distributed key generation (DKG) ceremony. A DKG creates an entirely new key pair: new secret, new public key, new addresses. Key refresh preserves the existing key pair while rotating the secret shares that protect it. Think of it as changing the locks on a safe without changing the safe itself: the contents stay the same, but old keys no longer open the door.
How It Works
Key refresh relies on a property of Shamir's Secret Sharing: shares of the same secret can be added together, and the resulting shares reconstruct the same secret. The refresh protocol exploits this by having each participant contribute shares of zero, which shift every share to a new value without altering the secret.
- Each participant generates a random polynomial of degree t-1 (where t is the signing threshold) with the constant term set to zero. This is called a zero-secret polynomial.
- Each participant evaluates their polynomial at every other participant's identifier and sends the resulting value as a refresh delta.
- Each participant receives deltas from all other participants, verifies them against published commitments, and adds them to their current share.
- Old shares are securely deleted. The new shares are mathematically independent from the old ones but still reconstruct the same group secret when combined.
Because every polynomial has a zero constant term, the sum of all constant terms is also zero. The group secret s = f(0) is unchanged. But at every other evaluation point, the added randomness transforms the share into a completely new value.
Verification
Participants need assurance that others actually chose a zero constant term: a malicious participant who picks a non-zero constant would silently change the group secret and corrupt the key. The standard defense is commitments: each participant publishes Pedersen commitments or Feldman commitments to the coefficients of their polynomial. Other participants verify that the constant-term commitment equals the identity element (the point at infinity for elliptic curves), proving the constant is zero without revealing any other coefficient.
Code Example
The frost-core Rust library (version 3.0) exposes refresh through dedicated functions:
// Trusted-dealer refresh
let refreshing_shares = compute_refreshing_shares(
secret_package,
max_signers,
min_signers,
identifiers,
&mut rng,
)?;
// Each participant updates their share
let new_key_package = refresh_share(
refreshing_share, // zero-share delta
current_key_package, // existing share
)?;
// The public key in new_key_package is identical
// to the one in current_key_packageIn a fully distributed (trustless) refresh, the library provides refresh_dkg_part1(), refresh_dkg_part2(), and refresh_dkg_shares() functions that follow the same zero-polynomial approach without requiring a trusted dealer.
Key Refresh vs. Full DKG
It is important to distinguish key refresh from a complete DKG:
| Property | Key Refresh | Full DKG |
|---|---|---|
| Group public key | Unchanged | New key generated |
| On-chain addresses | Stay valid | Must migrate funds |
| Old shares | Invalidated | N/A (different key) |
| Use case | Rotation, member changes | Initial setup |
| Complexity | One interactive round | Multiple rounds |
Why It Matters
In any long-lived threshold signature deployment, shares inevitably face exposure risk: servers get breached, devices get lost, employees leave organizations. Without refresh, an attacker who quietly collects shares over time (a "mobile adversary") can eventually accumulate enough to forge signatures.
Key refresh limits this window. Even if an attacker steals a share today, refreshing tomorrow renders that share useless: it no longer corresponds to any participant's current share, so combining old and new shares cannot produce a valid signature. This property is known as proactive security.
In the context of Bitcoin Layer 2 protocols, key refresh is especially valuable. Spark, for example, uses FROST-based signing where each transfer of a virtual UTXO involves rotating key shares between sender and recipient while keeping the same aggregate public key on the anchor transaction. The operator generates a new share for the recipient, adjusts its own share so the combined key stays fixed, and deletes the old share that corresponded to the sender. This is a targeted form of key refresh that enables off-chain ownership transfers without touching the blockchain.
Use Cases
Proactive Security
Organizations running multisig or threshold wallets can schedule periodic refreshes (daily, weekly, or per-epoch) to limit the exposure window. This is the cryptographic equivalent of rotating passwords: even if a share leaks, the attacker has a limited time to exploit it. Proactive threshold schemes combine key refresh with secure deletion to enforce forward secrecy for custody operations.
Changing the Signer Set
Key refresh allows adding or removing participants without generating a new key. When an employee leaves a custodial team, a refresh can redistribute shares to the remaining members, ensuring the departed employee's old share is worthless. When a new operator joins a network, refresh can issue them a valid share without exposing the secret or requiring all funds to migrate to a new address.
Ownership Transfers
Protocols like statechains and Spark use key refresh as the core mechanism for transferring ownership of Bitcoin UTXOs off-chain. The refresh rotates the key share from the current owner to the new owner while the on-chain output (locked to the aggregate public key) remains untouched. This avoids the cost and latency of an on-chain transaction for every transfer. For a deeper look at how this works in practice, see the Spark FROST signing performance analysis.
Recovery and Repair
If a participant suspects their share has been compromised (stolen device, leaked backup, side-channel attack), a refresh can immediately neutralize the leaked share without the disruption of generating a new key and migrating funds to a new address. The key deletion of the old share completes the recovery.
Risks and Considerations
Deletion Assumptions
Key refresh only provides proactive security if old shares are actually deleted. If an adversary captures both a pre-refresh and post-refresh share from the same participant, the two shares together may leak information. Secure deletion is straightforward in hardware security modules but difficult to guarantee in software environments with backups, swap files, and cloud storage. Protocols that rely on key refresh for ownership transfer (such as statechains) inherit this trust assumption: the operator must honestly delete old shares, and this cannot be verified cryptographically.
Liveness Requirements
A refresh round requires at least t participants (the signing threshold) to be online and responsive. If too many participants are offline, the refresh cannot complete. For systems that need frequent refreshes (every transfer, every epoch), this creates a liveness dependency. If the refresh stalls, ownership transfers or security rotations cannot proceed until quorum is restored.
Abort and Rushing Attacks
A malicious participant can attempt to disrupt a refresh by aborting partway through, potentially learning other participants' deltas without contributing their own. Well-designed protocols include abort identification to detect and exclude malicious participants. Additionally, a 2026 research paper noted that publishing intermediate refresh tokens during an aborted round can leak the group secret, underscoring the importance of careful protocol design.
Threshold Cannot Change Freely
Standard key refresh preserves the existing threshold t. Changing the threshold (for example, moving from 2-of-3 to 3-of-5) requires a more complex resharing protocol. A security vulnerability (CVE-2025-58359) in the frost-core library demonstrated this: versions 2.0.0 through 2.1.0 allowed refreshing with a smaller min_signers value, which could reduce the scheme's security. The fix, shipped in version 2.2.0, enforces that the threshold cannot be lowered through refresh.
Coordination Overhead
Each refresh round requires an interactive protocol: participants exchange commitments and deltas, verify each other's contributions, and update their local state. In networks with many participants or high refresh frequency, this communication overhead can become significant. Some newer protocols offer non-interactive "catch-up" mechanisms that allow offline participants to derive their updated shares from public data when they come back online, reducing the synchronization burden.
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.