@libp2p/crypto 0.0.0 → 0.22.0

package/src/keys/keys.js

@@ -0,0 +1,366 @@
+// @ts-nocheck
+
+/*eslint-disable*/
+import $protobuf from "protobufjs/minimal.js";
+
+// Common aliases
+const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+const $root = $protobuf.roots["libp2p-crypto-keys"] || ($protobuf.roots["libp2p-crypto-keys"] = {});
+
+/**
+ * KeyType enum.
+ * @exports KeyType
+ * @enum {number}
+ * @property {number} RSA=0 RSA value
+ * @property {number} Ed25519=1 Ed25519 value
+ * @property {number} Secp256k1=2 Secp256k1 value
+ */
+export const KeyType = $root.KeyType = (() => {
+    const valuesById = {}, values = Object.create(valuesById);
+    values[valuesById[0] = "RSA"] = 0;
+    values[valuesById[1] = "Ed25519"] = 1;
+    values[valuesById[2] = "Secp256k1"] = 2;
+    return values;
+})();
+
+/**
+ * Properties of a PublicKey.
+ * @exports IPublicKey
+ * @interface IPublicKey
+ * @property {KeyType} Type PublicKey Type
+ * @property {Uint8Array} Data PublicKey Data
+ */
+
+/**
+ * Constructs a new PublicKey.
+ * @exports PublicKey
+ * @classdesc Represents a PublicKey.
+ * @implements IPublicKey
+ * @constructor
+ * @param {IPublicKey=} [p] Properties to set
+ */
+export function PublicKey(p) {
+    if (p)
+        for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+            if (p[ks[i]] != null)
+                this[ks[i]] = p[ks[i]];
+}
+
+/**
+ * PublicKey Type.
+ * @member {KeyType} Type
+ * @memberof PublicKey
+ * @instance
+ */
+PublicKey.prototype.Type = 0;
+
+/**
+ * PublicKey Data.
+ * @member {Uint8Array} Data
+ * @memberof PublicKey
+ * @instance
+ */
+PublicKey.prototype.Data = $util.newBuffer([]);
+
+/**
+ * Encodes the specified PublicKey message. Does not implicitly {@link PublicKey.verify|verify} messages.
+ * @function encode
+ * @memberof PublicKey
+ * @static
+ * @param {IPublicKey} m PublicKey message or plain object to encode
+ * @param {$protobuf.Writer} [w] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+PublicKey.encode = function encode(m, w) {
+    if (!w)
+        w = $Writer.create();
+    w.uint32(8).int32(m.Type);
+    w.uint32(18).bytes(m.Data);
+    return w;
+};
+
+/**
+ * Decodes a PublicKey message from the specified reader or buffer.
+ * @function decode
+ * @memberof PublicKey
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+ * @param {number} [l] Message length if known beforehand
+ * @returns {PublicKey} PublicKey
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+PublicKey.decode = function decode(r, l) {
+    if (!(r instanceof $Reader))
+        r = $Reader.create(r);
+    var c = l === undefined ? r.len : r.pos + l, m = new PublicKey();
+    while (r.pos < c) {
+        var t = r.uint32();
+        switch (t >>> 3) {
+        case 1:
+            m.Type = r.int32();
+            break;
+        case 2:
+            m.Data = r.bytes();
+            break;
+        default:
+            r.skipType(t & 7);
+            break;
+        }
+    }
+    if (!m.hasOwnProperty("Type"))
+        throw $util.ProtocolError("missing required 'Type'", { instance: m });
+    if (!m.hasOwnProperty("Data"))
+        throw $util.ProtocolError("missing required 'Data'", { instance: m });
+    return m;
+};
+
+/**
+ * Creates a PublicKey message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof PublicKey
+ * @static
+ * @param {Object.<string,*>} d Plain object
+ * @returns {PublicKey} PublicKey
+ */
+PublicKey.fromObject = function fromObject(d) {
+    if (d instanceof PublicKey)
+        return d;
+    var m = new PublicKey();
+    switch (d.Type) {
+    case "RSA":
+    case 0:
+        m.Type = 0;
+        break;
+    case "Ed25519":
+    case 1:
+        m.Type = 1;
+        break;
+    case "Secp256k1":
+    case 2:
+        m.Type = 2;
+        break;
+    }
+    if (d.Data != null) {
+        if (typeof d.Data === "string")
+            $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0);
+        else if (d.Data.length)
+            m.Data = d.Data;
+    }
+    return m;
+};
+
+/**
+ * Creates a plain object from a PublicKey message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof PublicKey
+ * @static
+ * @param {PublicKey} m PublicKey
+ * @param {$protobuf.IConversionOptions} [o] Conversion options
+ * @returns {Object.<string,*>} Plain object
+ */
+PublicKey.toObject = function toObject(m, o) {
+    if (!o)
+        o = {};
+    var d = {};
+    if (o.defaults) {
+        d.Type = o.enums === String ? "RSA" : 0;
+        if (o.bytes === String)
+            d.Data = "";
+        else {
+            d.Data = [];
+            if (o.bytes !== Array)
+                d.Data = $util.newBuffer(d.Data);
+        }
+    }
+    if (m.Type != null && m.hasOwnProperty("Type")) {
+        d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type;
+    }
+    if (m.Data != null && m.hasOwnProperty("Data")) {
+        d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data;
+    }
+    return d;
+};
+
+/**
+ * Converts this PublicKey to JSON.
+ * @function toJSON
+ * @memberof PublicKey
+ * @instance
+ * @returns {Object.<string,*>} JSON object
+ */
+PublicKey.prototype.toJSON = function toJSON() {
+    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+};
+
+/**
+ * Properties of a PrivateKey.
+ * @exports IPrivateKey
+ * @interface IPrivateKey
+ * @property {KeyType} Type PrivateKey Type
+ * @property {Uint8Array} Data PrivateKey Data
+ */
+
+/**
+ * Constructs a new PrivateKey.
+ * @exports PrivateKey
+ * @classdesc Represents a PrivateKey.
+ * @implements IPrivateKey
+ * @constructor
+ * @param {IPrivateKey=} [p] Properties to set
+ */
+export function PrivateKey(p) {
+    if (p)
+        for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+            if (p[ks[i]] != null)
+                this[ks[i]] = p[ks[i]];
+}
+
+/**
+ * PrivateKey Type.
+ * @member {KeyType} Type
+ * @memberof PrivateKey
+ * @instance
+ */
+PrivateKey.prototype.Type = 0;
+
+/**
+ * PrivateKey Data.
+ * @member {Uint8Array} Data
+ * @memberof PrivateKey
+ * @instance
+ */
+PrivateKey.prototype.Data = $util.newBuffer([]);
+
+/**
+ * Encodes the specified PrivateKey message. Does not implicitly {@link PrivateKey.verify|verify} messages.
+ * @function encode
+ * @memberof PrivateKey
+ * @static
+ * @param {IPrivateKey} m PrivateKey message or plain object to encode
+ * @param {$protobuf.Writer} [w] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+PrivateKey.encode = function encode(m, w) {
+    if (!w)
+        w = $Writer.create();
+    w.uint32(8).int32(m.Type);
+    w.uint32(18).bytes(m.Data);
+    return w;
+};
+
+/**
+ * Decodes a PrivateKey message from the specified reader or buffer.
+ * @function decode
+ * @memberof PrivateKey
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+ * @param {number} [l] Message length if known beforehand
+ * @returns {PrivateKey} PrivateKey
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+PrivateKey.decode = function decode(r, l) {
+    if (!(r instanceof $Reader))
+        r = $Reader.create(r);
+    var c = l === undefined ? r.len : r.pos + l, m = new PrivateKey();
+    while (r.pos < c) {
+        var t = r.uint32();
+        switch (t >>> 3) {
+        case 1:
+            m.Type = r.int32();
+            break;
+        case 2:
+            m.Data = r.bytes();
+            break;
+        default:
+            r.skipType(t & 7);
+            break;
+        }
+    }
+    if (!m.hasOwnProperty("Type"))
+        throw $util.ProtocolError("missing required 'Type'", { instance: m });
+    if (!m.hasOwnProperty("Data"))
+        throw $util.ProtocolError("missing required 'Data'", { instance: m });
+    return m;
+};
+
+/**
+ * Creates a PrivateKey message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof PrivateKey
+ * @static
+ * @param {Object.<string,*>} d Plain object
+ * @returns {PrivateKey} PrivateKey
+ */
+PrivateKey.fromObject = function fromObject(d) {
+    if (d instanceof PrivateKey)
+        return d;
+    var m = new PrivateKey();
+    switch (d.Type) {
+    case "RSA":
+    case 0:
+        m.Type = 0;
+        break;
+    case "Ed25519":
+    case 1:
+        m.Type = 1;
+        break;
+    case "Secp256k1":
+    case 2:
+        m.Type = 2;
+        break;
+    }
+    if (d.Data != null) {
+        if (typeof d.Data === "string")
+            $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0);
+        else if (d.Data.length)
+            m.Data = d.Data;
+    }
+    return m;
+};
+
+/**
+ * Creates a plain object from a PrivateKey message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof PrivateKey
+ * @static
+ * @param {PrivateKey} m PrivateKey
+ * @param {$protobuf.IConversionOptions} [o] Conversion options
+ * @returns {Object.<string,*>} Plain object
+ */
+PrivateKey.toObject = function toObject(m, o) {
+    if (!o)
+        o = {};
+    var d = {};
+    if (o.defaults) {
+        d.Type = o.enums === String ? "RSA" : 0;
+        if (o.bytes === String)
+            d.Data = "";
+        else {
+            d.Data = [];
+            if (o.bytes !== Array)
+                d.Data = $util.newBuffer(d.Data);
+        }
+    }
+    if (m.Type != null && m.hasOwnProperty("Type")) {
+        d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type;
+    }
+    if (m.Data != null && m.hasOwnProperty("Data")) {
+        d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data;
+    }
+    return d;
+};
+
+/**
+ * Converts this PrivateKey to JSON.
+ * @function toJSON
+ * @memberof PrivateKey
+ * @instance
+ * @returns {Object.<string,*>} JSON object
+ */
+PrivateKey.prototype.toJSON = function toJSON() {
+    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+};

