@libp2p/keychain 4.1.6 → 5.0.0-1210884ed

package/src/utils/export.ts

@@ -0,0 +1,210 @@
+import { randomBytes } from '@libp2p/crypto'
+import { AES_GCM } from '@libp2p/crypto/ciphers'
+import { privateKeyToProtobuf } from '@libp2p/crypto/keys'
+import webcrypto from '@libp2p/crypto/webcrypto'
+import { InvalidParametersError, UnsupportedKeyTypeError } from '@libp2p/interface'
+import { pbkdf2Async } from '@noble/hashes/pbkdf2'
+import { sha512 } from '@noble/hashes/sha512'
+import * as asn1js from 'asn1js'
+import { base64 } from 'multiformats/bases/base64'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { ITERATIONS, KEY_SIZE, SALT_LENGTH } from './constants.js'
+import type { Ed25519PrivateKey, PrivateKey, RSAPrivateKey, Secp256k1PrivateKey } from '@libp2p/interface'
+import type { Multibase } from 'multiformats/bases/interface'
+
+/**
+ * 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): Promise<Multibase<'m'>> {
+  const cipher = AES_GCM.create()
+  const encryptedKey = await cipher.encrypt(privateKey, password)
+  return base64.encode(encryptedKey)
+}
+
+export type ExportFormat = 'pkcs-8' | 'libp2p-key'
+
+/**
+ * Converts an exported private key into its representative object.
+ *
+ * Supported formats are 'pem' (RSA only) and 'libp2p-key'.
+ */
+export async function exportPrivateKey (key: PrivateKey, password: string, format?: ExportFormat): Promise<Multibase<'m'>> {
+  if (key.type === 'RSA') {
+    return exportRSAPrivateKey(key, password, format)
+  }
+
+  if (key.type === 'Ed25519') {
+    return exportEd25519PrivateKey(key, password, format)
+  }
+
+  if (key.type === 'secp256k1') {
+    return exportSecp256k1PrivateKey(key, password, format)
+  }
+
+  throw new UnsupportedKeyTypeError()
+}
+
+/**
+ * Exports the key into a password protected `format`
+ */
+export async function exportEd25519PrivateKey (key: Ed25519PrivateKey, password: string, format: ExportFormat = 'libp2p-key'): Promise<Multibase<'m'>> {
+  if (format === 'libp2p-key') {
+    return exporter(privateKeyToProtobuf(key), password)
+  } else {
+    throw new InvalidParametersError(`export format '${format}' is not supported`)
+  }
+}
+
+/**
+ * Exports the key into a password protected `format`
+ */
+export async function exportSecp256k1PrivateKey (key: Secp256k1PrivateKey, password: string, format: ExportFormat = 'libp2p-key'): Promise<Multibase<'m'>> {
+  if (format === 'libp2p-key') {
+    return exporter(privateKeyToProtobuf(key), password)
+  } else {
+    throw new InvalidParametersError('Export format is not supported')
+  }
+}
+
+/**
+ * Exports the key as libp2p-key - a aes-gcm encrypted value with the key
+ * derived from the password.
+ *
+ * To export it as a password protected PEM file, please use the `exportPEM`
+ * function from `@libp2p/rsa`.
+ */
+export async function exportRSAPrivateKey (key: RSAPrivateKey, password: string, format: ExportFormat = 'pkcs-8'): Promise<Multibase<'m'>> {
+  if (format === 'pkcs-8') {
+    return exportToPem(key, password)
+  } else if (format === 'libp2p-key') {
+    return exporter(privateKeyToProtobuf(key), password)
+  } else {
+    throw new InvalidParametersError('Export format is not supported')
+  }
+}
+
+export async function exportToPem (privateKey: RSAPrivateKey, password: string): Promise<string> {
+  const crypto = webcrypto.get()
+
+  // PrivateKeyInfo
+  const keyWrapper = new asn1js.Sequence({
+    value: [
+      // version (0)
+      new asn1js.Integer({ value: 0 }),
+
+      // privateKeyAlgorithm
+      new asn1js.Sequence({
+        value: [
+        // rsaEncryption OID
+          new asn1js.ObjectIdentifier({
+            value: '1.2.840.113549.1.1.1'
+          }),
+          new asn1js.Null()
+        ]
+      }),
+
+      // PrivateKey
+      new asn1js.OctetString({
+        valueHex: privateKey.raw
+      })
+    ]
+  })
+
+  const keyBuf = keyWrapper.toBER()
+  const keyArr = new Uint8Array(keyBuf, 0, keyBuf.byteLength)
+  const salt = randomBytes(SALT_LENGTH)
+
+  const encryptionKey = await pbkdf2Async(
+    sha512,
+    password,
+    salt, {
+      c: ITERATIONS,
+      dkLen: KEY_SIZE
+    }
+  )
+
+  const iv = randomBytes(16)
+  const cryptoKey = await crypto.subtle.importKey('raw', encryptionKey, 'AES-CBC', false, ['encrypt'])
+  const encrypted = await crypto.subtle.encrypt({
+    name: 'AES-CBC',
+    iv
+  }, cryptoKey, keyArr)
+
+  const pbkdf2Params = new asn1js.Sequence({
+    value: [
+      // salt
+      new asn1js.OctetString({ valueHex: salt }),
+
+      // iteration count
+      new asn1js.Integer({ value: ITERATIONS }),
+
+      // key length
+      new asn1js.Integer({ value: KEY_SIZE }),
+
+      // AlgorithmIdentifier
+      new asn1js.Sequence({
+        value: [
+          // hmacWithSHA512
+          new asn1js.ObjectIdentifier({ value: '1.2.840.113549.2.11' }),
+          new asn1js.Null()
+        ]
+      })
+    ]
+  })
+
+  const encryptionAlgorithm = new asn1js.Sequence({
+    value: [
+      // pkcs5PBES2
+      new asn1js.ObjectIdentifier({
+        value: '1.2.840.113549.1.5.13'
+      }),
+      new asn1js.Sequence({
+        value: [
+          // keyDerivationFunc
+          new asn1js.Sequence({
+            value: [
+              // pkcs5PBKDF2
+              new asn1js.ObjectIdentifier({
+                value: '1.2.840.113549.1.5.12'
+              }),
+              // PBKDF2-params
+              pbkdf2Params
+            ]
+          }),
+
+          // encryptionScheme
+          new asn1js.Sequence({
+            value: [
+              // aes256-CBC
+              new asn1js.ObjectIdentifier({
+                value: '2.16.840.1.101.3.4.1.42'
+              }),
+              // iv
+              new asn1js.OctetString({
+                valueHex: iv
+              })
+            ]
+          })
+        ]
+      })
+    ]
+  })
+
+  const finalWrapper = new asn1js.Sequence({
+    value: [
+      encryptionAlgorithm,
+      new asn1js.OctetString({ valueHex: encrypted })
+    ]
+  })
+
+  const finalWrapperBuf = finalWrapper.toBER()
+  const finalWrapperArr = new Uint8Array(finalWrapperBuf, 0, finalWrapperBuf.byteLength)
+
+  return [
+    '-----BEGIN ENCRYPTED PRIVATE KEY-----',
+    ...uint8ArrayToString(finalWrapperArr, 'base64pad').split(/(.{64})/).filter(Boolean),
+    '-----END ENCRYPTED PRIVATE KEY-----'
+  ].join('\n')
+}

