@libp2p/crypto 0.0.0 → 0.22.3

package/package.json

@@ -1,7 +1,181 @@
 {
   "name": "@libp2p/crypto",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "license": "(Apache-2.0 OR MIT)"
+  "version": "0.22.3",
+  "description": "Crypto primitives for libp2p",
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    },
+    "./aes": {
+      "import": "./dist/src/aes/index.js"
+    },
+    "./ciphers": {
+      "import": "./dist/src/ciphers/index.js"
+    },
+    "./hmac": {
+      "import": "./dist/src/hmac/index.js"
+    },
+    "./keys": {
+      "import": "./dist/src/keys/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist/src",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "src/*.d.ts"
+    ]
+  },
+  "scripts": {
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js",
+    "build": "tsc",
+    "pretest": "npm run build",
+    "test": "aegir test -f ./dist/test/**/*.js",
+    "test:chrome": "npm run test -- -t browser",
+    "test:chrome-webworker": "npm run test -- -t webworker",
+    "test:firefox": "npm run test -- -t browser -- --browser firefox",
+    "test:firefox-webworker": "npm run test -- -t webworker -- --browser firefox",
+    "test:node": "npm run test -- -t node --cov",
+    "test:electron-main": "npm run test -- -t electron-main",
+    "release": "semantic-release",
+    "build:proto": "npm run build:proto:js && npm run build:proto:types",
+    "build:proto:js": "pbjs -t static-module -w es6 --es6 -r libp2p-crypto-keys --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/keys/keys.js ./src/keys/keys.proto",
+    "build:proto:types": "pbts -o src/keys/keys.d.ts src/keys/keys.js"
+  },
+  "browser": {
+    "./dist/src/aes/ciphers.js": "./dist/src/aes/ciphers-browser.js",
+    "./dist/src/ciphers/aes-gcm.js": "./dist/src/ciphers/aes-gcm.browser.js",
+    "./dist/src/hmac/index.js": "./dist/src/hmac/index-browser.js",
+    "./dist/src/keys/ecdh.js": "./dist/src/keys/ecdh-browser.js",
+    "./dist/src/keys/rsa.js": "./dist/src/keys/rsa-browser.js"
+  },
+  "keywords": [
+    "IPFS",
+    "libp2p",
+    "crypto",
+    "rsa",
+    "secp256k1"
+  ],
+  "license": "Apache-2.0 OR MIT",
+  "dependencies": {
+    "@noble/ed25519": "^1.3.3",
+    "@noble/secp256k1": "^1.3.4",
+    "err-code": "^3.0.1",
+    "iso-random-stream": "^2.0.0",
+    "multiformats": "^9.4.5",
+    "node-forge": "^0.10.0",
+    "protobufjs": "^6.11.2",
+    "uint8arrays": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^9.0.0",
+    "aegir": "^36.1.2",
+    "benchmark": "^2.1.4",
+    "sinon": "^12.0.1",
+    "util": "^0.12.3",
+    "wherearewe": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=15.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/libp2p/js-libp2p-crypto.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-crypto/issues"
+  },
+  "homepage": "https://github.com/libp2p/js-libp2p-crypto",
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  }
 }

package/src/aes/cipher-mode.ts

@@ -0,0 +1,15 @@
+import errcode from 'err-code'
+
+const CIPHER_MODES = {
+  16: 'aes-128-ctr',
+  32: 'aes-256-ctr'
+}
+
+export function cipherMode (key: Uint8Array) {
+  if (key.length === 16 || key.length === 32) {
+    return CIPHER_MODES[key.length]
+  }
+
+  const modes = Object.entries(CIPHER_MODES).map(([k, v]) => `${k} (${v})`).join(' / ')
+  throw errcode(new Error(`Invalid key length ${key.length} bytes. Must be ${modes}`), 'ERR_INVALID_KEY_LENGTH')
+}

package/src/aes/ciphers-browser.ts

