@libp2p/crypto 0.0.0 → 0.22.3

package/src/keys/ecdh.ts

@@ -0,0 +1,33 @@
+import crypto from 'crypto'
+import errcode from 'err-code'
+import type { ECDHKey, ECDHKeyPair } from './interface.js'
+
+const curves = {
+  'P-256': 'prime256v1',
+  'P-384': 'secp384r1',
+  'P-521': 'secp521r1'
+}
+
+const curveTypes = Object.keys(curves)
+const names = curveTypes.join(' / ')
+
+export async function generateEphmeralKeyPair (curve: string): Promise<ECDHKey> { // eslint-disable-line require-await
+  if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
+    throw errcode(new Error(`Unknown curve: ${curve}. Must be ${names}`), 'ERR_INVALID_CURVE')
+  }
+
+  const ecdh = crypto.createECDH(curves[curve])
+  ecdh.generateKeys()
+
+  return {
+    key: ecdh.getPublicKey() as Uint8Array,
+
+    async genSharedKey (theirPub: Uint8Array, forcePrivate?: ECDHKeyPair): Promise<Uint8Array> { // eslint-disable-line require-await
+      if (forcePrivate != null) {
+        ecdh.setPrivateKey(forcePrivate.private)
+      }
+
+      return ecdh.computeSecret(theirPub)
+    }
+  }
+}

package/src/keys/ed25519-class.ts

@@ -0,0 +1,145 @@
+import errcode from 'err-code'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { base58btc } from 'multiformats/bases/base58'
+import { identity } from 'multiformats/hashes/identity'
+import * as crypto from './ed25519.js'
+import * as pbm from './keys.js'
+import { exporter } from './exporter.js'
+
+export class Ed25519PublicKey {
+  private readonly _key: Uint8Array
+
+  constructor (key: Uint8Array) {
+    this._key = ensureKey(key, crypto.publicKeyLength)
+  }
+
+  async verify (data: Uint8Array, sig: Uint8Array) { // eslint-disable-line require-await
+    return await crypto.hashAndVerify(this._key, sig, data)
+  }
+
+  marshal () {
+    return this._key
+  }
+
+  get bytes () {
+    return pbm.PublicKey.encode({
+      Type: pbm.KeyType.Ed25519,
+      Data: this.marshal()
+    }).finish()
+  }
+
+  equals (key: any) {
+    return uint8ArrayEquals(this.bytes, key.bytes)
+  }
+
+  async hash () {
+    const { bytes } = await sha256.digest(this.bytes)
+
+    return bytes
+  }
+}
+
+export class Ed25519PrivateKey {
+  private readonly _key: Uint8Array
+  private readonly _publicKey: Uint8Array
+
+  // key       - 64 byte Uint8Array containing private key
+  // publicKey - 32 byte Uint8Array containing public key
+  constructor (key: Uint8Array, publicKey: Uint8Array) {
+    this._key = ensureKey(key, crypto.privateKeyLength)
+    this._publicKey = ensureKey(publicKey, crypto.publicKeyLength)
+  }
+
+  async sign (message: Uint8Array) { // eslint-disable-line require-await
+    return await crypto.hashAndSign(this._key, message)
+  }
+
+  get public () {
+    return new Ed25519PublicKey(this._publicKey)
+  }
+
+  marshal () {
+    return this._key
+  }
+
+  get bytes () {
+    return pbm.PrivateKey.encode({
+      Type: pbm.KeyType.Ed25519,
+      Data: this.marshal()
+    }).finish()
+  }
+
+  equals (key: any) {
+    return uint8ArrayEquals(this.bytes, key.bytes)
+  }
+
+  async hash () {
+    const { bytes } = await sha256.digest(this.bytes)
+
+    return bytes
+  }
+
+  /**
+   * Gets the ID of the key.
+   *
+   * The key id is the base58 encoding of the identity multihash containing its public key.
+   * The public key is a protobuf encoding containing a type and the DER encoding
+   * of the PKCS SubjectPublicKeyInfo.
+   *
+   * @returns {Promise<string>}
+   */
+  async id () {
+    const encoding = await identity.digest(this.public.bytes)
+    return base58btc.encode(encoding.bytes).substring(1)
+  }
+
+  /**
+   * Exports the key into a password protected `format`
+   */
+  async export (password: string, format = 'libp2p-key') { // eslint-disable-line require-await
+    if (format === 'libp2p-key') {
+      return await exporter(this.bytes, password)
+    } else {
+      throw errcode(new Error(`export format '${format}' is not supported`), 'ERR_INVALID_EXPORT_FORMAT')
+    }
+  }
+}
+
+export function unmarshalEd25519PrivateKey (bytes: Uint8Array) {
+  // Try the old, redundant public key version
+  if (bytes.length > crypto.privateKeyLength) {
+    bytes = ensureKey(bytes, crypto.privateKeyLength + crypto.publicKeyLength)
+    const privateKeyBytes = bytes.slice(0, crypto.privateKeyLength)
+    const publicKeyBytes = bytes.slice(crypto.privateKeyLength, bytes.length)
+    return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes)
+  }
+
+  bytes = ensureKey(bytes, crypto.privateKeyLength)
+  const privateKeyBytes = bytes.slice(0, crypto.privateKeyLength)
+  const publicKeyBytes = bytes.slice(crypto.publicKeyLength)
+  return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes)
+}
+
+export function unmarshalEd25519PublicKey (bytes: Uint8Array) {
+  bytes = ensureKey(bytes, crypto.publicKeyLength)
+  return new Ed25519PublicKey(bytes)
+}
+
+export async function generateKeyPair () {
+  const { privateKey, publicKey } = await crypto.generateKey()
+  return new Ed25519PrivateKey(privateKey, publicKey)
+}
+
+export async function generateKeyPairFromSeed (seed: Uint8Array) {
+  const { privateKey, publicKey } = await crypto.generateKeyFromSeed(seed)
+  return new Ed25519PrivateKey(privateKey, publicKey)
+}
+
+function ensureKey (key: Uint8Array, length: number) {
+  key = Uint8Array.from(key ?? [])
+  if (key.length !== length) {
+    throw errcode(new Error(`Key must be a Uint8Array of length ${length}, got ${key.length}`), 'ERR_INVALID_KEY_TYPE')
+  }
+  return key
+}