package/src/utils/import.ts

@@ -0,0 +1,174 @@
+import { AES_GCM } from '@libp2p/crypto/ciphers'
+import { privateKeyFromProtobuf, privateKeyFromRaw } from '@libp2p/crypto/keys'
+import webcrypto from '@libp2p/crypto/webcrypto'
+import { InvalidParametersError } from '@libp2p/interface'
+import { pbkdf2Async } from '@noble/hashes/pbkdf2'
+import { sha512 } from '@noble/hashes/sha512'
+import * as asn1js from 'asn1js'
+import { base64 } from 'multiformats/bases/base64'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { ITERATIONS, KEY_SIZE } from './constants.js'
+import type { PrivateKey, RSAPrivateKey } from '@libp2p/interface'
+
+/**
+ * Converts an exported private key into its representative object.
+ *
+ * Supported formats are 'pem' (RSA only) and 'libp2p-key'.
+ */
+export async function importPrivateKey (encryptedKey: string, password: string): Promise<PrivateKey> {
+  try {
+    const key = await importer(encryptedKey, password)
+    return privateKeyFromProtobuf(key)
+  } catch {
+    // Ignore and try the old pem decrypt
+  }
+
+  if (!encryptedKey.includes('BEGIN')) {
+    throw new InvalidParametersError('Encrypted key was not a libp2p-key or a PEM file')
+  }
+
+  return importFromPem(encryptedKey, password)
+}
+
+/**
+ * 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): Promise<Uint8Array> {
+  const encryptedKey = base64.decode(privateKey)
+  const cipher = AES_GCM.create()
+  return cipher.decrypt(encryptedKey, password)
+}
+
+export async function importFromPem (pem: string, password: string): Promise<RSAPrivateKey> {
+  const crypto = webcrypto.get()
+  let plaintext: Uint8Array
+
+  if (pem.includes('-----BEGIN ENCRYPTED PRIVATE KEY-----')) {
+    const key = uint8ArrayFromString(
+      pem
+        .replace('-----BEGIN ENCRYPTED PRIVATE KEY-----', '')
+        .replace('-----END ENCRYPTED PRIVATE KEY-----', '')
+        .replace(/\n/g, '')
+        .trim(),
+      'base64pad'
+    )
+
+    const { result } = asn1js.fromBER(key)
+
+    const {
+      iv,
+      salt,
+      iterations,
+      keySize,
+      cipherText
+    } = findEncryptedPEMData(result)
+
+    const encryptionKey = await pbkdf2Async(
+      sha512,
+      password,
+      salt, {
+        c: iterations,
+        dkLen: keySize
+      }
+    )
+
+    const cryptoKey = await crypto.subtle.importKey('raw', encryptionKey, 'AES-CBC', false, ['decrypt'])
+    const decrypted = toUint8Array(await crypto.subtle.decrypt({
+      name: 'AES-CBC',
+      iv
+    }, cryptoKey, cipherText))
+
+    const { result: decryptedResult } = asn1js.fromBER(decrypted)
+    plaintext = findPEMData(decryptedResult)
+  } else if (pem.includes('-----BEGIN PRIVATE KEY-----')) {
+    const key = uint8ArrayFromString(
+      pem
+        .replace('-----BEGIN PRIVATE KEY-----', '')
+        .replace('-----END PRIVATE KEY-----', '')
+        .replace(/\n/g, '')
+        .trim(),
+      'base64pad'
+    )
+
+    const { result } = asn1js.fromBER(key)
+
+    plaintext = findPEMData(result)
+  } else {
+    throw new InvalidParametersError('Could not parse private key from PEM data')
+  }
+
+  const key = privateKeyFromRaw(plaintext)
+
+  if (key.type !== 'RSA') {
+    throw new InvalidParametersError('Could not parse RSA private key from PEM data')
+  }
+
+  return key
+}
+
+function findEncryptedPEMData (root: any): { cipherText: Uint8Array, iv: Uint8Array, salt: Uint8Array, iterations: number, keySize: number } {
+  const encryptionAlgorithm = root.valueBlock.value[0]
+  const scheme = encryptionAlgorithm.valueBlock.value[0].toString()
+
+  if (scheme !== 'OBJECT IDENTIFIER : 1.2.840.113549.1.5.13') {
+    throw new InvalidParametersError('Only pkcs5PBES2 encrypted private keys are supported')
+  }
+
+  const keyDerivationFunc = encryptionAlgorithm.valueBlock.value[1].valueBlock.value[0]
+  const keyDerivationFuncName = keyDerivationFunc.valueBlock.value[0].toString()
+
+  if (keyDerivationFuncName !== 'OBJECT IDENTIFIER : 1.2.840.113549.1.5.12') {
+    throw new InvalidParametersError('Only pkcs5PBKDF2 key derivation functions are supported')
+  }
+
+  const pbkdf2Params = keyDerivationFunc.valueBlock.value[1]
+
+  const salt = toUint8Array(pbkdf2Params.valueBlock.value[0].getValue())
+
+  let iterations = ITERATIONS
+  let keySize = KEY_SIZE
+
+  if (pbkdf2Params.valueBlock.value.length === 3) {
+    iterations = Number((pbkdf2Params.valueBlock.value[1] as asn1js.Integer).toBigInt())
+    keySize = Number((pbkdf2Params.valueBlock.value[2]).toBigInt())
+  } else if (pbkdf2Params.valueBlock.value.length === 2) {
+    throw new InvalidParametersError('Could not derive key size and iterations from PEM file - please use @libp2p/rsa to re-import your key')
+  }
+
+  const encryptionScheme = encryptionAlgorithm.valueBlock.value[1].valueBlock.value[1]
+  const encryptionSchemeName = encryptionScheme.valueBlock.value[0].toString()
+
+  if (encryptionSchemeName === 'OBJECT IDENTIFIER : 1.2.840.113549.3.7') {
+    // des-EDE3-CBC
+  } else if (encryptionSchemeName === 'OBJECT IDENTIFIER : 1.3.14.3.2.7') {
+    // des-CBC
+  } else if (encryptionSchemeName === 'OBJECT IDENTIFIER : 2.16.840.1.101.3.4.1.2') {
+    // aes128-CBC
+  } else if (encryptionSchemeName === 'OBJECT IDENTIFIER : 2.16.840.1.101.3.4.1.22') {
+    // aes192-CBC
+  } else if (encryptionSchemeName === 'OBJECT IDENTIFIER : 2.16.840.1.101.3.4.1.42') {
+    // aes256-CBC
+  } else {
+    throw new InvalidParametersError('Only AES-CBC encryption schemes are supported')
+  }
+
+  const iv = toUint8Array(encryptionScheme.valueBlock.value[1].getValue())
+
+  return {
+    cipherText: toUint8Array(root.valueBlock.value[1].getValue()),
+    salt,
+    iterations,
+    keySize,
+    iv
+  }
+}
+
+function findPEMData (seq: any): Uint8Array {
+  return toUint8Array(seq.valueBlock.value[2].getValue())
+}
+
+function toUint8Array (buf: ArrayBuffer): Uint8Array {
+  return new Uint8Array(buf, 0, buf.byteLength)
+}

package/dist/src/errors.d.ts

@@ -1,18 +0,0 @@
-export declare enum codes {
-    ERR_INVALID_PARAMETERS = "ERR_INVALID_PARAMETERS",
-    ERR_INVALID_KEY_NAME = "ERR_INVALID_KEY_NAME",
-    ERR_INVALID_KEY_TYPE = "ERR_INVALID_KEY_TYPE",
-    ERR_KEY_ALREADY_EXISTS = "ERR_KEY_ALREADY_EXISTS",
-    ERR_INVALID_KEY_SIZE = "ERR_INVALID_KEY_SIZE",
-    ERR_KEY_NOT_FOUND = "ERR_KEY_NOT_FOUND",
-    ERR_OLD_KEY_NAME_INVALID = "ERR_OLD_KEY_NAME_INVALID",
-    ERR_NEW_KEY_NAME_INVALID = "ERR_NEW_KEY_NAME_INVALID",
-    ERR_PASSWORD_REQUIRED = "ERR_PASSWORD_REQUIRED",
-    ERR_PEM_REQUIRED = "ERR_PEM_REQUIRED",
-    ERR_CANNOT_READ_KEY = "ERR_CANNOT_READ_KEY",
-    ERR_MISSING_PRIVATE_KEY = "ERR_MISSING_PRIVATE_KEY",
-    ERR_INVALID_OLD_PASS_TYPE = "ERR_INVALID_OLD_PASS_TYPE",
-    ERR_INVALID_NEW_PASS_TYPE = "ERR_INVALID_NEW_PASS_TYPE",
-    ERR_INVALID_PASS_LENGTH = "ERR_INVALID_PASS_LENGTH"
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK;IACf,sBAAsB,2BAA2B;IACjD,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,sBAAsB,2BAA2B;IACjD,oBAAoB,yBAAyB;IAC7C,iBAAiB,sBAAsB;IACvC,wBAAwB,6BAA6B;IACrD,wBAAwB,6BAA6B;IACrD,qBAAqB,0BAA0B;IAC/C,gBAAgB,qBAAqB;IACrC,mBAAmB,wBAAwB;IAC3C,uBAAuB,4BAA4B;IACnD,yBAAyB,8BAA8B;IACvD,yBAAyB,8BAA8B;IACvD,uBAAuB,4BAA4B;CACpD"}

package/dist/src/errors.js

@@ -1,19 +0,0 @@
-export var codes;
-(function (codes) {
-    codes["ERR_INVALID_PARAMETERS"] = "ERR_INVALID_PARAMETERS";
-    codes["ERR_INVALID_KEY_NAME"] = "ERR_INVALID_KEY_NAME";
-    codes["ERR_INVALID_KEY_TYPE"] = "ERR_INVALID_KEY_TYPE";
-    codes["ERR_KEY_ALREADY_EXISTS"] = "ERR_KEY_ALREADY_EXISTS";
-    codes["ERR_INVALID_KEY_SIZE"] = "ERR_INVALID_KEY_SIZE";
-    codes["ERR_KEY_NOT_FOUND"] = "ERR_KEY_NOT_FOUND";
-    codes["ERR_OLD_KEY_NAME_INVALID"] = "ERR_OLD_KEY_NAME_INVALID";
-    codes["ERR_NEW_KEY_NAME_INVALID"] = "ERR_NEW_KEY_NAME_INVALID";
-    codes["ERR_PASSWORD_REQUIRED"] = "ERR_PASSWORD_REQUIRED";
-    codes["ERR_PEM_REQUIRED"] = "ERR_PEM_REQUIRED";
-    codes["ERR_CANNOT_READ_KEY"] = "ERR_CANNOT_READ_KEY";
-    codes["ERR_MISSING_PRIVATE_KEY"] = "ERR_MISSING_PRIVATE_KEY";
-    codes["ERR_INVALID_OLD_PASS_TYPE"] = "ERR_INVALID_OLD_PASS_TYPE";
-    codes["ERR_INVALID_NEW_PASS_TYPE"] = "ERR_INVALID_NEW_PASS_TYPE";
-    codes["ERR_INVALID_PASS_LENGTH"] = "ERR_INVALID_PASS_LENGTH";
-})(codes || (codes = {}));
-//# sourceMappingURL=errors.js.map

package/dist/src/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,KAgBX;AAhBD,WAAY,KAAK;IACf,0DAAiD,CAAA;IACjD,sDAA6C,CAAA;IAC7C,sDAA6C,CAAA;IAC7C,0DAAiD,CAAA;IACjD,sDAA6C,CAAA;IAC7C,gDAAuC,CAAA;IACvC,8DAAqD,CAAA;IACrD,8DAAqD,CAAA;IACrD,wDAA+C,CAAA;IAC/C,8CAAqC,CAAA;IACrC,oDAA2C,CAAA;IAC3C,4DAAmD,CAAA;IACnD,gEAAuD,CAAA;IACvD,gEAAuD,CAAA;IACvD,4DAAmD,CAAA;AACrD,CAAC,EAhBW,KAAK,KAAL,KAAK,QAgBhB"}

package/dist/src/util.d.ts

@@ -1,12 +0,0 @@
-/**
- * Finds the first item in a collection that is matched in the
- * `asyncCompare` function.
- *
- * `asyncCompare` is an async function that must
- * resolve to either `true` or `false`.
- *
- * @param {Array} array
- * @param {function(*)} asyncCompare - An async function that returns a boolean
- */
-export declare function findAsync<T>(array: T[], asyncCompare: (val: T) => Promise<any>): Promise<T | undefined>;
-//# sourceMappingURL=util.d.ts.map

