search menu icon-carat-right cmu-wordmark

CERT Coordination Center

Retraction of mpc-lib hardened derivation fails to protect ancestor isolation

Vulnerability Note VU#701544

Original Release Date: 2026-10-26 | Last Revised: 2026-11-11

Overview

Fireblocks' mpc-lib library contains a cryptographic fail-open vulnerability in its BIP32 hardened derivation implementation in the case of a missing private parent key. This breaks the ancestor isolation property of hardened derivation, allowing an attacker with a compromised lower-level signer share to recover the higher-level share it was derived from.

After reviewing the feedback from Fireblocks and further analysis of the case, we have determined that this does not constitute a valid vulnerability. Fireblocks clarified that mpc-lib's signing protocols use only non-hardened BIP32 derivation and that a hardened index is handled as a non-hardened one. Effective exploitation would require privileged access, at which point the attacker would already hold the master share, rendering the issue moot.

Description

Fireblocks is a digital-asset custody and wallet platform that secures the private keys behind cryptocurrency wallets for institutions and exchanges, using multi-party computation (MPC) so that no single machine ever holds a complete key.

Fireblocks’ key security pipeline contains two layers: MPC, which splits a single key into shares, and hardened derivation, which mathematically isolates each share from its key hierarchy. Normally, the derivation delta between parent and child keys is formed by hashing the private parent key, a derivation index, and associated metadata.

VU#701544.1
A fail-open vulnerability was identified within the BIP32 hardened derivation implementation which fails to reject operations where no parent secret is present. If a parent key is missing, the implementation substitutes the secret parent contribution with a null buffer. Because the buffer becomes a known constant, 0, the delta becomes computable, violating ancestor isolation.

Impact

An attacker who compromises a single MPC party's descendant signer share, and who knows the associated chain code, can compute the public derivation delta and subtract it to recover that party's ancestor share, repeating the operation up the hierarchy to obtain that party's root share. The isolation between derivation levels is reduced to a publicly computable scalar, so a single leaf-level share compromise extends to that party's shares across the entire key hierarchy managed by the MPC cluster.

The primary MPC secret-sharing layer still prevents reconstruction of a full private key from a single compromised party's shares, so this flaw does not by itself yield a spendable key. Its significance is the elimination of a defense-in-depth layer: hardened derivation no longer provides post-compromise ancestor isolation, threshold-security assumptions degrade as compromise propagates across derivation levels over time, and the downgrade occurs silently with no error or log signal. In BIP32 deployments where the chain code is treated as public, the precondition of knowing the chain code is trivially met.

Solution

At the time of writing, Fireblocks could not be reached to coordinate this vulnerability, and no vendor fix is available. Integrators can, however, reduce exposure with the following mitigations.

  • Treat the chain code as secret. The attack is only available to a party that knows the chain code, because the derivation delta is computed as HMAC-SHA512(chaincode, ...). Chain codes should not be distributed in watch-only extended public keys or otherwise exposed to untrusted parties. Where a deployment can keep the chain code confidential, the delta is no longer publicly computable and ancestor-share recovery is not possible. This is the most effective mitigation available without a code change.

  • Do not rely on hardened derivation for isolation between signer shares. Audit derivation paths for hardened segments and treat the compromise of any single share as potentially exposing that party's other shares across the derivation hierarchy.

A complete fix requires a change in the library.

Acknowledgements

Thanks to hodlturk for reporting this vulnerability. This document was written using AI assisted tools by Alexander Curtis and Alex Lewis.

Vendor Information

701544
 

Fireblocks Not Affected

Notified:  2026-04-10 Updated: 2026-11-11

Statement Date:   November 01, 2026

VU#701544.1 Not Affected

Vendor Statement

Our position

We do not consider the issue described in CERT/CC vulnerability note VU#701544 (the "CERT note") to be a vulnerability, and we strongly disagree with how it is characterized. mpc-lib's signing protocols do not support hardened BIP32 derivation. This is a deliberate design choice in our MPC architecture, not a fail-open bug. We do not dispute the code behavior the CERT note describes. We dispute its classification as a vulnerability and its impact.

Fireblocks uses mpc-lib only with non-hardened paths, so the behavior described in the CERT note does not occur in Fireblocks’ implementation, and Fireblocks customers do not need to take any action. Hardened derivation is outside mpc-lib’s design, and using it is not a supported use of the library. Fireblocks does not use hardened derivation in any of our signing protocols.
Fireblocks' status for VU#701544 and the now retracted CVE-2026-90975 is Not Affected.

Why mpc-lib does not do hardened derivation

A hardened BIP32 child is computed with an HMAC over the parent private key. In mpc-lib signing protocols, no party ever holds that key. It exists only as shares held by different parties. Computing HMAC-SHA512 over a secret-shared key requires general-purpose MPC, which is considerably heavier than the protocols mpc-lib uses for signing. We chose not to support it.

Instead, mpc-lib signing protocols derives child keys the way non-hardened BIP32 does: each party adds a tweak to its own share. To get that tweak, the library calls the standard BIP32 routine with a zero buffer in place of the private key. This is intentional. It is not a fallback for a missing key, as the CERT note describes it.

Fireblocks itself uses only non-hardened paths (m/44/coin_type/account/change/address_index), as described in our public documentation: https://support.fireblocks.io/hc/en-us/articles/360014330819

Why the claimed impact does not apply

The CERT note describes the following attack. An attacker who compromises one party's descendant signer share, and who knows the chain code, computes the tweak and subtracts it. This recovers that party's ancestor share, and repeating the step recovers the root share.
In mpc-lib's signing protocols, there is no separate descendant share to compromise. Signing derives only the tweak. No mpc-lib signing or key-management flow stores or returns a derived share. Where a derived value is computed at signing time, it exists only transiently in memory, within a single signing call, and comes from the party's master share. The library also exports generic BIP32 helpers that take a caller-supplied key, and mpc-lib's own flows never call them with a real share.
The artifacts that could expose a signer's derived value in a compromise, such as process memory and backups, hold the master share itself. An attacker who obtains them already has what the chain is meant to reach. No isolation exists between the two, so none is lost. This does not depend on the chain code being secret. The CERT note does not show how an attacker would obtain a descendant share from an mpc-lib deployment.
The CERT note itself states that this behavior does not by itself yield a spendable key, because the MPC secret-sharing layer prevents reconstruction of the full private key from one party's shares. Code references are listed at the end of this statement.

Code references

All references are to mpc-lib commit 00ae08b (https://github.com/fireblocks/mpc-lib/commit/00ae08b). Paths are under src/common/cosigner/ unless noted.
* Tweak derived from a zero key: cmp_ecdsa_signing_service.cpp:279-293, bam_ecdsa_cosigner.cpp:263-282, frost_cosigner.cpp:198-222, asymmetric_eddsa_cosigner.cpp:26-53, eddsa_online_signing_service.cpp:269
* Persisted data is the tweak, not a share: include/cosigner/bam_tx_persistency_structures.h:13, include/cosigner/frost_tx_persistency_structures.h:18
* Derived value as a local variable, used within one signing call: frost_cosigner_client.cpp:263-264, bam_ecdsa_cosigner_client.cpp:582,653-658, asymmetric_eddsa_cosigner_client.cpp:188

Contact
security@fireblocks.com


Other Information

CVE IDs:
API URL: VINCE JSON | CSAF
Date Public: 2026-10-26
Date First Published: 2026-10-26
Date Last Updated: 2026-11-11 14:37 UTC
Document Revision: 5

Sponsored by CISA.