Add a fromKeyId() class method.

Cryptographic Key Pair Library for Linked Data (crypto-ld)

A Javascript library for generating and performing common operations on Linked Data cryptographic key pairs.

Background

Supported Key Types (`crypto-ld` versions `4+`)

This library provides general Linked Data cryptographic key generation functionality, but does not support any individual key type by default.

To use it, you must install individual driver libraries for each cryptographic key type. The following libraries are currently supported.

Type	Crypto Suite	Library	Usage
`Ed25519`	Ed25519VerificationKey2020 (recommended), Ed25519VerificationKey2018 (legacy)	`ed25519-verification-key-2020 >=1.0` (recommended), `ed25519-verification-key-2018 >=2.0` (legacy)	Signatures, VCs, zCaps, DIDAuth
`X25519/Curve25519`	X25519KeyAgreementKey2019	`x25519-key-agreement-key-2019 >=4.0`	ECDH key agreement, JWE/CWE encryption with `minimal-cipher`
`Secp256k1`	EcdsaSecp256k1VerificationKey2019	`ecdsa-secp256k1-verification-key-2019`	Signatures, VCs, zCaps, DIDAuth, HD Wallets

Legacy Supported Key Types (`crypto-ld` versions `<=3`)

In the previous version (v3.x) of crypto-ld, the RSA and Ed25519 suites were bundled with crypto-ld (as opposed to residing in standalone packages). For previous usage instructions of bundled RSA, Ed25519 and standalone Curve25519/x25519-key-pair type keys, see the README for crypto-ld v3.9.

Choosing a Key Type

For digital signatures using the jsonld-signatures, signing of Verifiable Credentials using vc-js, authorization capabilities, and DIDAuth operations:

Prefer Ed25519VerificationKey2020 type keys, by default.
Use EcdsaSepc256k1 keys if your use case requires it (for example, if you're developing for a Bitcoin-based or Ethereum-based ledger), or if you require Hierarchical Deterministic (HD) wallet functionality.

For key agreement protocols for encryption operations:

Use Curve25519 with the minimal-cipher library.

Security

As with most security- and cryptography-related tools, the overall security of your system will largely depend on your design decisions.

Install

Node.js 14.0+ is required.

To install locally (for development):

git clone https://github.com/digitalbazaar/crypto-ld.git
cd crypto-ld
npm install

Usage

Installing Support for Key Types

In order to use this library, you will need to import and install driver libraries for key types you'll be working with via the use() method.

To use the library with one or more supported suites:

import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-key-2020';
import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key-2020';

import {CryptoLD} from 'crypto-ld';
const cryptoLd = new CryptoLD();

cryptoLd.use(Ed25519VerificationKey2020);
cryptoLd.use(X25519KeyAgreementKey2020);

const edKeyPair = await cryptoLd.generate({type: 'Ed25519VerificationKey2020'});

Generating a new public/private key pair

To generate a new public/private key pair: cryptoLd.generate(options):

{string} [type] Suite name, required.
{string} [controller] Optional controller URI or DID to initialize the generated key. (This will also init the key id.)
{string} [seed] Optional deterministic seed value (only supported by some key types, such as ed25519) from which to generate the key.

Importing a key pair from storage

To create an instance of a public/private key pair from data imported from storage, use cryptoLd.from():

const serializedKeyPair = { ... };

const keyPair = await cryptoLd.from(serializedKeyPair);

Note that only installed key types are supported, if you try to create a key pair via from() for an unsupported type, an error will be thrown.

Common individual key pair operations

The full range of operations will depend on key type. Here are some common operations supported by all key types.

Exporting the public key only

To export just the public key of a pair - use export():

keyPair.export({publicKey: true});
// ->
{
  type: 'Ed25519VerificationKey2020',
  id: 'did:example:1234#z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3',
  controller: 'did:example:1234',
  publicKeyMultibase: 'zEYJrMxWigf9boyeJMTRN4Ern8DJMoCXaLK77pzQmxVjf'
}

Exporting the full public-private key pair

To export the full key pair, including private key (warning: this should be a carefully considered operation, best left to dedicated Key Management Systems):

keyPair.export({publicKey: true, privateKey: true});
// ->
{
  type: 'Ed25519VerificationKey2020',
  id: 'did:example:1234#z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3',
  controller: 'did:example:1234',
  publicKeyMultibase: 'zEYJrMxWigf9boyeJMTRN4Ern8DJMoCXaLK77pzQmxVjf',
  privateKeyMultibase: 'z4E7Q4neNHwv3pXUNzUjzc6TTYspqn9Aw6vakpRKpbVrCzwKWD4hQDHnxuhfrTaMjnR8BTp9NeUvJiwJoSUM6xHAZ'
}

Generating and verifying key fingerprint

To generate a fingerprint:

keyPair.fingerprint();
// ->
'z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3'

To verify a fingerprint:

keyPair.verifyFingerprint({
  fingerprint: 'z6MkszZtxCmA2Ce4vUV132PCuLQmwnaDD5mw2L23fGNnsiX3'
});
// ->
{ valid: true }

Operations on signature-related key pairs

For key pairs that are related to signature and verification (that extend from the LDVerifierKeyPair class), two additional operations must be supported:

Creating a signer function

In order to perform a cryptographic signature, you need to create a sign function, and then invoke it.

const keyPair = await cryptoLd.generate({type: 'Ed25519VerificationKey2020'});

const {sign} = keyPair.signer();

const data = 'test data to sign';
const signatureValue = await sign({data});

Creating a verifier function

In order to verify a cryptographic signature, you need to create a verify function, and then invoke it (passing it the data to verify, and the signature).

const keyPair = await cryptoLd.generate({type: 'Ed25519VerificationKey2020'});

const {verify} = keyPair.verifier();

const {valid} = await verify({data, signature});

Contribute

See the contribute file!

PRs accepted.

If editing the Readme, please conform to the standard-readme specification.

Commercial Support

Commercial support for this library is available upon request from Digital Bazaar: [email protected]

	if(env.nodejs && require('semver').gte(process.version, '12.0.0')) {
	const bs58 = require('bs58');
	const publicKeyBytes = util.base58Decode({
	decode: bs58.decode,
	keyMaterial: key.publicKeyBase58,
	type: 'public'
	});
	const _publicKey = require('./ed25519PublicKeyNode12');
	// create a Node public key
	const publicKey = _publicKey.create({publicKeyBytes});
	const {verify} = require('crypto');
	return {
	async verify({data, signature}) {
	return verify(
	null, Buffer.from(data.buffer, data.byteOffset, data.length),
	publicKey, signature);
	}
	};
	}
	if(env.nodejs) {
	const sodium = require('sodium-native');
	const bs58 = require('bs58');
	const publicKey = util.base58Decode({
	decode: bs58.decode,
	keyMaterial: key.publicKeyBase58,
	type: 'public'
	});
	return {
	async verify({data, signature}) {
	return sodium.crypto_sign_verify_detached(
	Buffer.from(signature.buffer, signature.byteOffset, signature.length),
	Buffer.from(data.buffer, data.byteOffset, data.length),
	publicKey);
	}
	};
	}

digitalbazaar / crypto-ld Goto Github PK

crypto-ld's Introduction

Cryptographic Key Pair Library for Linked Data (crypto-ld)

Table of Contents

Background

Supported Key Types (crypto-ld versions 4+)

Legacy Supported Key Types (crypto-ld versions <=3)

Choosing a Key Type

Security

Install

Usage

Installing Support for Key Types

Generating a new public/private key pair

Importing a key pair from storage

Common individual key pair operations

Exporting the public key only

Exporting the full public-private key pair

Generating and verifying key fingerprint

Operations on signature-related key pairs

Creating a signer function

Creating a verifier function

Contribute

Commercial Support

License

crypto-ld's People

Contributors

Stargazers

Watchers

Forkers

crypto-ld's Issues

Recommend Projects

Recommend Topics

Recommend Org

Supported Key Types (`crypto-ld` versions `4+`)

Legacy Supported Key Types (`crypto-ld` versions `<=3`)