@@ -0,0 +1,28 @@
+
+import 'node-forge/lib/aes.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+
+export function createCipheriv (mode: any, key: Uint8Array, iv: Uint8Array) {
+  const cipher2 = forge.cipher.createCipher('AES-CTR', uint8ArrayToString(key, 'ascii'))
+  cipher2.start({ iv: uint8ArrayToString(iv, 'ascii') })
+  return {
+    update: (data: Uint8Array) => {
+      cipher2.update(forge.util.createBuffer(uint8ArrayToString(data, 'ascii')))
+      return uint8ArrayFromString(cipher2.output.getBytes(), 'ascii')
+    }
+  }
+}
+
+export function createDecipheriv (mode: any, key: Uint8Array, iv: Uint8Array) {
+  const cipher2 = forge.cipher.createDecipher('AES-CTR', uint8ArrayToString(key, 'ascii'))
+  cipher2.start({ iv: uint8ArrayToString(iv, 'ascii') })
+  return {
+    update: (data: Uint8Array) => {
+      cipher2.update(forge.util.createBuffer(uint8ArrayToString(data, 'ascii')))
+      return uint8ArrayFromString(cipher2.output.getBytes(), 'ascii')
+    }
+  }
+}

package/src/aes/ciphers.ts

@@ -0,0 +1,4 @@
+import crypto from 'crypto'
+
+export const createCipheriv = crypto.createCipheriv
+export const createDecipheriv = crypto.createDecipheriv

package/src/aes/index.ts

@@ -0,0 +1,25 @@
+import * as ciphers from './ciphers.js'
+import { cipherMode } from './cipher-mode.js'
+
+export interface AESCipher {
+  encrypt: (data: Uint8Array) => Promise<Uint8Array>
+  decrypt: (data: Uint8Array) => Promise<Uint8Array>
+}
+
+export async function create (key: Uint8Array, iv: Uint8Array) { // eslint-disable-line require-await
+  const mode = cipherMode(key)
+  const cipher = ciphers.createCipheriv(mode, key, iv)
+  const decipher = ciphers.createDecipheriv(mode, key, iv)
+
+  const res: AESCipher = {
+    async encrypt (data) { // eslint-disable-line require-await
+      return cipher.update(data)
+    },
+
+    async decrypt (data) { // eslint-disable-line require-await
+      return decipher.update(data)
+    }
+  }
+
+  return res
+}

package/src/ciphers/aes-gcm.browser.ts

@@ -0,0 +1,74 @@
+import { concat } from 'uint8arrays/concat'
+import { fromString } from 'uint8arrays/from-string'
+import webcrypto from '../webcrypto.js'
+import type { CreateOptions, AESCipher } from './interface.js'
+
+// Based off of code from https://github.com/luke-park/SecureCompatibleEncryptionExamples
+
+export function create (opts?: CreateOptions) {
+  const algorithm = opts?.algorithm ?? 'AES-GCM'
+  let keyLength = opts?.keyLength ?? 16
+  const nonceLength = opts?.nonceLength ?? 12
+  const digest = opts?.digest ?? 'SHA-256'
+  const saltLength = opts?.saltLength ?? 16
+  const iterations = opts?.iterations ?? 32767
+
+  const crypto = webcrypto.get()
+  keyLength *= 8 // Browser crypto uses bits instead of bytes
+
+  /**
+   * Uses the provided password to derive a pbkdf2 key. The key
+   * will then be used to encrypt the data.
+   */
+  async function encrypt (data: Uint8Array, password: string | Uint8Array) { // eslint-disable-line require-await
+    const salt = crypto.getRandomValues(new Uint8Array(saltLength))
+    const nonce = crypto.getRandomValues(new Uint8Array(nonceLength))
+    const aesGcm = { name: algorithm, iv: nonce }
+
+    if (typeof password === 'string') {
+      password = fromString(password)
+    }
+
+    // Derive a key using PBKDF2.
+    const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
+    const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey', 'deriveBits'])
+    const cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['encrypt'])
+
+    // Encrypt the string.
+    const ciphertext = await crypto.subtle.encrypt(aesGcm, cryptoKey, data)
+    return concat([salt, aesGcm.iv, new Uint8Array(ciphertext)])
+  }
+
+  /**
+   * Uses the provided password to derive a pbkdf2 key. The key
+   * will then be used to decrypt the data. The options used to create
+   * this decryption cipher must be the same as those used to create
+   * the encryption cipher.
+   */
+  async function decrypt (data: Uint8Array, password: string | Uint8Array) {
+    const salt = data.slice(0, saltLength)
+    const nonce = data.slice(saltLength, saltLength + nonceLength)
+    const ciphertext = data.slice(saltLength + nonceLength)
+    const aesGcm = { name: algorithm, iv: nonce }
+
+    if (typeof password === 'string') {
+      password = fromString(password)
+    }
+
+    // Derive the key using PBKDF2.
+    const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
+    const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey', 'deriveBits'])
+    const cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['decrypt'])
+
+    // Decrypt the string.
+    const plaintext = await crypto.subtle.decrypt(aesGcm, cryptoKey, ciphertext)
+    return new Uint8Array(plaintext)
+  }
+
+  const cipher: AESCipher = {
+    encrypt,
+    decrypt
+  }
+
+  return cipher
+}

