web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/ecdsa/utils.js

@@ -0,0 +1,153 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index$1 = require('../../../../../../uint8arraylist/dist/src/index.js');
+var fromString = require('../../../../../../uint8arrays/dist/src/from-string.js');
+var toString = require('../../../../../../uint8arrays/dist/src/to-string.js');
+var der = require('../rsa/der.js');
+var ecdsa = require('./ecdsa.js');
+var index = require('./index.js');
+
+// 1.2.840.10045.3.1.7 prime256v1 (ANSI X9.62 named elliptic curve)
+const OID_256 = Uint8Array.from([0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07]);
+// 1.3.132.0.34 secp384r1 (SECG (Certicom) named elliptic curve)
+const OID_384 = Uint8Array.from([0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22]);
+// 1.3.132.0.35 secp521r1 (SECG (Certicom) named elliptic curve)
+const OID_521 = Uint8Array.from([0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x23]);
+const P_256_KEY_JWK = {
+  ext: true,
+  kty: 'EC',
+  crv: 'P-256'
+};
+const P_384_KEY_JWK = {
+  ext: true,
+  kty: 'EC',
+  crv: 'P-384'
+};
+const P_521_KEY_JWK = {
+  ext: true,
+  kty: 'EC',
+  crv: 'P-521'
+};
+const P_256_KEY_LENGTH = 32;
+const P_384_KEY_LENGTH = 48;
+const P_521_KEY_LENGTH = 66;
+function pkiMessageToECDSAPrivateKey(message) {
+  const privateKey = message[1];
+  const d = toString.toString(privateKey, 'base64url');
+  const coordinates = message[2][1][0];
+  const offset = 1;
+  let x;
+  let y;
+  if (privateKey.byteLength === P_256_KEY_LENGTH) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_256_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_256_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPrivateKey({
+      ...P_256_KEY_JWK,
+      key_ops: ['sign'],
+      d,
+      x,
+      y
+    });
+  }
+  if (privateKey.byteLength === P_384_KEY_LENGTH) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_384_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_384_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPrivateKey({
+      ...P_384_KEY_JWK,
+      key_ops: ['sign'],
+      d,
+      x,
+      y
+    });
+  }
+  if (privateKey.byteLength === P_521_KEY_LENGTH) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_521_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_521_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPrivateKey({
+      ...P_521_KEY_JWK,
+      key_ops: ['sign'],
+      d,
+      x,
+      y
+    });
+  }
+  throw new _interface.InvalidParametersError(`Private key length was wrong length, got ${privateKey.byteLength}, expected 32, 48 or 66`);
+}
+function unmarshalECDSAPublicKey(bytes) {
+  const message = der.decodeDer(bytes);
+  return pkiMessageToECDSAPublicKey(message);
+}
+function pkiMessageToECDSAPublicKey(message) {
+  const coordinates = message[1][1][0];
+  const offset = 1;
+  let x;
+  let y;
+  if (coordinates.byteLength === P_256_KEY_LENGTH * 2 + 1) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_256_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_256_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPublicKey({
+      ...P_256_KEY_JWK,
+      key_ops: ['verify'],
+      x,
+      y
+    });
+  }
+  if (coordinates.byteLength === P_384_KEY_LENGTH * 2 + 1) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_384_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_384_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPublicKey({
+      ...P_384_KEY_JWK,
+      key_ops: ['verify'],
+      x,
+      y
+    });
+  }
+  if (coordinates.byteLength === P_521_KEY_LENGTH * 2 + 1) {
+    x = toString.toString(coordinates.subarray(offset, offset + P_521_KEY_LENGTH), 'base64url');
+    y = toString.toString(coordinates.subarray(offset + P_521_KEY_LENGTH), 'base64url');
+    return new ecdsa.ECDSAPublicKey({
+      ...P_521_KEY_JWK,
+      key_ops: ['verify'],
+      x,
+      y
+    });
+  }
+  throw new _interface.InvalidParametersError(`coordinates were wrong length, got ${coordinates.byteLength}, expected 65, 97 or 133`);
+}
+function privateKeyToPKIMessage(privateKey) {
+  return der.encodeSequence([der.encodeInteger(Uint8Array.from([1])),
+  // header
+  der.encodeOctetString(fromString.fromString(privateKey.d ?? '', 'base64url')),
+  // body
+  der.encodeSequence([getOID(privateKey.crv)], 0xA0), der.encodeSequence([der.encodeBitString(new index$1.Uint8ArrayList(Uint8Array.from([0x04]), fromString.fromString(privateKey.x ?? '', 'base64url'), fromString.fromString(privateKey.y ?? '', 'base64url')))], 0xA1)]).subarray();
+}
+function publicKeyToPKIMessage(publicKey) {
+  return der.encodeSequence([der.encodeInteger(Uint8Array.from([1])),
+  // header
+  der.encodeSequence([getOID(publicKey.crv)], 0xA0), der.encodeSequence([der.encodeBitString(new index$1.Uint8ArrayList(Uint8Array.from([0x04]), fromString.fromString(publicKey.x ?? '', 'base64url'), fromString.fromString(publicKey.y ?? '', 'base64url')))], 0xA1)]).subarray();
+}
+function getOID(curve) {
+  if (curve === 'P-256') {
+    return OID_256;
+  }
+  if (curve === 'P-384') {
+    return OID_384;
+  }
+  if (curve === 'P-521') {
+    return OID_521;
+  }
+  throw new _interface.InvalidParametersError(`Invalid curve ${curve}`);
+}
+async function generateECDSAKeyPair() {
+  let curve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'P-256';
+  const key = await index.generateECDSAKey(curve);
+  return new ecdsa.ECDSAPrivateKey(key.privateKey);
+}
+
+exports.generateECDSAKeyPair = generateECDSAKeyPair;
+exports.pkiMessageToECDSAPrivateKey = pkiMessageToECDSAPrivateKey;
+exports.pkiMessageToECDSAPublicKey = pkiMessageToECDSAPublicKey;
+exports.privateKeyToPKIMessage = privateKeyToPKIMessage;
+exports.publicKeyToPKIMessage = publicKeyToPKIMessage;
+exports.unmarshalECDSAPublicKey = unmarshalECDSAPublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/ed25519/ed25519.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var base58 = require('../../../../../../multiformats/dist/src/bases/base58.js');
+var cid = require('../../../../../../multiformats/dist/src/cid.js');
+var identity = require('../../../../../../multiformats/dist/src/hashes/identity.js');
+var equals = require('../../../../../../uint8arrays/dist/src/equals.js');
+var index = require('../index.js');
+var utils = require('./utils.js');
+var index_browser = require('./index.browser.js');
+
+class Ed25519PublicKey {
+  type = 'Ed25519';
+  raw;
+  constructor(key) {
+    this.raw = utils.ensureEd25519Key(key, index_browser.publicKeyLength);
+  }
+  toMultihash() {
+    return identity.identity.digest(index.publicKeyToProtobuf(this));
+  }
+  toCID() {
+    return cid.CID.createV1(114, this.toMultihash());
+  }
+  toString() {
+    return base58.base58btc.encode(this.toMultihash().bytes).substring(1);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  verify(data, sig) {
+    return index_browser.hashAndVerify(this.raw, sig, data);
+  }
+}
+class Ed25519PrivateKey {
+  type = 'Ed25519';
+  raw;
+  publicKey;
+  // key       - 64 byte Uint8Array containing private key
+  // publicKey - 32 byte Uint8Array containing public key
+  constructor(key, publicKey) {
+    this.raw = utils.ensureEd25519Key(key, index_browser.privateKeyLength);
+    this.publicKey = new Ed25519PublicKey(publicKey);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals.equals(this.raw, key.raw);
+  }
+  sign(message) {
+    return index_browser.hashAndSign(this.raw, message);
+  }
+}
+
+exports.Ed25519PrivateKey = Ed25519PrivateKey;
+exports.Ed25519PublicKey = Ed25519PublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/ed25519/index.browser.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var ed25519 = require('../../../../../../@noble/curves/esm/ed25519.js');
+
+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;
+function hashAndSign(privateKey, msg) {
+  const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH);
+  return ed25519.ed25519.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw);
+}
+function hashAndVerify(publicKey, sig, msg) {
+  return ed25519.ed25519.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey);
+}
+
+exports.hashAndSign = hashAndSign;
+exports.hashAndVerify = hashAndVerify;
+exports.privateKeyLength = PRIVATE_KEY_BYTE_LENGTH;
+exports.publicKeyLength = PUBLIC_KEY_BYTE_LENGTH;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/ed25519/utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var ed25519 = require('./ed25519.js');
+var index_browser = require('./index.browser.js');
+
+function unmarshalEd25519PrivateKey(bytes) {
+  // Try the old, redundant public key version
+  if (bytes.length > index_browser.privateKeyLength) {
+    bytes = ensureEd25519Key(bytes, index_browser.privateKeyLength + index_browser.publicKeyLength);
+    const privateKeyBytes = bytes.subarray(0, index_browser.privateKeyLength);
+    const publicKeyBytes = bytes.subarray(index_browser.privateKeyLength, bytes.length);
+    return new ed25519.Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
+  }
+  bytes = ensureEd25519Key(bytes, index_browser.privateKeyLength);
+  const privateKeyBytes = bytes.subarray(0, index_browser.privateKeyLength);
+  const publicKeyBytes = bytes.subarray(index_browser.publicKeyLength);
+  return new ed25519.Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
+}
+function unmarshalEd25519PublicKey(bytes) {
+  bytes = ensureEd25519Key(bytes, index_browser.publicKeyLength);
+  return new ed25519.Ed25519PublicKey(bytes);
+}
+function ensureEd25519Key(key, length) {
+  key = Uint8Array.from(key ?? []);
+  if (key.length !== length) {
+    throw new _interface.InvalidParametersError(`Key must be a Uint8Array of length ${length}, got ${key.length}`);
+  }
+  return key;
+}
+
+exports.ensureEd25519Key = ensureEd25519Key;
+exports.unmarshalEd25519PrivateKey = unmarshalEd25519PrivateKey;
+exports.unmarshalEd25519PublicKey = unmarshalEd25519PublicKey;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/index.js