package/src/keys/ed25519.ts

@@ -0,0 +1,63 @@
+import * as ed from '@noble/ed25519'
+
+const PUBLIC_KEY_BYTE_LENGTH = 32
+const PRIVATE_KEY_BYTE_LENGTH = 64 // private key is actually 32 bytes but for historical reasons we concat private and public keys
+const KEYS_BYTE_LENGTH = 32
+
+export { PUBLIC_KEY_BYTE_LENGTH as publicKeyLength }
+export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength }
+
+export async function generateKey () {
+  // the actual private key (32 bytes)
+  const privateKeyRaw = ed.utils.randomPrivateKey()
+  const publicKey = await ed.getPublicKey(privateKeyRaw)
+
+  // concatenated the public key to the private key
+  const privateKey = concatKeys(privateKeyRaw, publicKey)
+
+  return {
+    privateKey,
+    publicKey
+  }
+}
+
+/**
+ * Generate keypair from a 32 byte uint8array
+ */
+export async function generateKeyFromSeed (seed: Uint8Array) {
+  if (seed.length !== KEYS_BYTE_LENGTH) {
+    throw new TypeError('"seed" must be 32 bytes in length.')
+  } else if (!(seed instanceof Uint8Array)) {
+    throw new TypeError('"seed" must be a node.js Buffer, or Uint8Array.')
+  }
+
+  // based on node forges algorithm, the seed is used directly as private key
+  const privateKeyRaw = seed
+  const publicKey = await ed.getPublicKey(privateKeyRaw)
+
+  const privateKey = concatKeys(privateKeyRaw, publicKey)
+
+  return {
+    privateKey,
+    publicKey
+  }
+}
+
+export async function hashAndSign (privateKey: Uint8Array, msg: Uint8Array) {
+  const privateKeyRaw = privateKey.slice(0, KEYS_BYTE_LENGTH)
+
+  return await ed.sign(msg, privateKeyRaw)
+}
+
+export async function hashAndVerify (publicKey: Uint8Array, sig: Uint8Array, msg: Uint8Array) {
+  return await ed.verify(sig, msg, publicKey)
+}
+
+function concatKeys (privateKeyRaw: Uint8Array, publicKey: Uint8Array) {
+  const privateKey = new Uint8Array(PRIVATE_KEY_BYTE_LENGTH)
+  for (let i = 0; i < KEYS_BYTE_LENGTH; i++) {
+    privateKey[i] = privateKeyRaw[i]
+    privateKey[KEYS_BYTE_LENGTH + i] = publicKey[i]
+  }
+  return privateKey
+}

