CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-elliptic

Fast elliptic curve cryptography in plain JavaScript for ECDSA, EdDSA, and ECDH operations

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview
Eval results
Files

curves.mddocs/

Curve Management

Access to predefined elliptic curves and curve operations, supporting multiple curve types with optimized implementations for Short Weierstrass, Montgomery, Edwards, and Twisted Edwards curves.

Capabilities

Predefined Curves Access

Access to built-in elliptic curve configurations with optimized parameters.

const curves = require('elliptic').curves;

// NIST standard curves
curves.p192;
curves.p224;
curves.p256;
curves.p384;
curves.p521;

// Bitcoin curve with endomorphism optimization
curves.secp256k1;

// Curve25519 family
curves.curve25519;  // Montgomery curve for ECDH
curves.ed25519;     // Edwards curve for EdDSA

Usage Examples:

const elliptic = require('elliptic');
const curves = elliptic.curves;

// Access curve configurations
console.log('secp256k1 prime:', curves.secp256k1.curve.p.toString(16));
console.log('P-256 generator:', curves.p256.g);

// Use with EC constructor
const EC = elliptic.ec;
const ec1 = new EC(curves.secp256k1);
const ec2 = new EC('secp256k1'); // Equivalent

PresetCurve Class

Class representing a configured elliptic curve with all necessary parameters.

/**
 * Create curve instance with parameters
 * @param options - Curve configuration options
 * @returns PresetCurve instance
 */
function PresetCurve(options);

Curve Types and Characteristics

Short Weierstrass Curves

Standard elliptic curves in the form: y² = x³ + ax + b

// Short Weierstrass curves
const shortCurves = {
  p192: curves.p192,     // NIST P-192 (secp192r1)
  p224: curves.p224,     // NIST P-224 (secp224r1) 
  p256: curves.p256,     // NIST P-256 (secp256r1, prime256v1)
  p384: curves.p384,     // NIST P-384 (secp384r1)
  p521: curves.p521,     // NIST P-521 (secp521r1)
  secp256k1: curves.secp256k1  // Bitcoin curve with endomorphism
};

Characteristics:

  • p192, p224, p256, p384, p521: NIST standard curves for general cryptographic use
  • secp256k1: Bitcoin curve with Koblitz endomorphism for optimization

Montgomery Curves

Curves optimized for ECDH key exchange in the form: By² = x³ + Ax² + x

// Montgomery curves
const montgomeryCurves = {
  curve25519: curves.curve25519  // Optimized for ECDH
};

Characteristics:

  • curve25519: High-performance ECDH operations, constant-time implementation
  • Optimized for key agreement protocols
  • Not suitable for ECDSA (use corresponding Edwards curve)

Edwards Curves

Curves optimized for EdDSA in the form: x² + y² = 1 + dx²y²

// Edwards curves
const edwardsCurves = {
  ed25519: curves.ed25519  // Optimized for EdDSA signatures
};

Characteristics:

  • ed25519: High-performance EdDSA signatures, birationally equivalent to curve25519
  • Deterministic signatures
  • Resistant to side-channel attacks

Curve Properties

Each curve provides access to mathematical parameters and properties.

// Curve properties
curve.curve;    // Underlying curve implementation
curve.g;        // Generator point
curve.n;        // Order of the generator point
curve.hash;     // Associated hash function

Usage Examples:

const curves = require('elliptic').curves;

// Examine secp256k1 properties
const secp256k1 = curves.secp256k1;
console.log('Generator point:', secp256k1.g.toString());
console.log('Curve order:', secp256k1.n.toString(16));
console.log('Hash function:', secp256k1.hash);

// Check curve type
console.log('Curve type:', secp256k1.curve.type); // 'short'

// Access curve parameters
const curve = secp256k1.curve;
console.log('Prime field:', curve.p.toString(16));
console.log('Curve parameter a:', curve.a.toString(16));
console.log('Curve parameter b:', curve.b.toString(16));

Curve Security Levels

Security strength of supported curves in approximate bits:

const securityLevels = {
  p192: 96,        // ~96-bit security
  secp256k1: 128,  // ~128-bit security  
  p256: 128,       // ~128-bit security
  curve25519: 128, // ~128-bit security
  ed25519: 128,    // ~128-bit security
  p384: 192,       // ~192-bit security
  p521: 256        // ~256-bit security
};

Curve Selection Guidelines

For ECDSA Digital Signatures

// Modern applications
const ec = new (require('elliptic').ec)('p256');

// Bitcoin and cryptocurrency
const ec = new (require('elliptic').ec)('secp256k1');

// High security requirements
const ec = new (require('elliptic').ec)('p384');

For EdDSA Digital Signatures

// Modern applications (recommended)
const eddsa = new (require('elliptic').eddsa)('ed25519');

For ECDH Key Agreement

// Modern applications (recommended)
const ec = new (require('elliptic').ec)('curve25519');

// NIST compatibility
const ec = new (require('elliptic').ec)('p256');

Performance Characteristics

Relative performance of different curves:

Fastest to Slowest (typical):

  1. curve25519 - Optimized Montgomery ladder
  2. ed25519 - Optimized Edwards operations
  3. secp256k1 - Endomorphism optimization
  4. p256 - NIST standard implementation
  5. p384, p521 - Larger field sizes

Usage Examples:

const elliptic = require('elliptic');

// Performance-optimized choices
const fastECDH = new elliptic.ec('curve25519');      // Fastest ECDH
const fastEdDSA = new elliptic.eddsa('ed25519');     // Fastest signatures
const fastECDSA = new elliptic.ec('secp256k1');      // Fast ECDSA with endomorphism

// Standard/compatibility choices  
const standardECDSA = new elliptic.ec('p256');       // NIST standard
const highSecECDSA = new elliptic.ec('p384');        // Higher security

Curve Validation

All predefined curves undergo validation during initialization:

// Automatic validation checks
// - Generator point is on the curve
// - Generator point has correct order
// - Curve parameters meet security requirements
// - Mathematical consistency of parameters

Custom Curve Definition

While not commonly needed, curves can be defined with custom parameters:

/**
 * Define custom curve (advanced usage)
 * @param name - Curve identifier
 * @param options - Curve parameters
 */
function defineCurve(name, options);

Note: Use predefined curves unless you have specific requirements and deep cryptographic expertise.

Interoperability

Standard Compatibility

  • NIST Curves: Full compatibility with FIPS 186-4
  • secp256k1: Bitcoin and cryptocurrency ecosystem
  • Curve25519/Ed25519: Modern cryptographic standards (RFC 7748, RFC 8032)

Cross-Platform Support

All curves work consistently across:

  • Browser environments (pure JavaScript)
  • Node.js applications
  • Different JavaScript engines
  • Various operating systems

Security Considerations

Curve Choice Impact

Recommended Modern Curves:

  • ed25519: EdDSA signatures (preferred for new applications)
  • curve25519: ECDH key agreement (preferred for new applications)
  • p256: ECDSA when NIST compliance required

Legacy/Specialized Curves:

  • secp256k1: Bitcoin and cryptocurrency applications
  • p384, p521: High security requirements or compliance needs

Validation Requirements

Always use the predefined curve configurations rather than manual parameter specification to ensure:

  • Cryptographically secure parameters
  • Resistance to known attacks
  • Proper mathematical structure
  • Performance optimizations

Install with Tessl CLI

npx tessl i tessl/npm-elliptic

docs

curves.md

ecdsa.md

eddsa.md

index.md

utils.md

tile.json