@@ -0,0 +1,151 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index = require('./ecdsa/index.js');
+var utils$2 = require('./ecdsa/utils.js');
+var index_browser = require('./ed25519/index.browser.js');
+var utils = require('./ed25519/utils.js');
+var keys = require('./keys.js');
+var der = require('./rsa/der.js');
+var index_browser$2 = require('./rsa/index.browser.js');
+var utils$3 = require('./rsa/utils.js');
+var index_browser$1 = require('./secp256k1/index.browser.js');
+var utils$1 = require('./secp256k1/utils.js');
+
+/**
+ * @packageDocumentation
+ *
+ * ## Supported Key Types
+ *
+ * Currently the `'RSA'`, `'ed25519'`, and `secp256k1` types are supported, although ed25519 and secp256k1 keys support only signing and verification of messages.
+ *
+ * For encryption / decryption support, RSA keys should be used.
+ */
+async function generateKeyPair(type, bits) {
+  {
+    return utils$2.generateECDSAKeyPair(toCurve());
+  }
+}
+/**
+ * Converts a protobuf serialized public key into its representative object.
+ *
+ * For RSA public keys optionally pass the multihash digest of the public key if
+ * it is known. If the digest is omitted it will be calculated which can be
+ * expensive.
+ *
+ * For other key types the digest option is ignored.
+ */
+function publicKeyFromProtobuf(buf, digest) {
+  const {
+    Type,
+    Data
+  } = keys.PublicKey.decode(buf);
+  const data = Data ?? new Uint8Array();
+  switch (Type) {
+    case keys.KeyType.RSA:
+      return utils$3.pkixToRSAPublicKey(data, digest);
+    case keys.KeyType.Ed25519:
+      return utils.unmarshalEd25519PublicKey(data);
+    case keys.KeyType.secp256k1:
+      return utils$1.unmarshalSecp256k1PublicKey(data);
+    case keys.KeyType.ECDSA:
+      return utils$2.unmarshalECDSAPublicKey(data);
+    default:
+      throw new _interface.UnsupportedKeyTypeError();
+  }
+}
+/**
+ * Creates a public key from the raw key bytes
+ */
+function publicKeyFromRaw(buf) {
+  if (buf.byteLength === index_browser.publicKeyLength) {
+    return utils.unmarshalEd25519PublicKey(buf);
+  } else if (buf.byteLength === index_browser$1.publicKeyLength) {
+    return utils$1.unmarshalSecp256k1PublicKey(buf);
+  }
+  const message = der.decodeDer(buf);
+  const ecdsaOid = message[1]?.[0];
+  if (ecdsaOid === index.ECDSA_P_256_OID || ecdsaOid === index.ECDSA_P_384_OID || ecdsaOid === index.ECDSA_P_521_OID) {
+    return utils$2.pkiMessageToECDSAPublicKey(message);
+  }
+  if (message[0]?.[0] === index_browser$2.RSAES_PKCS1_V1_5_OID) {
+    return utils$3.pkixMessageToRSAPublicKey(message, buf);
+  }
+  throw new _interface.InvalidParametersError('Could not extract public key from raw bytes');
+}
+/**
+ * Converts a public key object into a protobuf serialized public key
+ */
+function publicKeyToProtobuf(key) {
+  return keys.PublicKey.encode({
+    Type: keys.KeyType[key.type],
+    Data: key.raw
+  });
+}
+/**
+ * Creates a private key from the raw key bytes. For Ed25519 keys this requires
+ * the public key to be appended to the private key otherwise we can't
+ * differentiate between Ed25519 and secp256k1 keys as they are the same length.
+ */
+function privateKeyFromRaw(buf) {
+  if (buf.byteLength === index_browser.privateKeyLength) {
+    return utils.unmarshalEd25519PrivateKey(buf);
+  } else if (buf.byteLength === index_browser$1.privateKeyLength) {
+    return utils$1.unmarshalSecp256k1PrivateKey(buf);
+  }
+  const message = der.decodeDer(buf);
+  const ecdsaOid = message[2]?.[0];
+  if (ecdsaOid === index.ECDSA_P_256_OID || ecdsaOid === index.ECDSA_P_384_OID || ecdsaOid === index.ECDSA_P_521_OID) {
+    return utils$2.pkiMessageToECDSAPrivateKey(message);
+  }
+  if (message.length > 8) {
+    return utils$3.pkcs1MessageToRSAPrivateKey(message);
+  }
+  throw new _interface.InvalidParametersError('Could not extract private key from raw bytes');
+}
+function toCurve(curve) {
+  {
+    return 'P-256';
+  }
+}
+/**
+ * Convert a libp2p RSA or ECDSA private key to a WebCrypto CryptoKeyPair
+ */
+async function privateKeyToCryptoKeyPair(privateKey) {
+  if (privateKey.type === 'RSA') {
+    return {
+      privateKey: await crypto.subtle.importKey('jwk', privateKey.jwk, {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: {
+          name: 'SHA-256'
+        }
+      }, true, ['sign']),
+      publicKey: await crypto.subtle.importKey('jwk', privateKey.publicKey.jwk, {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: {
+          name: 'SHA-256'
+        }
+      }, true, ['verify'])
+    };
+  }
+  if (privateKey.type === 'ECDSA') {
+    return {
+      privateKey: await crypto.subtle.importKey('jwk', privateKey.jwk, {
+        name: 'ECDSA',
+        namedCurve: privateKey.jwk.crv ?? 'P-256'
+      }, true, ['sign']),
+      publicKey: await crypto.subtle.importKey('jwk', privateKey.publicKey.jwk, {
+        name: 'ECDSA',
+        namedCurve: privateKey.publicKey.jwk.crv ?? 'P-256'
+      }, true, ['verify'])
+    };
+  }
+  throw new _interface.InvalidParametersError('Only RSA and ECDSA keys are supported');
+}
+
+exports.generateKeyPair = generateKeyPair;
+exports.privateKeyFromRaw = privateKeyFromRaw;
+exports.privateKeyToCryptoKeyPair = privateKeyToCryptoKeyPair;
+exports.publicKeyFromProtobuf = publicKeyFromProtobuf;
+exports.publicKeyFromRaw = publicKeyFromRaw;
+exports.publicKeyToProtobuf = publicKeyToProtobuf;