package/src/keys/ephemeral-keys.ts

@@ -0,0 +1,9 @@
+import { generateEphmeralKeyPair } from './ecdh.js'
+
+/**
+ * Generates an ephemeral public key and returns a function that will compute
+ * the shared secret key.
+ *
+ * Focuses only on ECDH now, but can be made more general in the future.
+ */
+export default generateEphmeralKeyPair

package/src/keys/exporter.ts

@@ -0,0 +1,13 @@
+import { base64 } from 'multiformats/bases/base64'
+import * as ciphers from '../ciphers/aes-gcm.js'
+
+/**
+ * Exports the given PrivateKey as a base64 encoded string.
+ * The PrivateKey is encrypted via a password derived PBKDF2 key
+ * leveraging the aes-gcm cipher algorithm.
+ */
+export async function exporter (privateKey: Uint8Array, password: string) {
+  const cipher = ciphers.create()
+  const encryptedKey = await cipher.encrypt(privateKey, password)
+  return base64.encode(encryptedKey)
+}

package/src/keys/importer.ts

@@ -0,0 +1,13 @@
+import { base64 } from 'multiformats/bases/base64'
+import * as ciphers from '../ciphers/aes-gcm.js'
+
+/**
+ * Attempts to decrypt a base64 encoded PrivateKey string
+ * with the given password. The privateKey must have been exported
+ * using the same password and underlying cipher (aes-gcm)
+ */
+export async function importer (privateKey: string, password: string) {
+  const encryptedKey = base64.decode(privateKey)
+  const cipher = ciphers.create()
+  return await cipher.decrypt(encryptedKey, password)
+}

package/src/keys/index.ts

