@noble/curves

Les faits et les vérifications qui les fondent

Rien de ce qui suit n’est copié d’une documentation. La vérification content/libraries/verify/noble-curves/run.sh a exécuté @noble/curves 2.4.0 dans l’image de conteneur node:24.22.0-bookworm-slim le 20 octobre 2026 ; la page doit correspondre à ce que la vérification a affiché, et chaque fait cite les lignes en question.

• Encodage des signatures ECDSA

  raw

  sign() renvoie 64 octets de r‖s compact ; avec format: "der", elle renvoie plutôt de l’ASN.1 DER, et verify() a besoin de la même option pour le lire.

  Relevé par la vérification

  fact ecdsa-signature-encoding = raw
  evidence ecdsa-signature-encoding: default 64 bytes; format "der" gives 71 bytes that parse as DER: true

• Low-S à la signature

  low-s

  Aucune valeur high-S n’est apparue sur 64 signatures, sur aucune des sept courbes de Weierstrass : s est toujours normalisé.

  Relevé par la vérification

  fact ecdsa-low-s-sign = low-s
  evidence ecdsa-low-s-sign: no high-S in 64 signatures on any of the seven curves

• High-S à la vérification

  rejects-high-s

  Avec les options par défaut, chaque signature high-S produite par node:crypto a été rejetée et chaque signature low-S acceptée ; avec lowS: false, les 64 ont toutes passé la vérification.

  Relevé par la vérification

  fact ecdsa-low-s-verify = rejects-high-s
  evidence ecdsa-low-s-verify: 64 node:crypto signatures: every high-S one rejected: true; every low-S one accepted: true; all 64 accepted with lowS false: true

• Nonce ECDSA

  rfc6979

  RFC 6979 : le vecteur de test P-256 de l’annexe A.2.5 a été reproduit exactement, avec s remplacé par n − s. extraEntropy: true y mêle de l’aléa (signatures dites « hedged »).

  Relevé par la vérification

  fact ecdsa-nonce = rfc6979
  evidence ecdsa-nonce: r matches RFC 6979 A.2.5: true; s equals n - s(RFC): true; extraEntropy true changes the bytes: true

• Ce que l’appel de signature hache

  hashes-message

  La 2.x hache le message avec la fonction de hachage de la courbe (SHA-256 pour P-256) ; prehash: false signe et vérifie un condensat que vous avez calculé.

  Relevé par la vérification

  fact ecdsa-prehash = hashes-message

• Entrée de signature en version 1

  digest

  En 1.9.7, sign() traitait son entrée comme le condensat : seul sign(sha256(m)) a reproduit le vecteur de la RFC 6979. Mettre à jour depuis la 1.x sans modifier les points d’appel conduit à un double hachage.

  Relevé par la vérification

  fact v1-sign-input = digest
  evidence v1-sign-input: 1.x sign(sha256(m)) gives the RFC 6979 r: true; 1.x sign(m) does: false

• Low-S sur P-256 en version 1

  either

  La 1.9.7 renvoyait telle quelle la valeur high-S de la RFC pour P-256 ; la normalisation sur toutes les courbes est une nouveauté de la 2.x.

  Relevé par la vérification

  fact v1-p256-low-s-sign = either
  evidence v1-p256-low-s-sign: 1.x P-256 returned the RFC's high s unchanged: true

• Signature ECDSA mal formée

  throws

  Une signature de mauvaise longueur (des octets DER sans format: "der", ou un bloc de 3 octets) lève expected Uint8Array of length 64 ; une signature bien formée mais incorrecte renvoie false.

  Relevé par la vérification

  fact ecdsa-malformed-signature = throws
  evidence ecdsa-malformed-signature: DER without format: throws expected Uint8Array of length 64, got length=71
  evidence ecdsa-malformed-signature: 3 bytes: throws expected Uint8Array of length 64, got length=3
  evidence ecdsa-malformed-signature: 64 zero bytes: false

• Courbes ECDSA

  P-256P-384P-521secp256k1brainpoolP256r1brainpoolP384r1brainpoolP512r1

  P-256, P-384 et P-521 dans nist.js, secp256k1 dans secp256k1.js, et les courbes Brainpool r1 dans misc.js.

  Relevé par la vérification

  fact ecdsa-curves = P-256, P-384, P-521, secp256k1, brainpoolP256r1, brainpoolP384r1, brainpoolP512r1

• EdDSA

  Ed25519Ed25519phEd25519ctxEd448Ed448ph

  Signature et vérification réussies avec Ed25519 et ses variantes ph et ctx, Ed448 et Ed448ph.

  Relevé par la vérification

  fact eddsa = Ed25519, Ed25519ph, Ed25519ctx, Ed448, Ed448ph

• Algorithmes post-quantiques

  none

  Aucun algorithme post-quantique dans ce paquet.

  Relevé par la vérification

  fact pqc = none
  evidence pqc: exports of the package mention ML-DSA or ML-KEM: false

• Formats de clé publique

  sec1-uncompressedsec1-compressed

  Les clés publiques sont des points SEC1, compressés ou non compressés ; un x‖y de 64 octets et le SPKI DER ont été rejetés.

  Relevé par la vérification

  fact public-key-formats = sec1-uncompressed, sec1-compressed

• Format de clé publique par défaut

  sec1-compressed

  getPublicKey() renvoie le point compressé de 33 octets, sauf si vous passez false pour obtenir la forme non compressée.

  Relevé par la vérification

  fact default-public-key = sec1-compressed

• Formats de clé privée

  raw-scalar

  Les clés secrètes sont le scalaire brut de 32 octets ; le PKCS#8 DER a été rejeté.

  Relevé par la vérification

  fact private-key-formats = raw-scalar

• Signatures Schnorr

  BIP-340

  schnorr, dans secp256k1.js, implémente BIP-340 : des signatures de 64 octets sur des clés publiques x-only.

  Relevé par la vérification

  fact schnorr = BIP-340

Utilisation

import { generateKeyPairSync, sign } from "node:crypto";
import { p256 } from "@noble/curves/nist.js";

// A signature made elsewhere: node:crypto (OpenSSL) emits DER, with s in either half.
const { privateKey, publicKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
const message = new TextEncoder().encode("order #1042 approved");
const der = sign("sha256", message, privateKey);
const jwk = publicKey.export({ format: "jwk" });
const point = Uint8Array.from([4, ...Buffer.from(jwk.x, "base64url"), ...Buffer.from(jwk.y, "base64url")]);

// noble 2.x hashes the message itself and rejects high-S unless told otherwise.
console.log("verified:", p256.verify(der, message, point, { format: "der", lowS: false }));

// Its own signatures are compact r||s, RFC 6979 and low-S: the same bytes every time.
const secretKey = p256.utils.randomSecretKey();
const first = p256.sign(message, secretKey);
const second = p256.sign(message, secretKey);
console.log("deterministic:", Buffer.from(first).equals(Buffer.from(second)), first.length);