package/src/keys/keys.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+enum KeyType {
+  RSA = 0;
+  Ed25519 = 1;
+  Secp256k1 = 2;
+}
+message PublicKey {
+  required KeyType Type = 1;
+  required bytes Data = 2;
+}
+message PrivateKey {
+  required KeyType Type = 1;
+  required bytes Data = 2;
+}

package/src/keys/rsa-browser.ts

@@ -0,0 +1,156 @@
+import webcrypto from '../webcrypto.js'
+import randomBytes from '../random-bytes.js'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import * as utils from './rsa-utils.js'
+import { jwk2pub, jwk2priv } from './jwk2pem.js'
+import errcode from 'err-code'
+
+export { utils }
+
+export async function generateKey (bits: number) {
+  const pair = await webcrypto.get().subtle.generateKey(
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      modulusLength: bits,
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['sign', 'verify']
+  )
+
+  const keys = await exportKey(pair)
+
+  return {
+    privateKey: keys[0],
+    publicKey: keys[1]
+  }
+}
+
+// Takes a jwk key
+export async function unmarshalPrivateKey (key: JsonWebKey) {
+  const privateKey = await webcrypto.get().subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['sign']
+  )
+
+  const pair = [
+    privateKey,
+    await derivePublicFromPrivate(key)
+  ]
+
+  const keys = await exportKey({
+    privateKey: pair[0],
+    publicKey: pair[1]
+  })
+
+  return {
+    privateKey: keys[0],
+    publicKey: keys[1]
+  }
+}
+
+export { randomBytes as getRandomValues }
+
+export async function hashAndSign (key: JsonWebKey, msg: Uint8Array) {
+  const privateKey = await webcrypto.get().subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    false,
+    ['sign']
+  )
+
+  const sig = await webcrypto.get().subtle.sign(
+    { name: 'RSASSA-PKCS1-v1_5' },
+    privateKey,
+    Uint8Array.from(msg)
+  )
+
+  return new Uint8Array(sig, 0, sig.byteLength)
+}
+
+export async function hashAndVerify (key: JsonWebKey, sig: Uint8Array, msg: Uint8Array) {
+  const publicKey = await webcrypto.get().subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    false,
+    ['verify']
+  )
+
+  return await webcrypto.get().subtle.verify(
+    { name: 'RSASSA-PKCS1-v1_5' },
+    publicKey,
+    sig,
+    msg
+  )
+}
+
+async function exportKey (pair: CryptoKeyPair) {
+  if (pair.privateKey == null || pair.publicKey == null) {
+    throw errcode(new Error('Private and public key are required'), 'ERR_INVALID_PARAMETERS')
+  }
+
+  return await Promise.all([
+    webcrypto.get().subtle.exportKey('jwk', pair.privateKey),
+    webcrypto.get().subtle.exportKey('jwk', pair.publicKey)
+  ])
+}
+
+async function derivePublicFromPrivate (jwKey: JsonWebKey) {
+  return await webcrypto.get().subtle.importKey(
+    'jwk',
+    {
+      kty: jwKey.kty,
+      n: jwKey.n,
+      e: jwKey.e
+    },
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['verify']
+  )
+}
+
+/*
+
+RSA encryption/decryption for the browser with webcrypto workaround
+"bloody dark magic. webcrypto's why."
+
+Explanation:
+  - Convert JWK to nodeForge
+  - Convert msg Uint8Array to nodeForge buffer: ByteBuffer is a "binary-string backed buffer", so let's make our Uint8Array a binary string
+  - Convert resulting nodeForge buffer to Uint8Array: it returns a binary string, turn that into a Uint8Array
+
+*/
+
+function convertKey (key: JsonWebKey, pub: boolean, msg: Uint8Array, handle: (msg: string, key: { encrypt: (msg: string) => string, decrypt: (msg: string) => string}) => string) {
+  const fkey = pub ? jwk2pub(key) : jwk2priv(key)
+  const fmsg = uint8ArrayToString(Uint8Array.from(msg), 'ascii')
+  const fomsg = handle(fmsg, fkey)
+  return uint8ArrayFromString(fomsg, 'ascii')
+}
+
+export function encrypt (key: JsonWebKey, msg: Uint8Array) {
+  return convertKey(key, true, msg, (msg, key) => key.encrypt(msg))
+}
+
+export function decrypt (key: JsonWebKey, msg: Uint8Array) {
+  return convertKey(key, false, msg, (msg, key) => key.decrypt(msg))
+}