package/src/ciphers/aes-gcm.ts

@@ -0,0 +1,102 @@
+import crypto from 'crypto'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { CreateOptions, AESCipher } from './interface.js'
+
+// Based off of code from https://github.com/luke-park/SecureCompatibleEncryptionExamples
+
+export function create (opts?: CreateOptions) {
+  const algorithm = opts?.algorithm ?? 'aes-128-gcm'
+  const keyLength = opts?.keyLength ?? 16
+  const nonceLength = opts?.nonceLength ?? 12
+  const digest = opts?.digest ?? 'sha256'
+  const saltLength = opts?.saltLength ?? 16
+  const iterations = opts?.iterations ?? 32767
+  const algorithmTagLength = opts?.algorithmTagLength ?? 16
+
+  async function encryptWithKey (data: Uint8Array, key: Uint8Array) { // eslint-disable-line require-await
+    const nonce = crypto.randomBytes(nonceLength)
+
+    // Create the cipher instance.
+    const cipher = crypto.createCipheriv(algorithm, key, nonce)
+
+    // Encrypt and prepend nonce.
+    const ciphertext = uint8ArrayConcat([cipher.update(data), cipher.final()])
+
+    // @ts-expect-error getAuthTag is not a function
+    return uint8ArrayConcat([nonce, ciphertext, cipher.getAuthTag()])
+  }
+
+  /**
+   * Uses the provided password to derive a pbkdf2 key. The key
+   * will then be used to encrypt the data.
+   */
+  async function encrypt (data: Uint8Array, password: string | Uint8Array) { // eslint-disable-line require-await
+    // Generate a 128-bit salt using a CSPRNG.
+    const salt = crypto.randomBytes(saltLength)
+
+    if (typeof password === 'string') {
+      password = uint8ArrayFromString(password)
+    }
+
+    // Derive a key using PBKDF2.
+    const key = crypto.pbkdf2Sync(password, salt, iterations, keyLength, digest)
+
+    // Encrypt and prepend salt.
+    return uint8ArrayConcat([salt, await encryptWithKey(Uint8Array.from(data), key)])
+  }
+
+  /**
+   * Decrypts the given cipher text with the provided key. The `key` should
+   * be a cryptographically safe key and not a plaintext password. To use
+   * a plaintext password, use `decrypt`. The options used to create
+   * this decryption cipher must be the same as those used to create
+   * the encryption cipher.
+   */
+  async function decryptWithKey (ciphertextAndNonce: Uint8Array, key: Uint8Array) { // eslint-disable-line require-await
+    // Create Uint8Arrays of nonce, ciphertext and tag.
+    const nonce = ciphertextAndNonce.slice(0, nonceLength)
+    const ciphertext = ciphertextAndNonce.slice(nonceLength, ciphertextAndNonce.length - algorithmTagLength)
+    const tag = ciphertextAndNonce.slice(ciphertext.length + nonceLength)
+
+    // Create the cipher instance.
+    const cipher = crypto.createDecipheriv(algorithm, key, nonce)
+
+    // Decrypt and return result.
+    // @ts-expect-error getAuthTag is not a function
+    cipher.setAuthTag(tag)
+    return uint8ArrayConcat([cipher.update(ciphertext), cipher.final()])
+  }
+
+  /**
+   * Uses the provided password to derive a pbkdf2 key. The key
+   * will then be used to decrypt the data. The options used to create
+   * this decryption cipher must be the same as those used to create
+   * the encryption cipher.
+   *
+   * @param {Uint8Array} data - The data to decrypt
+   * @param {string|Uint8Array} password - A plain password
+   */
+  async function decrypt (data: Uint8Array, password: string | Uint8Array) { // eslint-disable-line require-await
+    // Create Uint8Arrays of salt and ciphertextAndNonce.
+    const salt = data.slice(0, saltLength)
+    const ciphertextAndNonce = data.slice(saltLength)
+
+    if (typeof password === 'string') {
+      password = uint8ArrayFromString(password)
+    }
+
+    // Derive the key using PBKDF2.
+    const key = crypto.pbkdf2Sync(password, salt, iterations, keyLength, digest)
+
+    // Decrypt and return result.
+    return await decryptWithKey(ciphertextAndNonce, key)
+  }
+
+  const cipher: AESCipher = {
+    encrypt,
+    decrypt
+  }
+
+  return cipher
+}