package/dist/src/util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAE,CAAC,EAAG,KAAK,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAK/G"}

package/dist/src/util.js

@@ -1,17 +0,0 @@
-/**
- * Finds the first item in a collection that is matched in the
- * `asyncCompare` function.
- *
- * `asyncCompare` is an async function that must
- * resolve to either `true` or `false`.
- *
- * @param {Array} array
- * @param {function(*)} asyncCompare - An async function that returns a boolean
- */
-export async function findAsync(array, asyncCompare) {
-    const promises = array.map(asyncCompare);
-    const results = await Promise.all(promises);
-    const index = results.findIndex(result => result);
-    return array[index];
-}
-//# sourceMappingURL=util.js.map

package/dist/src/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAM,KAAU,EAAE,YAAsC;IACrF,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IACxC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAA;IACjD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAA;AACrB,CAAC"}

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DEKConfig": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.DEKConfig.html",
-  ".:DEKConfig": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.DEKConfig.html",
-  "KeyInfo": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeyInfo.html",
-  ".:KeyInfo": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeyInfo.html",
-  "Keychain": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.Keychain.html",
-  ".:Keychain": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.Keychain.html",
-  "KeychainComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeychainComponents.html",
-  ".:KeychainComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeychainComponents.html",
-  "KeychainInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeychainInit.html",
-  ".:KeychainInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_keychain.KeychainInit.html",
-  "keychain": "https://libp2p.github.io/js-libp2p/functions/_libp2p_keychain.keychain-1.html",
-  ".:keychain": "https://libp2p.github.io/js-libp2p/functions/_libp2p_keychain.keychain-1.html"
-}