@@ -0,0 +1,126 @@
+import * as keysPBM from './keys.js'
+import 'node-forge/lib/asn1.js'
+import 'node-forge/lib/pbe.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import errcode from 'err-code'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { keyStretcher } from './key-stretcher.js'
+import generateEphemeralKeyPair from './ephemeral-keys.js'
+import { importer } from './importer.js'
+import * as RSA from './rsa-class.js'
+import * as Ed25519 from './ed25519-class.js'
+import * as Secp256k1 from './secp256k1-class.js'
+
+export { keyStretcher }
+export { generateEphemeralKeyPair }
+export { keysPBM }
+
+export const supportedKeys = {
+  rsa: RSA,
+  ed25519: Ed25519,
+  secp256k1: Secp256k1
+}
+
+function unsupportedKey (type: string) {
+  const supported = Object.keys(supportedKeys).join(' / ')
+  return errcode(new Error(`invalid or unsupported key type ${type}. Must be ${supported}`), 'ERR_UNSUPPORTED_KEY_TYPE')
+}
+
+function typeToKey (type: string) {
+  type = type.toLowerCase()
+
+  if (type === 'rsa' || type === 'ed25519' || type === 'secp256k1') {
+    return supportedKeys[type]
+  }
+
+  throw unsupportedKey(type)
+}
+
+// Generates a keypair of the given type and bitsize
+export async function generateKeyPair (type: 'RSA' | 'Ed25519' | 'secp256k1', bits?: number) { // eslint-disable-line require-await
+  return await typeToKey(type).generateKeyPair(bits ?? 2048)
+}
+
+// Generates a keypair of the given type and bitsize
+// seed is a 32 byte uint8array
+export async function generateKeyPairFromSeed (type: 'RSA' | 'Ed25519' | 'secp256k1', seed: Uint8Array, bits?: number) { // eslint-disable-line require-await
+  if (type.toLowerCase() !== 'ed25519') {
+    throw errcode(new Error('Seed key derivation is unimplemented for RSA or secp256k1'), 'ERR_UNSUPPORTED_KEY_DERIVATION_TYPE')
+  }
+
+  return await Ed25519.generateKeyPairFromSeed(seed)
+}
+
+// Converts a protobuf serialized public key into its
+// representative object
+export function unmarshalPublicKey (buf: Uint8Array) {
+  const decoded = keysPBM.PublicKey.decode(buf)
+  const data = decoded.Data
+
+  switch (decoded.Type) {
+    case keysPBM.KeyType.RSA:
+      return supportedKeys.rsa.unmarshalRsaPublicKey(data)
+    case keysPBM.KeyType.Ed25519:
+      return supportedKeys.ed25519.unmarshalEd25519PublicKey(data)
+    case keysPBM.KeyType.Secp256k1:
+      return supportedKeys.secp256k1.unmarshalSecp256k1PublicKey(data)
+    default:
+      throw unsupportedKey(decoded.Type)
+  }
+}
+
+// Converts a public key object into a protobuf serialized public key
+export function marshalPublicKey (key: { bytes: Uint8Array }, type?: string) {
+  type = (type ?? 'rsa').toLowerCase()
+  typeToKey(type) // check type
+  return key.bytes
+}
+
+// Converts a protobuf serialized private key into its
+// representative object
+export async function unmarshalPrivateKey (buf: Uint8Array) { // eslint-disable-line require-await
+  const decoded = keysPBM.PrivateKey.decode(buf)
+  const data = decoded.Data
+
+  switch (decoded.Type) {
+    case keysPBM.KeyType.RSA:
+      return await supportedKeys.rsa.unmarshalRsaPrivateKey(data)
+    case keysPBM.KeyType.Ed25519:
+      return supportedKeys.ed25519.unmarshalEd25519PrivateKey(data)
+    case keysPBM.KeyType.Secp256k1:
+      return supportedKeys.secp256k1.unmarshalSecp256k1PrivateKey(data)
+    default:
+      throw unsupportedKey(decoded.Type)
+  }
+}
+
+// Converts a private key object into a protobuf serialized private key
+export function marshalPrivateKey (key: { bytes: Uint8Array }, type?: string) {
+  type = (type ?? 'rsa').toLowerCase()
+  typeToKey(type) // check type
+  return key.bytes
+}
+
+/**
+ *
+ * @param {string} encryptedKey
+ * @param {string} password
+ */
+export async function importKey (encryptedKey: string, password: string) { // eslint-disable-line require-await
+  try {
+    const key = await importer(encryptedKey, password)
+    return await unmarshalPrivateKey(key)
+  } catch (_) {
+    // Ignore and try the old pem decrypt
+  }
+
+  // Only rsa supports pem right now
+  const key = forge.pki.decryptRsaPrivateKey(encryptedKey, password)
+  if (key === null) {
+    throw errcode(new Error('Cannot read the key, most likely the password is wrong or not a RSA key'), 'ERR_CANNOT_DECRYPT_PEM')
+  }
+  let der = forge.asn1.toDer(forge.pki.privateKeyToAsn1(key))
+  der = uint8ArrayFromString(der.getBytes(), 'ascii')
+  return await supportedKeys.rsa.unmarshalRsaPrivateKey(der)
+}

package/src/keys/interface.ts