package/src/ciphers/interface.ts

@@ -0,0 +1,15 @@
+
+export interface CreateOptions {
+  algorithm?: string
+  nonceLength?: number
+  keyLength?: number
+  digest?: string
+  saltLength?: number
+  iterations?: number
+  algorithmTagLength?: number
+}
+
+export interface AESCipher {
+  encrypt: (data: Uint8Array, password: string | Uint8Array) => Promise<Uint8Array>
+  decrypt: (data: Uint8Array, password: string | Uint8Array) => Promise<Uint8Array>
+}

package/src/hmac/index-browser.ts

@@ -0,0 +1,35 @@
+import webcrypto from '../webcrypto.js'
+import lengths from './lengths.js'
+
+const hashTypes = {
+  SHA1: 'SHA-1',
+  SHA256: 'SHA-256',
+  SHA512: 'SHA-512'
+}
+
+const sign = async (key: CryptoKey, data: Uint8Array) => {
+  const buf = await webcrypto.get().subtle.sign({ name: 'HMAC' }, key, data)
+  return new Uint8Array(buf, 0, buf.byteLength)
+}
+
+export async function create (hashType: 'SHA1' | 'SHA256' | 'SHA512', secret: Uint8Array) {
+  const hash = hashTypes[hashType]
+
+  const key = await webcrypto.get().subtle.importKey(
+    'raw',
+    secret,
+    {
+      name: 'HMAC',
+      hash: { name: hash }
+    },
+    false,
+    ['sign']
+  )
+
+  return {
+    async digest (data: Uint8Array) { // eslint-disable-line require-await
+      return await sign(key, data)
+    },
+    length: lengths[hashType]
+  }
+}

package/src/hmac/index.ts

@@ -0,0 +1,15 @@
+import crypto from 'crypto'
+import lengths from './lengths.js'
+
+export async function create (hash: 'SHA1' | 'SHA256' | 'SHA512', secret: Uint8Array) { // eslint-disable-line require-await
+  const res = {
+    async digest (data: Uint8Array) { // eslint-disable-line require-await
+      const hmac = crypto.createHmac(hash.toLowerCase(), secret)
+      hmac.update(data)
+      return hmac.digest()
+    },
+    length: lengths[hash]
+  }
+
+  return res
+}

package/src/hmac/lengths.ts

