noble-curves

Implémentation JS auditée et minimale de cryptographie sur courbes elliptiques.

• 🔒 Auditée par des sociétés de sécurité indépendantes
• 🪶 Minimale : 15 Ko (gzippé) pour secp256k1, le code inutilisé est exclu de vos builds
• 🏎 Rapide : optimisée à la main pour les particularités des moteurs JS
• 🔍 Fiable : tests inter-bibliothèques / wycheproof garantissant la correction
• ➰ Courbes de Weierstrass, Edwards ; signatures ECDSA, EdDSA, Schnorr, BLS
• ✍️ ECDH, hash-to-curve, OPRF, FROST, hash Poseidon, FFT
• 🔖 Non-répudiation (SUF-CMA, SBS) et compatibilité consensus (ZIP215) dans ed25519, ed448
• 🥈 Wrapper avec API identique au-dessus de WebCrypto natif

Les courbes ont des projets frères de 5 Ko secp256k1 & ed25519. Ils ont une surface d'attaque plus réduite, mais moins de fonctionnalités.

Cette bibliothèque appartient à la cryptographie noble

noble cryptography — ensemble de bibliothèques et d'outils cryptographiques à haute sécurité, facilement auditables et contenus.

• Dépendances nulles ou minimales
• Code TypeScript / JS hautement lisible
• Versions signées PGP et builds NPM transparents
• Toutes les bibliothèques : ciphers, curves, hashes, post-quantum, 5 Ko secp256k1 / ed25519
• Version WASM : awasm-noble
• Consultez la page d'accueil pour des ressources de lecture, de la documentation et des applications construites avec noble

Utilisation

npm install @noble/curves

deno add jsr:@noble/curves

Nous prenons en charge toutes les principales plateformes et environnements d'exécution. Pour React Native, vous pourriez avoir besoin d'un polyfill pour getRandomValues. Un fichier autonome noble-curves.js est également disponible.```js // import * from '@noble/curves'; // Error: use sub-imports, to ensure small app size import { secp256k1 } from '@noble/curves/secp256k1.js'; const { secretKey, publicKey } = secp256k1.keygen(); const msg = new TextEncoder().encode('hello noble'); const sig = secp256k1.sign(msg, secretKey); const isValid = secp256k1.verify(sig, msg, publicKey);

- [Signatures ECDSA, EdDSA, Schnorr](#ecdsa-eddsa-schnorr-signatures)
- [ECDH : secrets partagés Diffie-Hellman](#ecdh-diffie-hellman-shared-secrets)
- [webcrypto : wrapper convivial](#webcrypto-friendly-wrapper)
- [Signatures BLS, bls12-381, bn254 alias alt\_bn128](#bls-signatures-bls12-381-bn254-aka-alt_bn128)
- [hash-to-curve : hachage vers des points de courbe](#hash-to-curve-hashing-to-curve-points)
- [OPRFs](#oprfs) | [Signatures de seuil FROST](#frost-threshold-signatures)
- [poseidon : hash Poseidon](#poseidon-poseidon-hash) | [fft : Transformée de Fourier rapide](#fft-fast-fourier-transform) | [utils](#utils-byte-shuffling-conversion)
- Internes : [Mathématiques de points](#elliptic-curve-point-math) | [modulaire](#modular-modular-arithmetics--finite-fields) | [courbes personnalisées](#weierstrass-custom-weierstrass-curve--ecdsa)
- [Spécifications](#specs)
- [Sécurité](#security) | [Vitesse](#speed) | [Mise à niveau](#upgrading) | [Contribution et tests](#contributing--testing) | [Licence](#license)

### Signatures ECDSA, EdDSA, Schnorr

#### secp256k1, p256, p384, p521, ed25519, ed448, brainpool```js
import { secp256k1, schnorr } from '@noble/curves/secp256k1.js';
import { p256, p384, p521 } from '@noble/curves/nist.js';
import { ed25519 } from '@noble/curves/ed25519.js';
import { ed448 } from '@noble/curves/ed448.js';
import { brainpoolP256r1, brainpoolP384r1, brainpoolP512r1 } from '@noble/curves/misc.js';
for (const curve of [
  secp256k1, schnorr,
  p256, p384, p521,
  ed25519, ed448,
  brainpoolP256r1, brainpoolP384r1, brainpoolP512r1
]) {
  const { secretKey, publicKey } = curve.keygen();
  const msg = new TextEncoder().encode('hello noble');
  const sig = curve.sign(msg, secretKey);
  const isValid = curve.verify(sig, msg, publicKey);
  console.log(curve, secretKey, publicKey, sig, isValid);
}