@@ -0,0 +1,20 @@
+
+export interface JWKKeyPair {
+  privateKey: JsonWebKey
+  publicKey: JsonWebKey
+}
+
+export interface Uint8ArrayKeyPair {
+  privateKey: Uint8Array
+  publicKey: Uint8Array
+}
+
+export interface ECDHKeyPair {
+  private: Uint8Array
+  public: Uint8Array
+}
+
+export interface ECDHKey {
+  key: Uint8Array
+  genSharedKey: (theirPub: Uint8Array, forcePrivate?: ECDHKeyPair) => Promise<Uint8Array>
+}

package/src/keys/jwk2pem.ts

@@ -0,0 +1,16 @@
+import 'node-forge/lib/rsa.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { base64urlToBigInteger } from '../util'
+
+function convert (key: any, types: string[]) {
+  return types.map(t => base64urlToBigInteger(key[t]))
+}
+
+export function jwk2priv (key: JsonWebKey) {
+  return forge.pki.setRsaPrivateKey(...convert(key, ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi']))
+}
+
+export function jwk2pub (key: JsonWebKey) {
+  return forge.pki.setRsaPublicKey(...convert(key, ['n', 'e']))
+}

package/src/keys/key-stretcher.ts

@@ -0,0 +1,77 @@
+import errcode from 'err-code'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import * as hmac from '../hmac/index.js'
+
+const cipherMap = {
+  'AES-128': {
+    ivSize: 16,
+    keySize: 16
+  },
+  'AES-256': {
+    ivSize: 16,
+    keySize: 32
+  },
+  Blowfish: {
+    ivSize: 8,
+    keySize: 32
+  }
+}
+
+/**
+ * Generates a set of keys for each party by stretching the shared key.
+ * (myIV, theirIV, myCipherKey, theirCipherKey, myMACKey, theirMACKey)
+ */
+export async function keyStretcher (cipherType: 'AES-128' | 'AES-256' | 'Blowfish', hash: 'SHA1' | 'SHA256' | 'SHA512', secret: Uint8Array) {
+  const cipher = cipherMap[cipherType]
+
+  if (cipher == null) {
+    const allowed = Object.keys(cipherMap).join(' / ')
+    throw errcode(new Error(`unknown cipher type '${cipherType}'. Must be ${allowed}`), 'ERR_INVALID_CIPHER_TYPE')
+  }
+
+  if (hash == null) {
+    throw errcode(new Error('missing hash type'), 'ERR_MISSING_HASH_TYPE')
+  }
+
+  const cipherKeySize = cipher.keySize
+  const ivSize = cipher.ivSize
+  const hmacKeySize = 20
+  const seed = uint8ArrayFromString('key expansion')
+  const resultLength = 2 * (ivSize + cipherKeySize + hmacKeySize)
+
+  const m = await hmac.create(hash, secret)
+  let a = await m.digest(seed)
+
+  const result = []
+  let j = 0
+
+  while (j < resultLength) {
+    const b = await m.digest(uint8ArrayConcat([a, seed]))
+    let todo = b.length
+
+    if (j + todo > resultLength) {
+      todo = resultLength - j
+    }
+
+    result.push(b)
+    j += todo
+    a = await m.digest(a)
+  }
+
+  const half = resultLength / 2
+  const resultBuffer = uint8ArrayConcat(result)
+  const r1 = resultBuffer.slice(0, half)
+  const r2 = resultBuffer.slice(half, resultLength)
+
+  const createKey = (res: Uint8Array) => ({
+    iv: res.slice(0, ivSize),
+    cipherKey: res.slice(ivSize, ivSize + cipherKeySize),
+    macKey: res.slice(ivSize + cipherKeySize)
+  })
+
+  return {
+    k1: createKey(r1),
+    k2: createKey(r2)
+  }
+}

package/src/keys/keys.d.ts

@@ -0,0 +1,146 @@
+import $protobuf from 'protobufjs'
+
+/** KeyType enum. */
+export enum KeyType {
+  RSA = 0,
+  Ed25519 = 1,
+  Secp256k1 = 2
+}
+
+export interface IPublicKey {
+
+  /** PublicKey Type. */
+  Type: KeyType
+
+  /** PublicKey Data. */
+  Data: Uint8Array
+}
+
+/** Represents a PublicKey. */
+export class PublicKey implements IPublicKey {
+  /**
+   * Constructs a new PublicKey.
+   *
+   * @param [p] - Properties to set
+   */
+  constructor (p?: IPublicKey);
+
+  /** PublicKey Type. */
+  public Type: KeyType
+
+  /** PublicKey Data. */
+  public Data: Uint8Array
+
+  /**
+   * Encodes the specified PublicKey message. Does not implicitly {@link PublicKey.verify|verify} messages.
+   *
+   * @param m - PublicKey message or plain object to encode
+   * @param [w] - Writer to encode to
+   * @returns Writer
+   */
+  public static encode (m: IPublicKey, w?: $protobuf.Writer): $protobuf.Writer;
+
+  /**
+   * Decodes a PublicKey message from the specified reader or buffer.
+   *
+   * @param r - Reader or buffer to decode from
+   * @param [l] - Message length if known beforehand
+   * @returns PublicKey
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  public static decode (r: ($protobuf.Reader|Uint8Array), l?: number): PublicKey;
+
+  /**
+   * Creates a PublicKey message from a plain object. Also converts values to their respective internal types.
+   *
+   * @param d - Plain object
+   * @returns PublicKey
+   */
+  public static fromObject (d: { [k: string]: any }): PublicKey;
+
+  /**
+   * Creates a plain object from a PublicKey message. Also converts values to other types if specified.
+   *
+   * @param m - PublicKey
+   * @param [o] - Conversion options
+   * @returns Plain object
+   */
+  public static toObject (m: PublicKey, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+  /**
+   * Converts this PublicKey to JSON.
+   *
+   * @returns JSON object
+   */
+  public toJSON (): { [k: string]: any };
+}
+
+export interface IPrivateKey {
+
+  /** PrivateKey Type. */
+  Type: KeyType
+
+  /** PrivateKey Data. */
+  Data: Uint8Array
+}
+
+/** Represents a PrivateKey. */
+export class PrivateKey implements IPrivateKey {
+  /**
+   * Constructs a new PrivateKey.
+   *
+   * @param [p] - Properties to set
+   */
+  constructor (p?: IPrivateKey);
+
+  /** PrivateKey Type. */
+  public Type: KeyType
+
+  /** PrivateKey Data. */
+  public Data: Uint8Array
+
+  /**
+   * Encodes the specified PrivateKey message. Does not implicitly {@link PrivateKey.verify|verify} messages.
+   *
+   * @param m - PrivateKey message or plain object to encode
+   * @param [w] - Writer to encode to
+   * @returns Writer
+   */
+  public static encode (m: IPrivateKey, w?: $protobuf.Writer): $protobuf.Writer;
+
+  /**
+   * Decodes a PrivateKey message from the specified reader or buffer.
+   *
+   * @param r - Reader or buffer to decode from
+   * @param [l] - Message length if known beforehand
+   * @returns PrivateKey
+   * @throws {Error} If the payload is not a reader or valid buffer
+   * @throws {$protobuf.util.ProtocolError} If required fields are missing
+   */
+  public static decode (r: ($protobuf.Reader|Uint8Array), l?: number): PrivateKey;
+
+  /**
+   * Creates a PrivateKey message from a plain object. Also converts values to their respective internal types.
+   *
+   * @param d - Plain object
+   * @returns PrivateKey
+   */
+  public static fromObject (d: { [k: string]: any }): PrivateKey;
+
+  /**
+   * Creates a plain object from a PrivateKey message. Also converts values to other types if specified.
+   *
+   * @param m - PrivateKey
+   * @param [o] - Conversion options
+   * @returns Plain object
+   */
+  public static toObject (m: PrivateKey, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+  /**
+   * Converts this PrivateKey to JSON.
+   *
+   * @returns JSON object
+   */
+  public toJSON (): { [k: string]: any };
+}