libp2p 0.36.0 → 0.36.2-199395d

package/src/insecure/{proto.d.ts → pb/proto.d.ts}

@@ -19,11 +19,17 @@ export class Exchange implements IExchange {
     constructor(p?: IExchange);
 
     /** Exchange id. */
-    public id: Uint8Array;
+    public id?: (Uint8Array|null);
 
     /** Exchange pubkey. */
     public pubkey?: (IPublicKey|null);
 
+    /** Exchange _id. */
+    public _id?: "id";
+
+    /** Exchange _pubkey. */
+    public _pubkey?: "pubkey";
+
     /**
      * Encodes the specified Exchange message. Does not implicitly {@link Exchange.verify|verify} messages.
      * @param m Exchange message or plain object to encode

package/src/insecure/pb/proto.js

@@ -0,0 +1,388 @@
+/*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-plaintext"] || ($protobuf.roots["libp2p-plaintext"] = {});
+
+export const Exchange = $root.Exchange = (() => {
+
+    /**
+     * Properties of an Exchange.
+     * @exports IExchange
+     * @interface IExchange
+     * @property {Uint8Array|null} [id] Exchange id
+     * @property {IPublicKey|null} [pubkey] Exchange pubkey
+     */
+
+    /**
+     * Constructs a new Exchange.
+     * @exports Exchange
+     * @classdesc Represents an Exchange.
+     * @implements IExchange
+     * @constructor
+     * @param {IExchange=} [p] Properties to set
+     */
+    function Exchange(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]];
+    }
+
+    /**
+     * Exchange id.
+     * @member {Uint8Array|null|undefined} id
+     * @memberof Exchange
+     * @instance
+     */
+    Exchange.prototype.id = null;
+
+    /**
+     * Exchange pubkey.
+     * @member {IPublicKey|null|undefined} pubkey
+     * @memberof Exchange
+     * @instance
+     */
+    Exchange.prototype.pubkey = null;
+
+    // OneOf field names bound to virtual getters and setters
+    let $oneOfFields;
+
+    /**
+     * Exchange _id.
+     * @member {"id"|undefined} _id
+     * @memberof Exchange
+     * @instance
+     */
+    Object.defineProperty(Exchange.prototype, "_id", {
+        get: $util.oneOfGetter($oneOfFields = ["id"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Exchange _pubkey.
+     * @member {"pubkey"|undefined} _pubkey
+     * @memberof Exchange
+     * @instance
+     */
+    Object.defineProperty(Exchange.prototype, "_pubkey", {
+        get: $util.oneOfGetter($oneOfFields = ["pubkey"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Encodes the specified Exchange message. Does not implicitly {@link Exchange.verify|verify} messages.
+     * @function encode
+     * @memberof Exchange
+     * @static
+     * @param {IExchange} m Exchange message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Exchange.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.id != null && Object.hasOwnProperty.call(m, "id"))
+            w.uint32(10).bytes(m.id);
+        if (m.pubkey != null && Object.hasOwnProperty.call(m, "pubkey"))
+            $root.PublicKey.encode(m.pubkey, w.uint32(18).fork()).ldelim();
+        return w;
+    };
+
+    /**
+     * Decodes an Exchange message from the specified reader or buffer.
+     * @function decode
+     * @memberof Exchange
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {Exchange} Exchange
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Exchange.decode = function decode(r, l) {
+        if (!(r instanceof $Reader))
+            r = $Reader.create(r);
+        var c = l === undefined ? r.len : r.pos + l, m = new $root.Exchange();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.id = r.bytes();
+                break;
+            case 2:
+                m.pubkey = $root.PublicKey.decode(r, r.uint32());
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates an Exchange message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof Exchange
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {Exchange} Exchange
+     */
+    Exchange.fromObject = function fromObject(d) {
+        if (d instanceof $root.Exchange)
+            return d;
+        var m = new $root.Exchange();
+        if (d.id != null) {
+            if (typeof d.id === "string")
+                $util.base64.decode(d.id, m.id = $util.newBuffer($util.base64.length(d.id)), 0);
+            else if (d.id.length)
+                m.id = d.id;
+        }
+        if (d.pubkey != null) {
+            if (typeof d.pubkey !== "object")
+                throw TypeError(".Exchange.pubkey: object expected");
+            m.pubkey = $root.PublicKey.fromObject(d.pubkey);
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from an Exchange message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof Exchange
+     * @static
+     * @param {Exchange} m Exchange
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Exchange.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (m.id != null && m.hasOwnProperty("id")) {
+            d.id = o.bytes === String ? $util.base64.encode(m.id, 0, m.id.length) : o.bytes === Array ? Array.prototype.slice.call(m.id) : m.id;
+            if (o.oneofs)
+                d._id = "id";
+        }
+        if (m.pubkey != null && m.hasOwnProperty("pubkey")) {
+            d.pubkey = $root.PublicKey.toObject(m.pubkey, o);
+            if (o.oneofs)
+                d._pubkey = "pubkey";
+        }
+        return d;
+    };
+
+    /**
+     * Converts this Exchange to JSON.
+     * @function toJSON
+     * @memberof Exchange
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Exchange.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return Exchange;
+})();
+
+/**
+ * KeyType enum.
+ * @exports KeyType
+ * @enum {number}
+ * @property {number} RSA=0 RSA value
+ * @property {number} Ed25519=1 Ed25519 value
+ * @property {number} Secp256k1=2 Secp256k1 value
+ * @property {number} ECDSA=3 ECDSA 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;
+    values[valuesById[3] = "ECDSA"] = 3;
+    return values;
+})();
+
+export const PublicKey = $root.PublicKey = (() => {
+
+    /**
+     * Properties of a PublicKey.
+     * @exports IPublicKey
+     * @interface IPublicKey
+     * @property {KeyType|null} [Type] PublicKey Type
+     * @property {Uint8Array|null} [Data] PublicKey Data
+     */
+
+    /**
+     * Constructs a new PublicKey.
+     * @exports PublicKey
+     * @classdesc Represents a PublicKey.
+     * @implements IPublicKey
+     * @constructor
+     * @param {IPublicKey=} [p] Properties to set
+     */
+    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();
+        if (m.Type != null && Object.hasOwnProperty.call(m, "Type"))
+            w.uint32(8).int32(m.Type);
+        if (m.Data != null && Object.hasOwnProperty.call(m, "Data"))
+            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 $root.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;
+            }
+        }
+        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 $root.PublicKey)
+            return d;
+        var m = new $root.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;
+        case "ECDSA":
+        case 3:
+            m.Type = 3;
+            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);
+    };
+
+    return PublicKey;
+})();
+
+export { $root as default };