package/dist/cjs/node_modules/@libp2p/crypto/dist/src/keys/keys.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+var _enum = require('../../../../../protons-runtime/dist/src/codecs/enum.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+require('../../../../../protons-runtime/dist/src/utils/float.js');
+require('../../../../../protons-runtime/dist/src/utils/longbits.js');
+require('../../../../../protons-runtime/dist/src/utils/writer.js');
+
+exports.KeyType = void 0;
+(function (KeyType) {
+  KeyType["RSA"] = "RSA";
+  KeyType["Ed25519"] = "Ed25519";
+  KeyType["secp256k1"] = "secp256k1";
+  KeyType["ECDSA"] = "ECDSA";
+})(exports.KeyType || (exports.KeyType = {}));
+var __KeyTypeValues;
+(function (__KeyTypeValues) {
+  __KeyTypeValues[__KeyTypeValues["RSA"] = 0] = "RSA";
+  __KeyTypeValues[__KeyTypeValues["Ed25519"] = 1] = "Ed25519";
+  __KeyTypeValues[__KeyTypeValues["secp256k1"] = 2] = "secp256k1";
+  __KeyTypeValues[__KeyTypeValues["ECDSA"] = 3] = "ECDSA";
+})(__KeyTypeValues || (__KeyTypeValues = {}));
+(function (KeyType) {
+  KeyType.codec = () => {
+    return _enum.enumeration(__KeyTypeValues);
+  };
+})(exports.KeyType || (exports.KeyType = {}));
+exports.PublicKey = void 0;
+(function (PublicKey) {
+  let _codec;
+  PublicKey.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.Type != null) {
+          w.uint32(8);
+          exports.KeyType.codec().encode(obj.Type, w);
+        }
+        if (obj.Data != null) {
+          w.uint32(18);
+          w.bytes(obj.Data);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.Type = exports.KeyType.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                obj.Data = reader.bytes();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  PublicKey.encode = obj => {
+    return encode.encodeMessage(obj, PublicKey.codec());
+  };
+  PublicKey.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, PublicKey.codec(), opts);
+  };
+})(exports.PublicKey || (exports.PublicKey = {}));
+exports.PrivateKey = void 0;
+(function (PrivateKey) {
+  let _codec;
+  PrivateKey.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.Type != null) {
+          w.uint32(8);
+          exports.KeyType.codec().encode(obj.Type, w);
+        }
+        if (obj.Data != null) {
+          w.uint32(18);
+          w.bytes(obj.Data);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.Type = exports.KeyType.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                obj.Data = reader.bytes();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  PrivateKey.encode = obj => {
+    return encode.encodeMessage(obj, PrivateKey.codec());
+  };
+  PrivateKey.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, PrivateKey.codec(), opts);
+  };
+})(exports.PrivateKey || (exports.PrivateKey = {}));