noble-curves

Geprüfte & minimale JS-Implementierung der Kryptographie elliptischer Kurven.

• 🔒 Geprüft von unabhängigen Sicherheitsfirmen
• 🪶 Minimal: 15KB (gzipped) secp256k1, ungenutzter Code wird aus deinen Builds ausgeschlossen
• 🏎 Schnell: handoptimiert für die Eigenheiten von JS-Engines
• 🔍 Zuverlässig: Cross-Library- / wycheproof-Tests gewährleisten Korrektheit
• ➰ Weierstrass-, Edwards-Kurven; ECDSA-, EdDSA-, Schnorr-, BLS-Signaturen
• ✍️ ECDH, Hash-to-Curve, OPRF, FROST, Poseidon-Hash, FFT
• 🔖 Nichtabstreitbarkeit (SUF-CMA, SBS) & Konsensfreundlichkeit (ZIP215) in ed25519, ed448
• 🥈 Wrapper mit identischer API über natives WebCrypto

Kurven haben 5kb-Schwesterprojekte secp256k1 & ed25519. Sie haben eine kleinere Angriffsfläche, aber weniger Funktionen.

Diese Bibliothek gehört zur noble-Kryptographie

noble cryptography — hochsichere, leicht prüfbare Sammlung überschaubarer Kryptographie-Bibliotheken und -Werkzeuge.

• Keine oder minimale Abhängigkeiten
• Hochgradig lesbarer TypeScript- / JS-Code
• PGP-signierte Releases und transparente NPM-Builds
• Alle Bibliotheken: ciphers, curves, hashes, post-quantum, 5kb secp256k1 / ed25519
• WASM-Version: awasm-noble
• Schau dir die Homepage an für Lektüre-Ressourcen, Dokumentation und mit noble erstellte Apps

Verwendung

npm install @noble/curves

deno add jsr:@noble/curves

Wir unterstützen alle wichtigen Plattformen und Runtimes. Für React Native benötigst du möglicherweise einen Polyfill für getRandomValues. Eine eigenständige Datei noble-curves.js ist ebenfalls verfügbar.```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);

- [ECDSA-, EdDSA-, Schnorr-Signaturen](#ecdsa-eddsa-schnorr-signatures)
- [ECDH: Diffie-Hellman-Shared-Secrets](#ecdh-diffie-hellman-shared-secrets)
- [webcrypto: benutzerfreundlicher Wrapper](#webcrypto-friendly-wrapper)
- [BLS-Signaturen, bls12-381, bn254 aka alt\_bn128](#bls-signatures-bls12-381-bn254-aka-alt_bn128)
- [hash-to-curve: Hashing auf Kurvenpunkte](#hash-to-curve-hashing-to-curve-points)
- [OPRFs](#oprfs) | [FROST-Schwellenwert-Signaturen](#frost-threshold-signatures)
- [poseidon: Poseidon-Hash](#poseidon-poseidon-hash) | [fft: Schnelle Fourier-Transformation](#fft-fast-fourier-transform) | [utils](#utils-byte-shuffling-conversion)
- Interna: [Punktarithmetik](#elliptic-curve-point-math) | [modular](#modular-modular-arithmetics--finite-fields) | [benutzerdefinierte Kurven](#weierstrass-custom-weierstrass-curve--ecdsa)
- [Spezifikationen](#specs)
- [Sicherheit](#security) | [Geschwindigkeit](#speed) | [Upgrade](#upgrading) | [Mitwirken & Testen](#contributing--testing) | [Lizenz](#license)

### ECDSA-, EdDSA-, Schnorr-Signaturen

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

Nachrichten werden immer zuerst gehasht: siehe prehashed signing. ECDSA verwendet deterministisches k, EdDSA folgt RFC 8032, Schnorr (nur secp256k1) folgt BIP 340: siehe Specs.

MuSig2-Signaturschema und BIP324 ElligatorSwift-Mapping für secp256k1 sind in einem separaten Paket verfügbar.

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

Sieh dir [RFC 9496](https://www.rfc-editor.org/rfc/rfc9496) an für weitere Informationen zu ristretto255 & decaf448.
Sieh dir die separate Dokumentation für [Point](#elliptic-curve-point-math), [hasher](#hash-to-curve-hashing-to-curve-points) und [oprf](#oprfs) an.

#### Vorab gehashtes Signieren```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 });

Standardmäßig (prehash: true) wenden sign() und verify() zuerst den eingebauten Hash der Kurve auf die Nachricht an: sha256 für secp256k1, sha512 für p521. prehash: false ermöglicht die Verwendung eines benutzerdefinierten Hashs (z. B. secp256k1 + keccak_256). In noble-curves v1 war prehash: false der Standard.

Wiederherstellen öffentlicher Schlüssel aus Signaturen```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');

Public-Key-Wiederherstellung wird nur mit ECDSA unterstützt. Es ist eine einfache mathematische Operation:
es gibt keine Garantie, dass die Signierung tatsächlich durchgeführt wurde. Ein gefälschtes (r, s, h) wird in
einen zufälligen öffentlichen Schlüssel wiederhergestellt, aber es ist nicht machbar, m zu finden, das zu diesem spezifischen gefälschten h führen würde.