package/src/errors.ts

@@ -1,17 +0,0 @@
-export enum codes {
-  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
-  ERR_INVALID_KEY_NAME = 'ERR_INVALID_KEY_NAME',
-  ERR_INVALID_KEY_TYPE = 'ERR_INVALID_KEY_TYPE',
-  ERR_KEY_ALREADY_EXISTS = 'ERR_KEY_ALREADY_EXISTS',
-  ERR_INVALID_KEY_SIZE = 'ERR_INVALID_KEY_SIZE',
-  ERR_KEY_NOT_FOUND = 'ERR_KEY_NOT_FOUND',
-  ERR_OLD_KEY_NAME_INVALID = 'ERR_OLD_KEY_NAME_INVALID',
-  ERR_NEW_KEY_NAME_INVALID = 'ERR_NEW_KEY_NAME_INVALID',
-  ERR_PASSWORD_REQUIRED = 'ERR_PASSWORD_REQUIRED',
-  ERR_PEM_REQUIRED = 'ERR_PEM_REQUIRED',
-  ERR_CANNOT_READ_KEY = 'ERR_CANNOT_READ_KEY',
-  ERR_MISSING_PRIVATE_KEY = 'ERR_MISSING_PRIVATE_KEY',
-  ERR_INVALID_OLD_PASS_TYPE = 'ERR_INVALID_OLD_PASS_TYPE',
-  ERR_INVALID_NEW_PASS_TYPE = 'ERR_INVALID_NEW_PASS_TYPE',
-  ERR_INVALID_PASS_LENGTH = 'ERR_INVALID_PASS_LENGTH'
-}

package/src/util.ts

@@ -1,16 +0,0 @@
-/**
- * Finds the first item in a collection that is matched in the
- * `asyncCompare` function.
- *
- * `asyncCompare` is an async function that must
- * resolve to either `true` or `false`.
- *
- * @param {Array} array
- * @param {function(*)} asyncCompare - An async function that returns a boolean
- */
-export async function findAsync <T> (array: T[], asyncCompare: (val: T) => Promise<any>): Promise<T | undefined> {
-  const promises = array.map(asyncCompare)
-  const results = await Promise.all(promises)
-  const index = results.findIndex(result => result)
-  return array[index]
-}