@@ -0,0 +1,6 @@
+
+export default {
+  SHA1: 20,
+  SHA256: 32,
+  SHA512: 64
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import * as hmac from './hmac/index.js'
+import * as aes from './aes/index.js'
+import * as keys from './keys/index.js'
+import randomBytes from './random-bytes.js'
+import pbkdf2 from './pbkdf2.js'
+
+export { aes }
+export { hmac }
+export { keys }
+export { randomBytes }
+export { pbkdf2 }

package/src/keys/ecdh-browser.ts

@@ -0,0 +1,138 @@
+import errcode from 'err-code'
+import webcrypto from '../webcrypto.js'
+import { base64urlToBuffer } from '../util.js'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import type { ECDHKey, ECDHKeyPair } from './interface.js'
+
+const bits = {
+  'P-256': 256,
+  'P-384': 384,
+  'P-521': 521
+}
+
+const curveTypes = Object.keys(bits)
+const names = curveTypes.join(' / ')
+
+export async function generateEphmeralKeyPair (curve: string) {
+  if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
+    throw errcode(new Error(`Unknown curve: ${curve}. Must be ${names}`), 'ERR_INVALID_CURVE')
+  }
+
+  const pair = await webcrypto.get().subtle.generateKey(
+    {
+      name: 'ECDH',
+      namedCurve: curve
+    },
+    true,
+    ['deriveBits']
+  )
+
+  // forcePrivate is used for testing only
+  const genSharedKey = async (theirPub: Uint8Array, forcePrivate?: ECDHKeyPair) => {
+    let privateKey
+
+    if (forcePrivate != null) {
+      privateKey = await webcrypto.get().subtle.importKey(
+        'jwk',
+        unmarshalPrivateKey(curve, forcePrivate),
+        {
+          name: 'ECDH',
+          namedCurve: curve
+        },
+        false,
+        ['deriveBits']
+      )
+    } else {
+      privateKey = pair.privateKey
+    }
+
+    const key = await webcrypto.get().subtle.importKey(
+      'jwk',
+      unmarshalPublicKey(curve, theirPub),
+      {
+        name: 'ECDH',
+        namedCurve: curve
+      },
+      false,
+      []
+    )
+
+    const buffer = await webcrypto.get().subtle.deriveBits(
+      {
+        name: 'ECDH',
+        // @ts-expect-error namedCurve is missing from the types
+        namedCurve: curve,
+        public: key
+      },
+      privateKey,
+      bits[curve]
+    )
+
+    return new Uint8Array(buffer, 0, buffer.byteLength)
+  }
+
+  // @ts-expect-error jwk is missing from the types
+  const publicKey = await webcrypto.get().subtle.exportKey('jwk', pair.publicKey)
+
+  const ecdhKey: ECDHKey = {
+    key: marshalPublicKey(publicKey),
+    genSharedKey
+  }
+
+  return ecdhKey
+}
+
+const curveLengths = {
+  'P-256': 32,
+  'P-384': 48,
+  'P-521': 66
+}
+
+// Marshal converts a jwk encoded ECDH public key into the
+// form specified in section 4.3.6 of ANSI X9.62. (This is the format
+// go-ipfs uses)
+function marshalPublicKey (jwk: JsonWebKey) {
+  if (jwk.crv == null || jwk.x == null || jwk.y == null) {
+    throw errcode(new Error('JWK was missing components'), 'ERR_INVALID_PARAMETERS')
+  }
+
+  if (jwk.crv !== 'P-256' && jwk.crv !== 'P-384' && jwk.crv !== 'P-521') {
+    throw errcode(new Error(`Unknown curve: ${jwk.crv}. Must be ${names}`), 'ERR_INVALID_CURVE')
+  }
+
+  const byteLen = curveLengths[jwk.crv]
+
+  return uint8ArrayConcat([
+    Uint8Array.from([4]), // uncompressed point
+    base64urlToBuffer(jwk.x, byteLen),
+    base64urlToBuffer(jwk.y, byteLen)
+  ], 1 + byteLen * 2)
+}
+
+// Unmarshal converts a point, serialized by Marshal, into an jwk encoded key
+function unmarshalPublicKey (curve: string, key: Uint8Array) {
+  if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
+    throw errcode(new Error(`Unknown curve: ${curve}. Must be ${names}`), 'ERR_INVALID_CURVE')
+  }
+
+  const byteLen = curveLengths[curve]
+
+  if (!uint8ArrayEquals(key.slice(0, 1), Uint8Array.from([4]))) {
+    throw errcode(new Error('Cannot unmarshal public key - invalid key format'), 'ERR_INVALID_KEY_FORMAT')
+  }
+
+  return {
+    kty: 'EC',
+    crv: curve,
+    x: uint8ArrayToString(key.slice(1, byteLen + 1), 'base64url'),
+    y: uint8ArrayToString(key.slice(1 + byteLen), 'base64url'),
+    ext: true
+  }
+}
+
+const unmarshalPrivateKey = (curve: string, key: ECDHKeyPair) => ({
+  ...unmarshalPublicKey(curve, key.public),
+  d: uint8ArrayToString(key.private, 'base64url')
+})