web-dc-api 0.0.61 → 0.0.62

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/transport/transport.js

@@ -1,7 +1,7 @@
-import { serviceCapabilities, serviceDependencies, transportSymbol, setMaxListeners, start, stop, DialError, InvalidMessageError } from '@libp2p/interface';
-import { peerIdFromString, peerIdFromMultihash } from '@libp2p/peer-id';
+import { serviceCapabilities, serviceDependencies } from '../../../../interface/dist/src/index.js';
+import { peerIdFromString, peerIdFromMultihash } from '../../../../peer-id/dist/src/index.js';
 import { streamToMaConnection } from '../../../../utils/dist/src/stream-to-ma-conn.js';
-import { multiaddr } from '@multiformats/multiaddr';
+import { multiaddr } from '../../../../../@multiformats/multiaddr/dist/src/index.js';
 import { Circuit } from '../../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
 import { pbStream } from '../../../../../it-protobuf-stream/dist/src/index.js';
 import { decode } from '../../../../../multiformats/dist/src/hashes/digest.js';
@@ -13,6 +13,10 @@ import { RelayDiscovery } from './discovery.js';
 import { createListener } from './listener.js';
 import { ReservationStore } from './reservation-store.js';
 import { peerFilter } from '../../../../peer-collections/dist/src/filter.js';
+import { transportSymbol } from '../../../../interface/dist/src/transport.js';
+import { start, stop } from '../../../../interface/dist/src/startable.js';
+import { DialError, InvalidMessageError } from '../../../../interface/dist/src/errors.js';
+import { setMaxListeners } from '../../../../interface/dist/src/events.browser.js';
 
 const isValidStop = request => {
   if (request.peer == null) {

package/dist/esm/node_modules/@libp2p/config/dist/src/load-private-key.js

@@ -0,0 +1,24 @@
+import { generateKeyPair } from '../../../crypto/dist/src/keys/index.js';
+import { keychain } from '../../../keychain/dist/src/index.js';
+import { defaultLogger } from '../../../logger/dist/src/index.js';
+import { Key } from '../../../../interface-datastore/dist/src/key.js';
+
+async function loadOrCreateSelfKey(datastore) {
+  let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const selfKey = init.selfKey ?? 'self';
+  const chain = keychain(init)({
+    datastore,
+    logger: defaultLogger()
+  });
+  let privateKey;
+  if (await datastore.has(new Key(`/pkcs8/${selfKey}`))) {
+    privateKey = await chain.exportKey(selfKey);
+  } else {
+    privateKey = await generateKeyPair(init.keyType ?? 'Ed25519');
+    // persist the peer id in the keychain for next time
+    await chain.importKey(selfKey, privateKey);
+  }
+  return privateKey;
+}
+
+export { loadOrCreateSelfKey };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/ciphers/aes-gcm.browser.js

@@ -0,0 +1,164 @@
+import { concat } from '../../../../../uint8arrays/dist/src/concat.js';
+import { fromString } from '../../../../../uint8arrays/dist/src/from-string.js';
+import webcrypto from '../webcrypto/webcrypto.browser.js';
+
+// WebKit on Linux does not support deriving a key from an empty PBKDF2 key.
+// So, as a workaround, we provide the generated key as a constant. We test that
+// this generated key is accurate in test/workaround.spec.ts
+// Generated via:
+// await crypto.subtle.exportKey('jwk',
+//   await crypto.subtle.deriveKey(
+//     { name: 'PBKDF2', salt: new Uint8Array(16), iterations: 32767, hash: { name: 'SHA-256' } },
+//     await crypto.subtle.importKey('raw', new Uint8Array(0), { name: 'PBKDF2' }, false, ['deriveKey']),
+//     { name: 'AES-GCM', length: 128 }, true, ['encrypt', 'decrypt'])
+// )
+const derivedEmptyPasswordKey = {
+  alg: 'A128GCM',
+  ext: true,
+  /* spell-checker:disable-next-line */
+  k: 'scm9jmO_4BJAgdwWGVulLg',
+  key_ops: ['encrypt', 'decrypt'],
+  kty: 'oct'
+};
+// Based off of code from https://github.com/luke-park/SecureCompatibleEncryptionExamples
+function create(opts) {
+  const algorithm = 'AES-GCM';
+  let keyLength = 16;
+  const nonceLength = 12;
+  const digest = 'SHA-256';
+  const saltLength = 16;
+  const 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, password) {
+    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);
+    }
+    let cryptoKey;
+    if (password.length === 0) {
+      cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, {
+        name: 'AES-GCM'
+      }, true, ['encrypt']);
+      try {
+        const deriveParams = {
+          name: 'PBKDF2',
+          salt,
+          iterations,
+          hash: {
+            name: digest
+          }
+        };
+        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, {
+          name: 'PBKDF2'
+        }, false, ['deriveKey']);
+        cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, {
+          name: algorithm,
+          length: keyLength
+        }, true, ['encrypt']);
+      } catch {
+        cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, {
+          name: 'AES-GCM'
+        }, true, ['encrypt']);
+      }
+    } else {
+      // 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']);
+      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, password) {
+    const salt = data.subarray(0, saltLength);
+    const nonce = data.subarray(saltLength, saltLength + nonceLength);
+    const ciphertext = data.subarray(saltLength + nonceLength);
+    const aesGcm = {
+      name: algorithm,
+      iv: nonce
+    };
+    if (typeof password === 'string') {
+      password = fromString(password);
+    }
+    let cryptoKey;
+    if (password.length === 0) {
+      try {
+        const deriveParams = {
+          name: 'PBKDF2',
+          salt,
+          iterations,
+          hash: {
+            name: digest
+          }
+        };
+        const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, {
+          name: 'PBKDF2'
+        }, false, ['deriveKey']);
+        cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, {
+          name: algorithm,
+          length: keyLength
+        }, true, ['decrypt']);
+      } catch {
+        cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, {
+          name: 'AES-GCM'
+        }, true, ['decrypt']);
+      }
+    } else {
+      // 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']);
+      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 = {
+    encrypt,
+    decrypt
+  };
+  return cipher;
+}
+
+export { create, derivedEmptyPasswordKey };

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

