llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · tiny-secp256k1

GHSA-HJ9C-QX2W-G7MH

tiny-secp256k1: Stale buffer after ignored wasm failure accepts invalid infinity tweak

Parche disponible
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -24 d de la divulgación
Exposición24 hDesde la divulgación, 19 nov 2026, 5:43 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 2.2.5
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
26 oct 26
18 nov 26
19 nov 26
20 nov 26
26 oct 26
2 nov 26
8 nov 26
14 nov 26
20 nov 26
FechaFaseEventoDetalle
Remediación Parche 2.2.5 tiny-secp256k1 · -24 d desde divulgación
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-HJ9C-QX2W-G7MH divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

### Summary
The three-argument `xOnlyPointAddTweakCheck` path ignores the wasm failure return and compares an unchanged input buffer. When the tweak result is the point at infinity, this stale-buffer comparison can return `true` for an invalid derivation.

### Details
`xOnlyPointAddTweakCheck` in `index.ts` has two code paths. The path taken when the caller omits `tweakParity` discards the return value of the wasm call and compares whatever the shared input buffer holds.

try {
    X_ONLY_PUBLIC_KEY_INPUT.set(point);
    X_ONLY_PUBLIC_KEY_INPUT2.set(resultToCheck);
    TWEAK_INPUT.set(tweak);
    if (hasParity) {
      return wasm.xOnlyPointAddTweakCheck(tweakParity) === 1;
    } else {
      wasm.xOnlyPointAddTweak();
      const newKey = X_ONLY_PUBLIC_KEY_INPUT.slice(
        0,
        validate.X_ONLY_PUBLIC_KEY_SIZE
      );
      return compare(newKey, resultToCheck) === 0;
    }

`x_only_point_add_tweak` in `lib.rs` returns `-1` and leaves `X_ONLY_PUBLIC_KEY_INPUT` untouched when the tweak addition fails.

pub extern "C" fn x_only_point_add_tweak() -> i32 {
    unsafe {
        let mut xonly_pk = jstry!(x_only_pubkey_parse(X_ONLY_PUBLIC_KEY_INPUT.as_ptr()), 0);
        let mut pubkey = PublicKey::new();
        if secp256k1_xonly_pubkey_tweak_add(
            get_context(),
            &mut pubkey,
            &xonly_pk,
            TWEAK_INPUT.as_ptr(),
        ) != 1
        {
            // infinity point
            return -1;
        }

The buffer still holds `point`, which the caller wrote immediately before the call. `newKey` therefore equals `point`, and the comparison against `resultToCheck` succeeds whenever the caller passes `resultToCheck` equal to `point`.

`secp256k1_xonly_pubkey_tweak_add` in upstream `main_impl.h` returns 0 only when the internal key fails to load or the tweak helper fails.

if (!secp256k1_xonly_pubkey_load(ctx, &pk, internal_pubkey)
    || !secp256k1_ec_pubkey_tweak_add_helper(&pk, tweak32)) {
    return 0;
}

The helper in `secp256k1.c` fails on scalar overflow or on an infinite result.

static int secp256k1_ec_pubkey_tweak_add_helper(secp256k1_ge *p, const unsigned char *tweak32) {
    secp256k1_scalar term;
    int overflow = 0;
    secp256k1_scalar_set_b32(&term, tweak32, &overflow);
    return !overflow && secp256k1_eckey_pubkey_tweak_add(p, &term);
}

`validateTweak` in `validate.ts` already rejects a tweak at or above the group order, so overflow is excluded and the only remaining cause is `lift_x(point) + tweak * G` reaching the point at infinity.

The parity path is correct for the same input. `secp256k1_xonly_pubkey_tweak_add_check` returns 0 in that case. The two documented forms of the same check disagree.

`xOnlyPointAddTweak` also disagrees with the check, returning `null` for the exact inputs the check accepts.

The condition is untested. `schnorr.js` skips every `xOnlyPointAddTweakCheck` assertion for the infinity vectors present in its own fixtures.

const res = secp256k1.xOnlyPointAddTweak(f.pubkey, f.tweak);
if (f.result === null) {
  t.same(res, f.result, `xOnlyPointAddTweak returns null when G pubkey and n - 1 tweak used`);
  continue;
}

### PoC
Both witnesses are already present in the project fixtures at `schnorr.json` as the two vectors with a null result, and both pass every validator in `validate.ts`.

import * as secp256k1 from "tiny-secp256k1";

const hex = (s) => Uint8Array.from(Buffer.from(s, "hex"));

// x coordinate of G, and the tweak n - 1
const point = hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798");
const tweak = hex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140");

// lift_x(point) + tweak * G is the point at infinity, no tweaked key exists
console.log(secp256k1.xOnlyPointAddTweak(point, tweak));
// null

console.log(secp256k1.xOnlyPointAddTweakCheck(point, tweak, point, 0));
// false   correct, the parity form uses the C check

console.log(secp256k1.xOnlyPointAddTweakCheck(point, tweak, point));
// true    wrong, the three argument form compares point against itself

A second witness from the same fixture uses the x coordinate of `2 * G` with tweak `n - 2`.

const point2 = hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5");
const tweak2 = hex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413f");
console.log(secp256k1.xOnlyPointAddTweakCheck(point2, tweak2, point2));   // true

Both were executed against the published `secp256k1.wasm` from npm 2.2.4 under `wasmtime`, driving the exports through the exact write, call, slice, zero sequence `index.ts` performs.

-- witness x(G), n-1
   xOnlyPointAddTweak(P, t)      = None
   check(P, t, P, parity=0)      = False
   check(P, t, P, parity=1)      = False
   check(P, t, P)   3-arg form   = True
   raw wasm return               = -1
   buffer after call unchanged   = True 79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

-- witness x(2G), n-2
   xOnlyPointAddTweak(P, t)      = None
   check(P, t, P, parity=0)      = False
   check(P, t, P, parity=1)      = False
   check(P, t, P)   3-arg form   = True
   raw wasm return               = -1
   buffer after call unchanged   = True c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5

-- control, ordinary tweak 5 on x(G)
   xOnlyPointAddTweak            = (1, 'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556')
   check 3-arg with correct result = True
   check 3-arg with wrong result   = False

The control confirms the three argument form is otherwise correct, so the defect is specific to the failure path.

An attacker generated witness follows the same construction with a hash derived tweak.

tweak = 2ae431167097f01e131d3e3fd000044e79eb64f5391d594ec311d4a56a38c1e3
point = d14530c85d0169da4e4be4642f2cdaad14fb0421b690df617d00366b5f1ca832
lift_x(point) + tweak * G = infinity
xOnlyPointAddTweakCheck(point, tweak, point) === true

### Impact
The three-argument helper can return `true` for an internal key and tweak whose derived point is at infinity. Protocols that use this result to validate a derived output can accept an invalid key when the caller controls the point, tweak, and comparison value.

Affected versions
  • `tiny-secp256k1`: 2.1.0 through 2.2.4.
  • `@bitcoin-js/tiny-secp256k1-asmjs`: 2.2.2 through 2.2.4.

The `xOnlyPointAddTweakCheck` API first appears in tiny-secp256k1 2.1.0. Static inspection of the integrity-checked asm.js releases confirms the same ignored return value and unchanged-buffer path when the tweak result is infinity. The WASM reproduction above is not an asm.js runtime measurement.

Remediation

Upgrade `tiny-secp256k1` and `@bitcoin-js/tiny-secp256k1-asmjs`, as applicable, to 2.2.5 or a later patched release. The path without `tweakParity` now checks the backend's failure result before reading and comparing the output buffer. A tweak that produces the point at infinity returns `false`.

References
  • Fix: Reject failed infinity tweaks before comparing the output https://github.com/bitcoinjs/tiny-secp256k1/commit/ba1af1fceea95967a172c6438ed9302730bb7c01

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
tiny-secp256k1≥ 2.1.0 < 2.2.5
@bitcoin-js/tiny-secp256k1-asmjs≥ 2.2.2 < 2.2.5
2.1.0
2.2.2
2.2.5
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npmtiny-secp256k1
Corregida 2.2.5 -24 d 2.2.5 no afectada
Versiones corregidas2.2.5
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-107853
Otrahttps://github.com/bitcoinjs/tiny-secp256k1/security/advisories/GHSA-hj9c-qx2w-g7mh
Otrahttps://github.com/bitcoinjs/tiny-secp256k1/commit/ba1af1fceea95967a172c6438ed9302730bb7c01
Otrahttps://github.com/bitcoinjs/tiny-secp256k1
Otrahttps://github.com/bitcoinjs/tiny-secp256k1/releases/tag/v2.2.5

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.