package/src/keychain/{cms.js → cms.ts}

@@ -1,18 +1,18 @@
-'use strict'
-
-// @ts-ignore node-forge types not exported
-require('node-forge/lib/pkcs7')
-// @ts-ignore node-forge types not exported
-require('node-forge/lib/pbe')
-// @ts-ignore node-forge types not exported
-const forge = require('node-forge/lib/forge')
-const { certificateForKey, findAsync } = require('./util')
-const errcode = require('err-code')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { codes } = require('../errors')
-
-const privates = new WeakMap()
+import 'node-forge/lib/pkcs7.js'
+import 'node-forge/lib/pbe.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { certificateForKey, findAsync } from './util.js'
+import errCode from 'err-code'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { codes } from '../errors.js'
+import { logger } from '@libp2p/logger'
+import type { KeyChain } from './index.js'
+
+const log = logger('libp2p:keychain:cms')
+
+const privates = new WeakMap<object, { dek: string }>()
 
 /**
  * Cryptographic Message Syntax (aka PKCS #7)
@@ -23,16 +23,15 @@ const privates = new WeakMap()
  *
  * See RFC 5652 for all the details.
  */
-class CMS {
+export class CMS {
+  private readonly keychain: KeyChain
+
   /**
    * Creates a new instance with a keychain
-   *
-   * @param {import('./index')} keychain - the available keys
-   * @param {string} dek
    */
-  constructor (keychain, dek) {
-    if (!keychain) {
-      throw errcode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
+  constructor (keychain: KeyChain, dek: string) {
+    if (keychain == null) {
+      throw errCode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
     }
 
     this.keychain = keychain
@@ -43,20 +42,21 @@ class CMS {
    * Creates some protected data.
    *
    * The output Uint8Array contains the PKCS #7 message in DER.
-   *
-   * @param {string} name - The local key name.
-   * @param {Uint8Array} plain - The data to encrypt.
-   * @returns {Promise<Uint8Array>}
    */
-  async encrypt (name, plain) {
+  async encrypt (name: string, plain: Uint8Array): Promise<Uint8Array> {
     if (!(plain instanceof Uint8Array)) {
-      throw errcode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
+      throw errCode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
     }
 
     const key = await this.keychain.findKeyByName(name)
-    const pem = await this.keychain._getPrivateKey(name)
-    /** @type {string} */
-    const dek = privates.get(this).dek
+    const pem = await this.keychain.getPrivateKey(name)
+    const cached = privates.get(this)
+
+    if (cached == null) {
+      throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const dek = cached.dek
     const privateKey = forge.pki.decryptRsaPrivateKey(pem, dek)
     const certificate = await certificateForKey(key, privateKey)
 
@@ -76,71 +76,75 @@ class CMS {
    *
    * The keychain must contain one of the keys used to encrypt the data.  If none of the keys
    * exists, an Error is returned with the property 'missingKeys'.  It is array of key ids.
-   *
-   * @param {Uint8Array} cmsData - The CMS encrypted data to decrypt.
-   * @returns {Promise<Uint8Array>}
    */
-  async decrypt (cmsData) {
+  async decrypt (cmsData: Uint8Array): Promise<Uint8Array> {
     if (!(cmsData instanceof Uint8Array)) {
-      throw errcode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
+      throw errCode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    let cms
+    let cms: any
     try {
       const buf = forge.util.createBuffer(uint8ArrayToString(cmsData, 'ascii'))
       const obj = forge.asn1.fromDer(buf)
-      // @ts-ignore not defined
+
       cms = forge.pkcs7.messageFromAsn1(obj)
-    } catch (/** @type {any} */ err) {
-      throw errcode(new Error('Invalid CMS: ' + err.message), codes.ERR_INVALID_CMS)
+    } catch (err: any) {
+      log.error(err)
+      throw errCode(new Error('Invalid CMS'), codes.ERR_INVALID_CMS)
     }
 
     // Find a recipient whose key we hold. We only deal with recipient certs
     // issued by ipfs (O=ipfs).
-    const recipients = cms.recipients
-      // @ts-ignore cms types not defined
+    const recipients: any = cms.recipients
+      // @ts-expect-error cms types not defined
       .filter(r => r.issuer.find(a => a.shortName === 'O' && a.value === 'ipfs'))
-      // @ts-ignore cms types not defined
+      // @ts-expect-error cms types not defined
       .filter(r => r.issuer.find(a => a.shortName === 'CN'))
-      // @ts-ignore cms types not defined
+      // @ts-expect-error cms types not defined
       .map(r => {
         return {
           recipient: r,
-          // @ts-ignore cms types not defined
+          // @ts-expect-error cms types not defined
           keyId: r.issuer.find(a => a.shortName === 'CN').value
         }
       })
 
-    const r = await findAsync(recipients, async (recipient) => {
+    const r = await findAsync(recipients, async (recipient: any) => {
       try {
         const key = await this.keychain.findKeyById(recipient.keyId)
-        if (key) return true
-      } catch (/** @type {any} */ err) {
+        if (key != null) {
+          return true
+        }
+      } catch (err: any) {
         return false
       }
       return false
     })
 
-    if (!r) {
-      // @ts-ignore cms types not defined
-      const missingKeys = recipients.map(r => r.keyId)
-      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), codes.ERR_MISSING_KEYS, {
+    if (r == null) {
+      // @ts-expect-error cms types not defined
+      const missingKeys: string[] = recipients.map(r => r.keyId)
+      throw errCode(new Error(`Decryption needs one of the key(s): ${missingKeys.join(', ')}`), codes.ERR_MISSING_KEYS, {
         missingKeys
       })
     }
 
     const key = await this.keychain.findKeyById(r.keyId)
 
-    if (!key) {
-      throw errcode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
+    if (key == null) {
+      throw errCode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
+    }
+
+    const pem = await this.keychain.getPrivateKey(key.name)
+    const cached = privates.get(this)
+
+    if (cached == null) {
+      throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const pem = await this.keychain._getPrivateKey(key.name)
-    const dek = privates.get(this).dek
+    const dek = cached.dek
     const privateKey = forge.pki.decryptRsaPrivateKey(pem, dek)
     cms.decrypt(r.recipient, privateKey)
     return uint8ArrayFromString(cms.content.getBytes(), 'ascii')
   }
 }
-
-module.exports = CMS