@@ -1,10 +1,10 @@
-import { InvalidParametersError } from '@libp2p/interface';
 import { Uint8ArrayList } from '../../../../../../uint8arraylist/dist/src/index.js';
 import { fromString } from '../../../../../../uint8arrays/dist/src/from-string.js';
 import { toString } from '../../../../../../uint8arrays/dist/src/to-string.js';
 import { decodeDer, encodeSequence, encodeInteger, encodeBitString, encodeOctetString } from '../rsa/der.js';
 import { ECDSAPublicKey, ECDSAPrivateKey } from './ecdsa.js';
 import { generateECDSAKey } from './index.js';
+import { InvalidParametersError } from '../../../../../interface/dist/src/errors.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]);
@@ -30,6 +30,10 @@ const P_521_KEY_JWK = {
 const P_256_KEY_LENGTH = 32;
 const P_384_KEY_LENGTH = 48;
 const P_521_KEY_LENGTH = 66;
+function unmarshalECDSAPrivateKey(bytes) {
+  const message = decodeDer(bytes);
+  return pkiMessageToECDSAPrivateKey(message);
+}
 function pkiMessageToECDSAPrivateKey(message) {
   const privateKey = message[1];
   const d = toString(privateKey, 'base64url');
@@ -143,4 +147,4 @@ async function generateECDSAKeyPair() {
   return new ECDSAPrivateKey(key.privateKey);
 }
 
-export { generateECDSAKeyPair, pkiMessageToECDSAPrivateKey, pkiMessageToECDSAPublicKey, privateKeyToPKIMessage, publicKeyToPKIMessage, unmarshalECDSAPublicKey };
+export { generateECDSAKeyPair, pkiMessageToECDSAPrivateKey, pkiMessageToECDSAPublicKey, privateKeyToPKIMessage, publicKeyToPKIMessage, unmarshalECDSAPrivateKey, unmarshalECDSAPublicKey };

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

@@ -3,6 +3,17 @@ import { ed25519 } from '../../../../../../@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 generateKey() {
+  // the actual private key (32 bytes)
+  const privateKeyRaw = ed25519.utils.randomPrivateKey();
+  const publicKey = ed25519.getPublicKey(privateKeyRaw);
+  // concatenated the public key to the private key
+  const privateKey = concatKeys(privateKeyRaw, publicKey);
+  return {
+    privateKey,
+    publicKey
+  };
+}
 function hashAndSign(privateKey, msg) {
   const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH);
   return ed25519.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw);
