noble-curves

अंडरटेक किए गए और न्यूनतम एलिप्टिक कर्व क्रिप्टोग्राफी का JS कार्यान्वयन।

• 🔒 स्वतंत्र सुरक्षा फर्मों द्वारा ऑडिट किया गया
• 🪶 न्यूनतम: 15KB (gzipped) secp256k1, अप्रयुक्त कोड आपके बिल्ड से बाहर रखा जाता है
• 🏎 तेज़: JS इंजन की बारीकियों के लिए हाथ से अनुकूलित
• 🔍 विश्वसनीय: क्रॉस-लाइब्रेरी / wycheproof परीक्षण शुद्धता सुनिश्चित करते हैं
• ➰ Weierstrass, Edwards कर्व्स; ECDSA, EdDSA, Schnorr, BLS हस्ताक्षर
• ✍️ ECDH, hash-to-curve, OPRF, FROST, Poseidon hash, FFT
• 🔖 ed25519, ed448 में गैर-अस्वीकृति (SUF-CMA, SBS) और सर्वसम्मति-अनुकूलता (ZIP215)
• 🥈 मूल WebCrypto पर समान API वाला रैपर

कर्व्स के 5kb सिस्टर प्रोजेक्ट हैं secp256k1 और ed25519। इनका हमले का क्षेत्र छोटा है, लेकिन सुविधाएँ कम हैं।

यह लाइब्रेरी noble क्रिप्टोग्राफी से संबंधित है

noble cryptography — उच्च-सुरक्षा, आसानी से ऑडिट किए जा सकने वाले संयमित क्रिप्टोग्राफिक लाइब्रेरीज़ और टूल्स का सेट।

• शून्य या न्यूनतम निर्भरताएँ
• अत्यधिक पठनीय TypeScript / JS कोड
• PGP-हस्ताक्षरित रिलीज़ और पारदर्शी NPM बिल्ड
• सभी लाइब्रेरीज़: ciphers, curves, hashes, post-quantum, 5kb secp256k1 / ed25519
• WASM संस्करण: awasm-noble
• पठन संसाधनों, दस्तावेज़ीकरण और noble से बने ऐप्स के लिए होमपेज देखें

उपयोग

npm install @noble/curves

deno add jsr:@noble/curves

हम सभी प्रमुख प्लेटफ़ॉर्म और रनटाइम का समर्थन करते हैं। React Native के लिए, आपको getRandomValues के लिए पॉलीफ़िल की आवश्यकता हो सकती है। एक स्टैंडअलोन फ़ाइल noble-curves.js भी उपलब्ध है।```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 हस्ताक्षर](#ecdsa-eddsa-schnorr-signatures)
- [ECDH: Diffie-Hellman साझा रहस्य](#ecdh-diffie-hellman-shared-secrets)
- [webcrypto: अनुकूल रैपर](#webcrypto-friendly-wrapper)
- [BLS हस्ताक्षर, bls12-381, bn254 उर्फ alt\_bn128](#bls-signatures-bls12-381-bn254-aka-alt_bn128)
- [hash-to-curve: वक्र बिंदुओं पर हैशिंग](#hash-to-curve-hashing-to-curve-points)
- [OPRFs](#oprfs) | [FROST थ्रेशोल्ड हस्ताक्षर](#frost-threshold-signatures)
- [poseidon: Poseidon हैश](#poseidon-poseidon-hash) | [fft: फास्ट फूरियर ट्रांसफॉर्म](#fft-fast-fourier-transform) | [utils](#utils-byte-shuffling-conversion)
- आंतरिक: [बिंदु गणित](#elliptic-curve-point-math) | [मॉड्यूलर](#modular-modular-arithmetics--finite-fields) | [कस्टम वक्र](#weierstrass-custom-weierstrass-curve--ecdsa)
- [विनिर्देश](#specs)
- [सुरक्षा](#security) | [गति](#speed) | [अपग्रेड करना](#upgrading) | [योगदान और परीक्षण](#contributing--testing) | [लाइसेंस](#license)

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

Messages को हमेशा पहले hash किया जाता है: देखें prehashed signing। ECDSA deterministic k का उपयोग करता है, EdDSA RFC 8032 का पालन करता है, Schnorr (केवल secp256k1) BIP 340 का पालन करता है: देखें Specs।

MuSig2 signature scheme और secp256k1 के लिए BIP324 ElligatorSwift mapping एक अलग package में उपलब्ध हैं।

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

[RFC 9496](https://www.rfc-editor.org/rfc/rfc9496) पर ristretto255 और decaf448 के बारे में अधिक जानकारी देखें।
[Point](#elliptic-curve-point-math), [hasher](#hash-to-curve-hashing-to-curve-points) और [oprf](#oprfs) के लिए अलग दस्तावेज़ देखें।

#### Prehashed signing```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 });

डिफ़ॉल्ट रूप से (prehash: true), sign() और verify() पहले संदेश पर curve के अंतर्निहित hash को लागू करते हैं: secp256k1 के लिए sha256, p521 के लिए sha512। prehash: false एक कस्टम hash का उपयोग करने की अनुमति देता है (जैसे secp256k1 + keccak_256)। noble-curves v1 में, prehash: false डिफ़ॉल्ट था।

हस्ताक्षरों से सार्वजनिक कुंजियाँ पुनर्प्राप्त करना```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 recovery केवल ECDSA के साथ समर्थित है। यह एक सरल गणितीय संक्रिया है:
इस बात की कोई गारंटी नहीं है कि हस्ताक्षर वास्तव में किया गया था। एक जाली (r, s, h) एक
यादृच्छिक सार्वजनिक कुंजी में परिवर्तित हो जाता है, लेकिन ऐसा m खोजना संभव नहीं है जो इस विशिष्ट जाली h की ओर ले जाए।