@toruslabs/eccrypto

What is @toruslabs/eccrypto?

@toruslabs/eccrypto is a JavaScript library that provides elliptic curve cryptography functionalities. It allows developers to perform cryptographic operations such as key generation, encryption, decryption, signing, and verification using elliptic curve algorithms.

What are @toruslabs/eccrypto's main functionalities?

Key Generation

This feature allows you to generate a private key and derive the corresponding public key using elliptic curve cryptography.

const eccrypto = require('@toruslabs/eccrypto');
const privateKey = eccrypto.generatePrivate();
const publicKey = eccrypto.getPublic(privateKey);

Encryption

This feature allows you to encrypt a message using a public key. The encrypted message can only be decrypted by the corresponding private key.

const eccrypto = require('@toruslabs/eccrypto');
const publicKey = Buffer.from('...'); // Replace with actual public key
const message = Buffer.from('Hello, world!');
eccrypto.encrypt(publicKey, message).then(function(encrypted) {
  console.log(encrypted);
});

Decryption

This feature allows you to decrypt a message using a private key. The message must have been encrypted with the corresponding public key.

const eccrypto = require('@toruslabs/eccrypto');
const privateKey = Buffer.from('...'); // Replace with actual private key
eccrypto.decrypt(privateKey, encrypted).then(function(plaintext) {
  console.log(plaintext.toString());
});

Signing

This feature allows you to sign a message using a private key. The signature can be verified by anyone with the corresponding public key.

const eccrypto = require('@toruslabs/eccrypto');
const privateKey = Buffer.from('...'); // Replace with actual private key
const message = Buffer.from('Hello, world!');
eccrypto.sign(privateKey, message).then(function(sig) {
  console.log(sig);
});

Verification

This feature allows you to verify a signature using a public key. It checks if the signature is valid for the given message and public key.

const eccrypto = require('@toruslabs/eccrypto');
const publicKey = Buffer.from('...'); // Replace with actual public key
const message = Buffer.from('Hello, world!');
const signature = Buffer.from('...'); // Replace with actual signature
eccrypto.verify(publicKey, message, signature).then(function() {
  console.log('Signature is valid');
}).catch(function() {
  console.log('Signature is invalid');
});

Other packages similar to @toruslabs/eccrypto

elliptic

Elliptic is a widely used library for elliptic curve cryptography in JavaScript. It provides a comprehensive set of features for working with elliptic curves, including key generation, signing, and verification. Compared to @toruslabs/eccrypto, elliptic offers more flexibility and supports a wider range of elliptic curves.

secp256k1

Secp256k1 is a high-performance library specifically for the secp256k1 elliptic curve, which is used in Bitcoin and other cryptocurrencies. It is optimized for speed and security. While @toruslabs/eccrypto provides a broader set of cryptographic functionalities, secp256k1 is focused on providing efficient operations for the secp256k1 curve.

crypto

The built-in Node.js 'crypto' module provides cryptographic functionalities, including support for elliptic curve operations. While it is not as specialized as @toruslabs/eccrypto, it offers a wide range of cryptographic tools and is suitable for general-purpose cryptographic needs.

README

eccrypto

JavaScript Elliptic curve cryptography library for both browserify and node.

Motivation

There is currently no any isomorphic ECC library which provides ECDSA, ECDH and ECIES for both Node.js and Browser and uses the fastest implementation available (e.g. secp256k1-node is much faster than other libraries but can be used only on Node.js). So eccrypto is an attempt to create one.

Implementation details

With the help of browserify eccrypto provides different implementations for Browser and Node.js with the same API. Because WebCryptoAPI defines asynchronous promise-driven API, implementation for Node needs to use promises too.

• Use Node.js crypto module/library bindings where possible
• Use WebCryptoAPI where possible
• Promise-driven API
• Only secp256k1 curve, only SHA-512 (KDF), HMAC-SHA-256 (HMAC) and AES-256-CBC for ECIES
• Compressed key support

Native crypto API limitations

crypto

ECDH only works in Node 0.11+ (see https://github.com/joyent/node/pull/5854), ECDSA only supports keys in PEM format (see https://github.com/joyent/node/issues/6904) and ECIES is not supported at all.

WebCryptoAPI

ECDSA and ECDH are supported in Chrome only on Windows (see also bug 338883), aren't supported by Firefox (fixed only in 36.0+, see bug 1034854; see also feature matrix) and ECIES is not defined at all in WebCryptoAPI draft. Also WebCryptoAPI currently defines only curves recommended by NIST meaning that secp256k1 (K-256) curve is not supported (see also: [1], [2]).

So we use seck256k1 library in Node for ECDSA, elliptic in Browser for ECDSA and ECDH and implement ECIES manually with the help of native crypto API.

Possible future goals

• Support other curves/KDF/MAC/symmetric encryption schemes

Usage

ECDSA

var crypto = require("crypto");
var eccrypto = require("eccrypto");

// A new random 32-byte private key.
var privateKey = eccrypto.generatePrivate();
// Corresponding uncompressed (65-byte) public key.
var publicKey = eccrypto.getPublic(privateKey);

var str = "message to sign";
// Always hash you message to sign!
var msg = crypto.createHash("sha256").update(str).digest();

eccrypto.sign(privateKey, msg).then(function (sig) {
  console.log("Signature in DER format:", sig);
  eccrypto
    .verify(publicKey, msg, sig)
    .then(function () {
      console.log("Signature is OK");
    })
    .catch(function () {
      console.log("Signature is BAD");
    });
});

ECDH

var eccrypto = require("eccrypto");

var privateKeyA = eccrypto.generatePrivate();
var publicKeyA = eccrypto.getPublic(privateKeyA);
var privateKeyB = eccrypto.generatePrivate();
var publicKeyB = eccrypto.getPublic(privateKeyB);

eccrypto.derive(privateKeyA, publicKeyB).then(function (sharedKey1) {
  eccrypto.derive(privateKeyB, publicKeyA).then(function (sharedKey2) {
    console.log("Both shared keys are equal:", sharedKey1, sharedKey2);
  });
});

ECIES

var eccrypto = require("eccrypto");

var privateKeyA = eccrypto.generatePrivate();
var publicKeyA = eccrypto.getPublic(privateKeyA);
var privateKeyB = eccrypto.generatePrivate();
var publicKeyB = eccrypto.getPublic(privateKeyB);

// Encrypting the message for B.
eccrypto.encrypt(publicKeyB, Buffer.from("msg to b")).then(function (encrypted) {
  // B decrypting the message.
  eccrypto.decrypt(privateKeyB, encrypted).then(function (plaintext) {
    console.log("Message to part B:", plaintext.toString());
  });
});

// Encrypting the message for A.
eccrypto.encrypt(publicKeyA, Buffer.from("msg to a")).then(function (encrypted) {
  // A decrypting the message.
  eccrypto.decrypt(privateKeyA, encrypted).then(function (plaintext) {
    console.log("Message to part A:", plaintext.toString());
  });
});

License

eccrypto - JavaScript Elliptic curve cryptography library

Written in 2014-2015 by Kagami Hiiragi [e-mail]

To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty.

You should have received a copy of the CC0 Public Domain Dedication along with this software. If not, see http://creativecommons.org/publicdomain/zero/1.0/.