// Specific private key
import { hexToBytes } from '@noble/curves/utils.js';
const secret2 = hexToBytes('46c930bc7bb4db7f55da20798697421b98c4175a52c630294d75a84b9c126236');
const pub2 = secp256k1.getPublicKey(secret2);

Les messages sont toujours hachés d'abord : voir signature pré-hachée. ECDSA utilise un k déterministe, EdDSA suit la RFC 8032, Schnorr (secp256k1 uniquement) suit le BIP 340 : voir Spécifications.

Le schéma de signature MuSig2 et le mapping ElligatorSwift BIP324 pour secp256k1 sont disponibles dans un package séparé.

ristretto255, decaf448```ts

import { ristretto255, ristretto255_hasher, ristretto255_oprf } from '@noble/curves/ed25519.js'; import { decaf448, decaf448_hasher, decaf448_oprf } from '@noble/curves/ed448.js';

console.log(ristretto255.Point, decaf448.Point);

Consultez la [RFC 9496](https://www.rfc-editor.org/rfc/rfc9496) pour plus d'informations sur ristretto255 et decaf448.
Consultez la documentation séparée pour [Point](#elliptic-curve-point-math), [hasher](#hash-to-curve-hashing-to-curve-points) et [oprf](#oprfs).

#### Signature pré-hachée```js
import { secp256k1 } from '@noble/curves/secp256k1.js';
import { keccak_256 } from '@noble/hashes/sha3.js';
const { secretKey } = secp256k1.keygen();
const msg = new TextEncoder().encode('hello noble');
// prehash: true (default) - hash using secp256k1.hash (sha256)
const sig = secp256k1.sign(msg, secretKey);
// prehash: false - hash using custom hash
const sigKeccak = secp256k1.sign(keccak_256(msg), secretKey, { prehash: false });

Par défaut (prehash: true), sign() et verify() appliquent d'abord le hachage intégré de la courbe au message : sha256 pour secp256k1, sha512 pour p521. prehash: false permet d'utiliser un hachage personnalisé (par exemple secp256k1 + keccak_256). Dans noble-curves v1, prehash: false était la valeur par défaut.

Récupération des clés publiques à partir des signatures```js

import { secp256k1 } from '@noble/curves/secp256k1.js'; const { secretKey, publicKey } = secp256k1.keygen(); const msg = new TextEncoder().encode('hello noble'); const sigRec = secp256k1.sign(msg, secretKey, { format: 'recovered' }); const publicKey_ = secp256k1.recoverPublicKey(sigRec, msg); // == publicKey

// recovered sig is compact sig with an extra byte const sigNoRec = secp256k1.sign(msg, secretKey, { format: 'compact' }); // sigNoRec == sigRec.slice(1)

// Signature instance const sigInstance = secp256k1.Signature.fromBytes(sigRec, 'recovered');

La récupération de clé publique n'est prise en charge qu'avec ECDSA. Il s'agit d'une simple opération mathématique :
aucune garantie n'existe que la signature a réellement été effectuée. Un triplet (r, s, h) falsifié donne une clé publique aléatoire, mais il n'est pas réalisable de trouver m qui conduirait à ce h falsifié spécifique.