package/src/keys/rsa-class.ts

@@ -0,0 +1,155 @@
+
+import { sha256 } from 'multiformats/hashes/sha2'
+import errcode from 'err-code'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import 'node-forge/lib/sha512.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import * as crypto from './rsa.js'
+import * as pbm from './keys.js'
+import { exporter } from './exporter.js'
+
+export class RsaPublicKey {
+  private readonly _key: JsonWebKey
+
+  constructor (key: JsonWebKey) {
+    this._key = key
+  }
+
+  async verify (data: Uint8Array, sig: Uint8Array) { // eslint-disable-line require-await
+    return await crypto.hashAndVerify(this._key, sig, data)
+  }
+
+  marshal () {
+    return crypto.utils.jwkToPkix(this._key)
+  }
+
+  get bytes () {
+    return pbm.PublicKey.encode({
+      Type: pbm.KeyType.RSA,
+      Data: this.marshal()
+    }).finish()
+  }
+
+  encrypt (bytes: Uint8Array) {
+    return crypto.encrypt(this._key, bytes)
+  }
+
+  equals (key: RsaPublicKey) {
+    return uint8ArrayEquals(this.bytes, key.bytes)
+  }
+
+  async hash () {
+    const { bytes } = await sha256.digest(this.bytes)
+
+    return bytes
+  }
+}
+
+export class RsaPrivateKey {
+  private readonly _key: JsonWebKey
+  private readonly _publicKey: JsonWebKey
+
+  constructor (key: JsonWebKey, publicKey: JsonWebKey) {
+    this._key = key
+    this._publicKey = publicKey
+  }
+
+  genSecret () {
+    return crypto.getRandomValues(16)
+  }
+
+  async sign (message: Uint8Array) { // eslint-disable-line require-await
+    return await crypto.hashAndSign(this._key, message)
+  }
+
+  get public () {
+    if (this._publicKey == null) {
+      throw errcode(new Error('public key not provided'), 'ERR_PUBKEY_NOT_PROVIDED')
+    }
+
+    return new RsaPublicKey(this._publicKey)
+  }
+
+  decrypt (bytes: Uint8Array) {
+    return crypto.decrypt(this._key, bytes)
+  }
+
+  marshal () {
+    return crypto.utils.jwkToPkcs1(this._key)
+  }
+
+  get bytes () {
+    return pbm.PrivateKey.encode({
+      Type: pbm.KeyType.RSA,
+      Data: this.marshal()
+    }).finish()
+  }
+
+  equals (key: RsaPrivateKey) {
+    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 SHA-256 multihash of its public key.
+   * The public key is a protobuf encoding containing a type and the DER encoding
+   * of the PKCS SubjectPublicKeyInfo.
+   */
+  async id () {
+    const hash = await this.public.hash()
+    return uint8ArrayToString(hash, 'base58btc')
+  }
+
+  /**
+   * Exports the key into a password protected PEM format
+   */
+  async export (password: string, format = 'pkcs-8') { // eslint-disable-line require-await
+    if (format === 'pkcs-8') {
+      const buffer = new forge.util.ByteBuffer(this.marshal())
+      const asn1 = forge.asn1.fromDer(buffer)
+      const privateKey = forge.pki.privateKeyFromAsn1(asn1)
+
+      const options = {
+        algorithm: 'aes256',
+        count: 10000,
+        saltSize: 128 / 8,
+        prfAlgorithm: 'sha512'
+      }
+      return forge.pki.encryptRsaPrivateKey(privateKey, password, options)
+    } else 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 async function unmarshalRsaPrivateKey (bytes: Uint8Array) {
+  const jwk = crypto.utils.pkcs1ToJwk(bytes)
+  const keys = await crypto.unmarshalPrivateKey(jwk)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}
+
+export function unmarshalRsaPublicKey (bytes: Uint8Array) {
+  const jwk = crypto.utils.pkixToJwk(bytes)
+  return new RsaPublicKey(jwk)
+}
+
+export async function fromJwk (jwk: JsonWebKey) {
+  const keys = await crypto.unmarshalPrivateKey(jwk)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}
+
+export async function generateKeyPair (bits: number) {
+  const keys = await crypto.generateKey(bits)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}