@@ -10,5 +21,13 @@ function hashAndSign(privateKey, msg) {
 function hashAndVerify(publicKey, sig, msg) {
   return ed25519.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey);
 }
+function concatKeys(privateKeyRaw, publicKey) {
+  const privateKey = new Uint8Array(PRIVATE_KEY_BYTE_LENGTH);
+  for (let i = 0; i < KEYS_BYTE_LENGTH; i++) {
+    privateKey[i] = privateKeyRaw[i];
+    privateKey[KEYS_BYTE_LENGTH + i] = publicKey[i];
+  }
+  return privateKey;
+}
 
-export { hashAndSign, hashAndVerify, PRIVATE_KEY_BYTE_LENGTH as privateKeyLength, PUBLIC_KEY_BYTE_LENGTH as publicKeyLength };
+export { generateKey, hashAndSign, hashAndVerify, PRIVATE_KEY_BYTE_LENGTH as privateKeyLength, PUBLIC_KEY_BYTE_LENGTH as publicKeyLength };

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

@@ -1,6 +1,6 @@
-import { InvalidParametersError } from '@libp2p/interface';
 import { Ed25519PublicKey, Ed25519PrivateKey } from './ed25519.js';
-import { privateKeyLength as PRIVATE_KEY_BYTE_LENGTH, publicKeyLength as PUBLIC_KEY_BYTE_LENGTH } from './index.browser.js';
+import { generateKey, privateKeyLength as PRIVATE_KEY_BYTE_LENGTH, publicKeyLength as PUBLIC_KEY_BYTE_LENGTH } from './index.browser.js';
+import { InvalidParametersError } from '../../../../../interface/dist/src/errors.js';
 
 function unmarshalEd25519PrivateKey(bytes) {
   // Try the old, redundant public key version
@@ -19,6 +19,13 @@ function unmarshalEd25519PublicKey(bytes) {
   bytes = ensureEd25519Key(bytes, PUBLIC_KEY_BYTE_LENGTH);
   return new Ed25519PublicKey(bytes);
 }
+async function generateEd25519KeyPair() {
+  const {
+    privateKey,
+    publicKey
+  } = generateKey();
+  return new Ed25519PrivateKey(privateKey, publicKey);
+}
 function ensureEd25519Key(key, length) {
   key = Uint8Array.from(key ?? []);
   if (key.length !== length) {
@@ -27,4 +34,4 @@ function ensureEd25519Key(key, length) {
   return key;
 }
 
-export { ensureEd25519Key, unmarshalEd25519PrivateKey, unmarshalEd25519PublicKey };
+export { ensureEd25519Key, generateEd25519KeyPair, unmarshalEd25519PrivateKey, unmarshalEd25519PublicKey };

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

@@ -1,14 +1,14 @@
-import { InvalidParametersError, UnsupportedKeyTypeError } from '@libp2p/interface';
 import { ECDSA_P_256_OID, ECDSA_P_384_OID, ECDSA_P_521_OID } from './ecdsa/index.js';
-import { pkiMessageToECDSAPublicKey, pkiMessageToECDSAPrivateKey, unmarshalECDSAPublicKey, generateECDSAKeyPair } from './ecdsa/utils.js';
-import { publicKeyLength as PUBLIC_KEY_BYTE_LENGTH, privateKeyLength as PRIVATE_KEY_BYTE_LENGTH } from './ed25519/index.browser.js';
-import { unmarshalEd25519PublicKey, unmarshalEd25519PrivateKey } from './ed25519/utils.js';
-import { PublicKey, KeyType } from './keys.js';
+import { unmarshalECDSAPublicKey, unmarshalECDSAPrivateKey, pkiMessageToECDSAPrivateKey, pkiMessageToECDSAPublicKey, generateECDSAKeyPair } from './ecdsa/utils.js';
+import { privateKeyLength as PRIVATE_KEY_BYTE_LENGTH, publicKeyLength as PUBLIC_KEY_BYTE_LENGTH } from './ed25519/index.browser.js';
+import { unmarshalEd25519PublicKey, generateEd25519KeyPair, unmarshalEd25519PrivateKey } from './ed25519/utils.js';
+import { PublicKey, KeyType, PrivateKey } from './keys.js';
 import { decodeDer } from './rsa/der.js';
 import { RSAES_PKCS1_V1_5_OID } from './rsa/index.browser.js';
-import { pkixMessageToRSAPublicKey, pkcs1MessageToRSAPrivateKey, pkixToRSAPublicKey } from './rsa/utils.js';
-import { publicKeyLength as PUBLIC_KEY_BYTE_LENGTH$1, privateKeyLength as PRIVATE_KEY_BYTE_LENGTH$1 } from './secp256k1/index.browser.js';
-import { unmarshalSecp256k1PublicKey, unmarshalSecp256k1PrivateKey } from './secp256k1/utils.js';
+import { pkixToRSAPublicKey, pkcs1ToRSAPrivateKey, pkcs1MessageToRSAPrivateKey, pkixMessageToRSAPublicKey, generateRSAKeyPair } from './rsa/utils.js';
+import { privateKeyLength as PRIVATE_KEY_BYTE_LENGTH$1, publicKeyLength as PUBLIC_KEY_BYTE_LENGTH$1 } from './secp256k1/index.browser.js';
+import { unmarshalSecp256k1PublicKey, unmarshalSecp256k1PrivateKey, generateSecp256k1KeyPair } from './secp256k1/utils.js';
+import { UnsupportedKeyTypeError, InvalidParametersError } from '../../../../interface/dist/src/errors.js';
 
 /**
  * @packageDocumentation
@@ -20,9 +20,19 @@ import { unmarshalSecp256k1PublicKey, unmarshalSecp256k1PrivateKey } from './sec
  * For encryption / decryption support, RSA keys should be used.
  */
 async function generateKeyPair(type, bits) {
-  {
-    return generateECDSAKeyPair(toCurve());
+  if (type === 'Ed25519') {
+    return generateEd25519KeyPair();
   }
+  if (type === 'secp256k1') {
+    return generateSecp256k1KeyPair();
+  }
+  if (type === 'RSA') {
+    return generateRSAKeyPair(toBits(bits));
+  }
+  if (type === 'ECDSA') {
+    return generateECDSAKeyPair(toCurve(bits));
+  }
+  throw new UnsupportedKeyTypeError();
 }
 /**
  * Converts a protobuf serialized public key into its representative object.
@@ -71,6 +81,30 @@ function publicKeyFromRaw(buf) {
   }
   throw new InvalidParametersError('Could not extract public key from raw bytes');
 }
+/**
+ * Creates a public key from an identity multihash which contains a protobuf
+ * encoded Ed25519 or secp256k1 public key.
+ *
+ * RSA keys are not supported as in practice we they are not stored in identity
+ * multihash since the hash would be very large.
+ */
+function publicKeyFromMultihash(digest) {
+  const {
+    Type,
+    Data
+  } = PublicKey.decode(digest.digest);
+  const data = Data ?? new Uint8Array();
+  switch (Type) {
+    case KeyType.Ed25519:
+      return unmarshalEd25519PublicKey(data);
+    case KeyType.secp256k1:
+      return unmarshalSecp256k1PublicKey(data);
+    case KeyType.ECDSA:
+      return unmarshalECDSAPublicKey(data);
+    default:
+      throw new UnsupportedKeyTypeError();
+  }
+}
 /**
  * Converts a public key object into a protobuf serialized public key
  */
@@ -80,6 +114,25 @@ function publicKeyToProtobuf(key) {
     Data: key.raw
   });
 }
+/**
+ * Converts a protobuf serialized private key into its representative object
+ */
+function privateKeyFromProtobuf(buf) {
+  const decoded = PrivateKey.decode(buf);
+  const data = decoded.Data ?? new Uint8Array();
+  switch (decoded.Type) {
+    case KeyType.RSA:
+      return pkcs1ToRSAPrivateKey(data);
+    case KeyType.Ed25519:
+      return unmarshalEd25519PrivateKey(data);
+    case KeyType.secp256k1:
+      return unmarshalSecp256k1PrivateKey(data);
+    case KeyType.ECDSA:
+      return unmarshalECDSAPrivateKey(data);
+    default:
+      throw new UnsupportedKeyTypeError();
+  }
+}
 /**
  * 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
@@ -101,10 +154,32 @@ function privateKeyFromRaw(buf) {
   }
   throw new InvalidParametersError('Could not extract private key from raw bytes');
 }
+/**
+ * Converts a private key object into a protobuf serialized private key
+ */
+function privateKeyToProtobuf(key) {
+  return PrivateKey.encode({
+    Type: KeyType[key.type],
+    Data: key.raw
+  });
+}
+function toBits(bits) {
+  if (bits == null) {
+    return 2048;
+  }
+  return parseInt(bits, 10);
+}
 function toCurve(curve) {
-  {
+  if (curve === 'P-256' || curve == null) {
     return 'P-256';
   }
+  if (curve === 'P-384') {
+    return 'P-384';
+  }
+  if (curve === 'P-521') {
+    return 'P-521';
+  }
+  throw new InvalidParametersError('Unsupported curve, should be P-256, P-384 or P-521');
 }
 /**
  * Convert a libp2p RSA or ECDSA private key to a WebCrypto CryptoKeyPair
@@ -141,4 +216,4 @@ async function privateKeyToCryptoKeyPair(privateKey) {
   throw new InvalidParametersError('Only RSA and ECDSA keys are supported');
 }
 
-export { generateKeyPair, privateKeyFromRaw, privateKeyToCryptoKeyPair, publicKeyFromProtobuf, publicKeyFromRaw, publicKeyToProtobuf };
+export { generateKeyPair, privateKeyFromProtobuf, privateKeyFromRaw, privateKeyToCryptoKeyPair, privateKeyToProtobuf, publicKeyFromMultihash, publicKeyFromProtobuf, publicKeyFromRaw, publicKeyToProtobuf };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/keys/rsa/index.browser.js

@@ -1,8 +1,23 @@
-import { InvalidParametersError } from '@libp2p/interface';
 import { fromString } from '../../../../../../uint8arrays/dist/src/from-string.js';
 import webcrypto from '../../webcrypto/webcrypto.browser.js';
+import { InvalidParametersError } from '../../../../../interface/dist/src/errors.js';
 
 const RSAES_PKCS1_V1_5_OID = '1.2.840.113549.1.1.1';
+async function generateRSAKey(bits) {
+  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]
+  };
+}
 async function hashAndSign(key, msg) {
   const privateKey = await webcrypto.get().subtle.importKey('jwk', key, {
     name: 'RSASSA-PKCS1-v1_5',
@@ -26,6 +41,12 @@ async function hashAndVerify(key, sig, msg) {
     name: 'RSASSA-PKCS1-v1_5'
   }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
 }
+async function exportKey(pair) {
+  if (pair.privateKey == null || pair.publicKey == null) {
+    throw new InvalidParametersError('Private and public key are required');
+  }
+  return Promise.all([webcrypto.get().subtle.exportKey('jwk', pair.privateKey), webcrypto.get().subtle.exportKey('jwk', pair.publicKey)]);
+}
 function rsaKeySize(jwk) {
   if (jwk.kty !== 'RSA') {
     throw new InvalidParametersError('invalid key type');
@@ -36,4 +57,4 @@ function rsaKeySize(jwk) {
   return bytes.length * 8;
 }
 
-export { RSAES_PKCS1_V1_5_OID, hashAndSign, hashAndVerify, rsaKeySize };
+export { RSAES_PKCS1_V1_5_OID, generateRSAKey, hashAndSign, hashAndVerify, rsaKeySize };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/keys/rsa/utils.js

@@ -1,4 +1,3 @@
-import { InvalidPublicKeyError, InvalidParametersError } from '@libp2p/interface';
 import { sha256 } from '../../../../../../@noble/hashes/esm/sha256.js';
 import { create } from '../../../../../../multiformats/dist/src/hashes/digest.js';
 import { fromString } from '../../../../../../uint8arrays/dist/src/from-string.js';
@@ -6,7 +5,8 @@ import { toString } from '../../../../../../uint8arrays/dist/src/to-string.js';
 import { PublicKey, KeyType } from '../keys.js';
 import { decodeDer, encodeSequence, encodeBitString, encodeInteger } from './der.js';
 import { RSAPublicKey, RSAPrivateKey } from './rsa.js';
-import { rsaKeySize } from './index.browser.js';
+import { rsaKeySize, generateRSAKey } from './index.browser.js';
+import { InvalidPublicKeyError, InvalidParametersError } from '../../../../../interface/dist/src/errors.js';
 
 const MAX_RSA_KEY_SIZE = 8192;
 const SHA2_256_CODE = 0x12;
@@ -59,6 +59,13 @@ function jwkToPkix(jwk) {
   const subjectPublicKeyInfo = encodeSequence([RSA_ALGORITHM_IDENTIFIER, encodeBitString(encodeSequence([encodeInteger(fromString(jwk.n, 'base64url')), encodeInteger(fromString(jwk.e, 'base64url'))]))]);
   return subjectPublicKeyInfo.subarray();
 }
+/**
+ * Turn PKCS#1 DER bytes into a PrivateKey
+ */
+function pkcs1ToRSAPrivateKey(bytes) {
+  const message = decodeDer(bytes);
+  return pkcs1MessageToRSAPrivateKey(message);
+}
 /**
  * Turn PKCS#1 DER bytes into a PrivateKey
  */
@@ -101,6 +108,18 @@ function jwkToRSAPrivateKey(jwk) {
   const digest = create(SHA2_256_CODE, hash);
   return new RSAPrivateKey(keys.privateKey, new RSAPublicKey(keys.publicKey, digest));
 }
+async function generateRSAKeyPair(bits) {
+  if (bits > MAX_RSA_KEY_SIZE) {
+    throw new InvalidParametersError('Key size is too large');
+  }
+  const keys = await generateRSAKey(bits);
+  const hash = sha256(PublicKey.encode({
+    Type: KeyType.RSA,
+    Data: jwkToPkix(keys.publicKey)
+  }));
+  const digest = create(SHA2_256_CODE, hash);
+  return new RSAPrivateKey(keys.privateKey, new RSAPublicKey(keys.publicKey, digest));
+}
 /**
  * Takes a jwk key and returns a JWK KeyPair
  */
@@ -118,4 +137,4 @@ function jwkToJWKKeyPair(key) {
   };
 }
 
-export { MAX_RSA_KEY_SIZE, jwkToJWKKeyPair, jwkToPkcs1, jwkToPkix, jwkToRSAPrivateKey, pkcs1MessageToJwk, pkcs1MessageToRSAPrivateKey, pkixMessageToJwk, pkixMessageToRSAPublicKey, pkixToRSAPublicKey };
+export { MAX_RSA_KEY_SIZE, generateRSAKeyPair, jwkToJWKKeyPair, jwkToPkcs1, jwkToPkix, jwkToRSAPrivateKey, pkcs1MessageToJwk, pkcs1MessageToRSAPrivateKey, pkcs1ToRSAPrivateKey, pkixMessageToJwk, pkixMessageToRSAPublicKey, pkixToRSAPublicKey };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/keys/secp256k1/utils.js

@@ -1,6 +1,6 @@
-import { InvalidPublicKeyError, InvalidPrivateKeyError } from '@libp2p/interface';
 import { secp256k1 } from '../../../../../../@noble/curves/esm/secp256k1.js';
 import { Secp256k1PublicKey, Secp256k1PrivateKey } from './secp256k1.js';
+import { InvalidPublicKeyError, InvalidPrivateKeyError } from '../../../../../interface/dist/src/errors.js';
 
 function unmarshalSecp256k1PrivateKey(bytes) {
   return new Secp256k1PrivateKey(bytes);
@@ -8,6 +8,10 @@ function unmarshalSecp256k1PrivateKey(bytes) {
 function unmarshalSecp256k1PublicKey(bytes) {
   return new Secp256k1PublicKey(bytes);
 }
+async function generateSecp256k1KeyPair() {
+  const privateKeyBytes = generateSecp256k1PrivateKey();
+  return new Secp256k1PrivateKey(privateKeyBytes);
+}
 function compressSecp256k1PublicKey(key) {
   const point = secp256k1.ProjectivePoint.fromHex(key).toRawBytes(true);
   return point;
@@ -35,5 +39,8 @@ function computeSecp256k1PublicKey(privateKey) {
     throw new InvalidPrivateKeyError(String(err));
   }
 }
+function generateSecp256k1PrivateKey() {
+  return secp256k1.utils.randomPrivateKey();
+}
 
-export { compressSecp256k1PublicKey, computeSecp256k1PublicKey, unmarshalSecp256k1PrivateKey, unmarshalSecp256k1PublicKey, validateSecp256k1PrivateKey, validateSecp256k1PublicKey };
+export { compressSecp256k1PublicKey, computeSecp256k1PublicKey, generateSecp256k1KeyPair, generateSecp256k1PrivateKey, unmarshalSecp256k1PrivateKey, unmarshalSecp256k1PublicKey, validateSecp256k1PrivateKey, validateSecp256k1PublicKey };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/pbkdf2.js

@@ -0,0 +1,36 @@
+import { pbkdf2 as pbkdf2$1 } from '../../../../@noble/hashes/esm/pbkdf2.js';
+import { sha1 } from '../../../../@noble/hashes/esm/sha1.js';
+import { sha256 } from '../../../../@noble/hashes/esm/sha256.js';
+import { sha512 } from '../../../../@noble/hashes/esm/sha512.js';
+import { base64 } from '../../../../multiformats/dist/src/bases/base64.js';
+import { InvalidParametersError } from '../../../interface/dist/src/errors.js';
+
+/**
+ * Maps an IPFS hash name to its @noble/hashes equivalent.
+ *
+ * See https://github.com/multiformats/multihash/blob/master/hashtable.csv
+ *
+ * @private
+ */
+const hashName = {
+  sha1,
+  'sha2-256': sha256,
+  'sha2-512': sha512
+};
+/**
+ * Computes the Password-Based Key Derivation Function 2.
+ */
+function pbkdf2(password, salt, iterations, keySize, hash) {
+  if (hash !== 'sha1' && hash !== 'sha2-256' && hash !== 'sha2-512') {
+    const types = Object.keys(hashName).join(' / ');
+    throw new InvalidParametersError(`Hash '${hash}' is unknown or not supported. Must be ${types}`);
+  }
+  const hasher = hashName[hash];
+  const dek = pbkdf2$1(hasher, password, salt, {
+    c: iterations,
+    dkLen: keySize
+  });
+  return base64.encode(dek).substring(1);
+}
+
+export { pbkdf2 as default };

package/dist/esm/node_modules/@libp2p/crypto/dist/src/random-bytes.js

@@ -0,0 +1,14 @@
+import { randomBytes as randomBytes$1 } from '../../../../@noble/hashes/esm/utils.js';
+import { InvalidParametersError } from '../../../interface/dist/src/errors.js';
+
+/**
+ * Generates a Uint8Array with length `number` populated by random bytes
+ */
+function randomBytes(length) {
+  if (isNaN(length) || length <= 0) {
+    throw new InvalidParametersError('random bytes length must be a Number bigger than 0');
+  }
+  return randomBytes$1(length);
+}
+
+export { randomBytes as default };

package/dist/esm/node_modules/@libp2p/dcutr/dist/src/dcutr.js

@@ -1,11 +1,12 @@
-import { serviceDependencies, InvalidMessageError } from '@libp2p/interface';
-import { multiaddr } from '@multiformats/multiaddr';
+import { serviceDependencies } from '../../../interface/dist/src/index.js';
+import { multiaddr } from '../../../../@multiformats/multiaddr/dist/src/index.js';
 import { Circuit } from '../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
 import delay from '../../../../delay/index.js';
 import { pbStream } from '../../../../it-protobuf-stream/dist/src/index.js';
 import { HolePunch } from './pb/message.js';
 import { isPublicAndDialable } from './utils.js';
 import { multicodec } from './index.js';
+import { InvalidMessageError } from '../../../interface/dist/src/errors.js';
 
 // https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#rpc-messages
 const MAX_DCUTR_MESSAGE_SIZE = 1024 * 4;