web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,55 @@
+import { base58btc } from '../../../../../../multiformats/dist/src/bases/base58.js';
+import { CID } from '../../../../../../multiformats/dist/src/cid.js';
+import { identity } from '../../../../../../multiformats/dist/src/hashes/identity.js';
+import { equals } from '../../../../../../uint8arrays/dist/src/equals.js';
+import { publicKeyToProtobuf } from '../index.js';
+import { ensureEd25519Key } from './utils.js';
+import { publicKeyLength as PUBLIC_KEY_BYTE_LENGTH, hashAndVerify, privateKeyLength as PRIVATE_KEY_BYTE_LENGTH, hashAndSign } from './index.browser.js';
+
+class Ed25519PublicKey {
+  type = 'Ed25519';
+  raw;
+  constructor(key) {
+    this.raw = ensureEd25519Key(key, PUBLIC_KEY_BYTE_LENGTH);
+  }
+  toMultihash() {
+    return identity.digest(publicKeyToProtobuf(this));
+  }
+  toCID() {
+    return CID.createV1(114, this.toMultihash());
+  }
+  toString() {
+    return base58btc.encode(this.toMultihash().bytes).substring(1);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals(this.raw, key.raw);
+  }
+  verify(data, sig) {
+    return 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 = ensureEd25519Key(key, PRIVATE_KEY_BYTE_LENGTH);
+    this.publicKey = new Ed25519PublicKey(publicKey);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals(this.raw, key.raw);
+  }
+  sign(message) {
+    return hashAndSign(this.raw, message);
+  }
+}
+
+export { Ed25519PrivateKey, Ed25519PublicKey };

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

@@ -0,0 +1,14 @@
+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 hashAndSign(privateKey, msg) {
+  const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH);
+  return ed25519.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw);
+}
+function hashAndVerify(publicKey, sig, msg) {
+  return ed25519.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey);
+}
+
+export { 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

@@ -0,0 +1,30 @@
+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';
+
+function unmarshalEd25519PrivateKey(bytes) {
+  // Try the old, redundant public key version
+  if (bytes.length > PRIVATE_KEY_BYTE_LENGTH) {
+    bytes = ensureEd25519Key(bytes, PRIVATE_KEY_BYTE_LENGTH + PUBLIC_KEY_BYTE_LENGTH);
+    const privateKeyBytes = bytes.subarray(0, PRIVATE_KEY_BYTE_LENGTH);
+    const publicKeyBytes = bytes.subarray(PRIVATE_KEY_BYTE_LENGTH, bytes.length);
+    return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
+  }
+  bytes = ensureEd25519Key(bytes, PRIVATE_KEY_BYTE_LENGTH);
+  const privateKeyBytes = bytes.subarray(0, PRIVATE_KEY_BYTE_LENGTH);
+  const publicKeyBytes = bytes.subarray(PUBLIC_KEY_BYTE_LENGTH);
+  return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
+}
+function unmarshalEd25519PublicKey(bytes) {
+  bytes = ensureEd25519Key(bytes, PUBLIC_KEY_BYTE_LENGTH);
+  return new Ed25519PublicKey(bytes);
+}
+function ensureEd25519Key(key, length) {
+  key = Uint8Array.from(key ?? []);
+  if (key.length !== length) {
+    throw new InvalidParametersError(`Key must be a Uint8Array of length ${length}, got ${key.length}`);
+  }
+  return key;
+}
+
+export { ensureEd25519Key, unmarshalEd25519PrivateKey, unmarshalEd25519PublicKey };

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

@@ -0,0 +1,144 @@
+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 { 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';
+
+/**
+ * @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 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
+  } = PublicKey.decode(buf);
+  const data = Data ?? new Uint8Array();
+  switch (Type) {
+    case KeyType.RSA:
+      return pkixToRSAPublicKey(data, digest);
+    case KeyType.Ed25519:
+      return unmarshalEd25519PublicKey(data);
+    case KeyType.secp256k1:
+      return unmarshalSecp256k1PublicKey(data);
+    case KeyType.ECDSA:
+      return unmarshalECDSAPublicKey(data);
+    default:
+      throw new UnsupportedKeyTypeError();
+  }
+}
+/**
+ * Creates a public key from the raw key bytes
+ */
+function publicKeyFromRaw(buf) {
+  if (buf.byteLength === PUBLIC_KEY_BYTE_LENGTH) {
+    return unmarshalEd25519PublicKey(buf);
+  } else if (buf.byteLength === PUBLIC_KEY_BYTE_LENGTH$1) {
+    return unmarshalSecp256k1PublicKey(buf);
+  }
+  const message = decodeDer(buf);
+  const ecdsaOid = message[1]?.[0];
+  if (ecdsaOid === ECDSA_P_256_OID || ecdsaOid === ECDSA_P_384_OID || ecdsaOid === ECDSA_P_521_OID) {
+    return pkiMessageToECDSAPublicKey(message);
+  }
+  if (message[0]?.[0] === RSAES_PKCS1_V1_5_OID) {
+    return pkixMessageToRSAPublicKey(message, buf);
+  }
+  throw new InvalidParametersError('Could not extract public key from raw bytes');
+}
+/**
+ * Converts a public key object into a protobuf serialized public key
+ */
+function publicKeyToProtobuf(key) {
+  return PublicKey.encode({
+    Type: 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 === PRIVATE_KEY_BYTE_LENGTH) {
+    return unmarshalEd25519PrivateKey(buf);
+  } else if (buf.byteLength === PRIVATE_KEY_BYTE_LENGTH$1) {
+    return unmarshalSecp256k1PrivateKey(buf);
+  }
+  const message = decodeDer(buf);
+  const ecdsaOid = message[2]?.[0];
+  if (ecdsaOid === ECDSA_P_256_OID || ecdsaOid === ECDSA_P_384_OID || ecdsaOid === ECDSA_P_521_OID) {
+    return pkiMessageToECDSAPrivateKey(message);
+  }
+  if (message.length > 8) {
+    return pkcs1MessageToRSAPrivateKey(message);
+  }
+  throw new 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 InvalidParametersError('Only RSA and ECDSA keys are supported');
+}
+
+export { generateKeyPair, privateKeyFromRaw, privateKeyToCryptoKeyPair, publicKeyFromProtobuf, publicKeyFromRaw, publicKeyToProtobuf };

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

@@ -0,0 +1,141 @@
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import { enumeration } from '../../../../../protons-runtime/dist/src/codecs/enum.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import '../../../../../protons-runtime/dist/src/utils/float.js';
+import '../../../../../protons-runtime/dist/src/utils/longbits.js';
+import '../../../../../protons-runtime/dist/src/utils/writer.js';
+
+var KeyType;
+(function (KeyType) {
+  KeyType["RSA"] = "RSA";
+  KeyType["Ed25519"] = "Ed25519";
+  KeyType["secp256k1"] = "secp256k1";
+  KeyType["ECDSA"] = "ECDSA";
+})(KeyType || (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 enumeration(__KeyTypeValues);
+  };
+})(KeyType || (KeyType = {}));
+var PublicKey;
+(function (PublicKey) {
+  let _codec;
+  PublicKey.codec = () => {
+    if (_codec == null) {
+      _codec = 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);
+          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 = 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 encodeMessage(obj, PublicKey.codec());
+  };
+  PublicKey.decode = (buf, opts) => {
+    return decodeMessage(buf, PublicKey.codec(), opts);
+  };
+})(PublicKey || (PublicKey = {}));
+var PrivateKey;
+(function (PrivateKey) {
+  let _codec;
+  PrivateKey.codec = () => {
+    if (_codec == null) {
+      _codec = 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);
+          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 = 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 encodeMessage(obj, PrivateKey.codec());
+  };
+  PrivateKey.decode = (buf, opts) => {
+    return decodeMessage(buf, PrivateKey.codec(), opts);
+  };
+})(PrivateKey || (PrivateKey = {}));
+
+export { KeyType, PrivateKey, PublicKey };

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

@@ -0,0 +1,181 @@
+import { Uint8ArrayList } from '../../../../../../uint8arraylist/dist/src/index.js';
+
+const TAG_MASK = parseInt('11111', 2);
+const LONG_LENGTH_MASK = parseInt('10000000', 2);
+const LONG_LENGTH_BYTES_MASK = parseInt('01111111', 2);
+const decoders = {
+  0x0: readSequence,
+  0x1: readSequence,
+  0x2: readInteger,
+  0x3: readBitString,
+  0x4: readOctetString,
+  0x5: readNull,
+  0x6: readObjectIdentifier,
+  0x10: readSequence,
+  0x16: readSequence,
+  0x30: readSequence
+};
+function decodeDer(buf) {
+  let context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    offset: 0
+  };
+  const tag = buf[context.offset] & TAG_MASK;
+  context.offset++;
+  if (decoders[tag] != null) {
+    return decoders[tag](buf, context);
+  }
+  throw new Error('No decoder for tag ' + tag);
+}
+function readLength(buf, context) {
+  let length = 0;
+  if ((buf[context.offset] & LONG_LENGTH_MASK) === LONG_LENGTH_MASK) {
+    // long length
+    const count = buf[context.offset] & LONG_LENGTH_BYTES_MASK;
+    let str = '0x';
+    context.offset++;
+    for (let i = 0; i < count; i++, context.offset++) {
+      str += buf[context.offset].toString(16).padStart(2, '0');
+    }
+    length = parseInt(str, 16);
+  } else {
+    length = buf[context.offset];
+    context.offset++;
+  }
+  return length;
+}
+function readSequence(buf, context) {
+  readLength(buf, context);
+  const entries = [];
+  while (true) {
+    if (context.offset >= buf.byteLength) {
+      break;
+    }
+    const result = decodeDer(buf, context);
+    if (result === null) {
+      break;
+    }
+    entries.push(result);
+  }
+  return entries;
+}
+function readInteger(buf, context) {
+  const length = readLength(buf, context);
+  const start = context.offset;
+  const end = context.offset + length;
+  const vals = [];
+  for (let i = start; i < end; i++) {
+    if (i === start && buf[i] === 0) {
+      continue;
+    }
+    vals.push(buf[i]);
+  }
+  context.offset += length;
+  return Uint8Array.from(vals);
+}
+function readObjectIdentifier(buf, context) {
+  const count = readLength(buf, context);
+  const finalOffset = context.offset + count;
+  const byte = buf[context.offset];
+  context.offset++;
+  let val1 = 0;
+  let val2 = 0;
+  if (byte < 40) {
+    val1 = 0;
+    val2 = byte;
+  } else if (byte < 80) {
+    val1 = 1;
+    val2 = byte - 40;
+  } else {
+    val1 = 2;
+    val2 = byte - 80;
+  }
+  let oid = `${val1}.${val2}`;
+  let num = [];
+  while (context.offset < finalOffset) {
+    const byte = buf[context.offset];
+    context.offset++;
+    // remove msb
+    num.push(byte & 0b01111111);
+    if (byte < 128) {
+      num.reverse();
+      // reached the end of the encoding
+      let val = 0;
+      for (let i = 0; i < num.length; i++) {
+        val += num[i] << i * 7;
+      }
+      oid += `.${val}`;
+      num = [];
+    }
+  }
+  return oid;
+}
+function readNull(buf, context) {
+  context.offset++;
+  return null;
+}
+function readBitString(buf, context) {
+  const length = readLength(buf, context);
+  const unusedBits = buf[context.offset];
+  context.offset++;
+  const bytes = buf.subarray(context.offset, context.offset + length - 1);
+  context.offset += length;
+  if (unusedBits !== 0) {
+    // need to shift all bytes along by this many bits
+    throw new Error('Unused bits in bit string is unimplemented');
+  }
+  return bytes;
+}
+function readOctetString(buf, context) {
+  const length = readLength(buf, context);
+  const bytes = buf.subarray(context.offset, context.offset + length);
+  context.offset += length;
+  return bytes;
+}
+function encodeNumber(value) {
+  let number = value.toString(16);
+  if (number.length % 2 === 1) {
+    number = '0' + number;
+  }
+  const array = new Uint8ArrayList();
+  for (let i = 0; i < number.length; i += 2) {
+    array.append(Uint8Array.from([parseInt(`${number[i]}${number[i + 1]}`, 16)]));
+  }
+  return array;
+}
+function encodeLength(bytes) {
+  if (bytes.byteLength < 128) {
+    return Uint8Array.from([bytes.byteLength]);
+  }
+  // long length
+  const length = encodeNumber(bytes.byteLength);
+  return new Uint8ArrayList(Uint8Array.from([length.byteLength | LONG_LENGTH_MASK]), length);
+}
+function encodeInteger(value) {
+  const contents = new Uint8ArrayList();
+  const mask = 0b10000000;
+  const positive = (value.subarray()[0] & mask) === mask;
+  if (positive) {
+    contents.append(Uint8Array.from([0]));
+  }
+  contents.append(value);
+  return new Uint8ArrayList(Uint8Array.from([0x02]), encodeLength(contents), contents);
+}
+function encodeBitString(value) {
+  // unused bits is always 0 with full-byte-only values
+  const unusedBits = Uint8Array.from([0]);
+  const contents = new Uint8ArrayList(unusedBits, value);
+  return new Uint8ArrayList(Uint8Array.from([0x03]), encodeLength(contents), contents);
+}
+function encodeOctetString(value) {
+  return new Uint8ArrayList(Uint8Array.from([0x04]), encodeLength(value), value);
+}
+function encodeSequence(values) {
+  let tag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0x30;
+  const output = new Uint8ArrayList();
+  for (const buf of values) {
+    output.append(buf);
+  }
+  return new Uint8ArrayList(Uint8Array.from([tag]), encodeLength(output), output);
+}
+
+export { decodeDer, encodeBitString, encodeInteger, encodeOctetString, encodeSequence };

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

@@ -0,0 +1,39 @@
+import { InvalidParametersError } from '@libp2p/interface';
+import { fromString } from '../../../../../../uint8arrays/dist/src/from-string.js';
+import webcrypto from '../../webcrypto/webcrypto.browser.js';
+
+const RSAES_PKCS1_V1_5_OID = '1.2.840.113549.1.1.1';
+async function hashAndSign(key, msg) {
+  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, msg instanceof Uint8Array ? msg : msg.subarray());
+  return new Uint8Array(sig, 0, sig.byteLength);
+}
+async function hashAndVerify(key, sig, msg) {
+  const publicKey = await webcrypto.get().subtle.importKey('jwk', key, {
+    name: 'RSASSA-PKCS1-v1_5',
+    hash: {
+      name: 'SHA-256'
+    }
+  }, false, ['verify']);
+  return webcrypto.get().subtle.verify({
+    name: 'RSASSA-PKCS1-v1_5'
+  }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
+}
+function rsaKeySize(jwk) {
+  if (jwk.kty !== 'RSA') {
+    throw new InvalidParametersError('invalid key type');
+  } else if (jwk.n == null) {
+    throw new InvalidParametersError('invalid key modulus');
+  }
+  const bytes = fromString(jwk.n, 'base64url');
+  return bytes.length * 8;
+}
+
+export { RSAES_PKCS1_V1_5_OID, hashAndSign, hashAndVerify, rsaKeySize };

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

@@ -0,0 +1,67 @@
+import { base58btc } from '../../../../../../multiformats/dist/src/bases/base58.js';
+import { CID } from '../../../../../../multiformats/dist/src/cid.js';
+import { equals } from '../../../../../../uint8arrays/dist/src/equals.js';
+import { hashAndVerify, hashAndSign } from './index.browser.js';
+import { jwkToPkix, jwkToPkcs1 } from './utils.js';
+
+class RSAPublicKey {
+  type = 'RSA';
+  jwk;
+  _raw;
+  _multihash;
+  constructor(jwk, digest) {
+    this.jwk = jwk;
+    this._multihash = digest;
+  }
+  get raw() {
+    if (this._raw == null) {
+      this._raw = jwkToPkix(this.jwk);
+    }
+    return this._raw;
+  }
+  toMultihash() {
+    return this._multihash;
+  }
+  toCID() {
+    return CID.createV1(114, this._multihash);
+  }
+  toString() {
+    return base58btc.encode(this.toMultihash().bytes).substring(1);
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals(this.raw, key.raw);
+  }
+  verify(data, sig) {
+    return hashAndVerify(this.jwk, sig, data);
+  }
+}
+class RSAPrivateKey {
+  type = 'RSA';
+  jwk;
+  _raw;
+  publicKey;
+  constructor(jwk, publicKey) {
+    this.jwk = jwk;
+    this.publicKey = publicKey;
+  }
+  get raw() {
+    if (this._raw == null) {
+      this._raw = jwkToPkcs1(this.jwk);
+    }
+    return this._raw;
+  }
+  equals(key) {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false;
+    }
+    return equals(this.raw, key.raw);
+  }
+  sign(message) {
+    return hashAndSign(this.jwk, message);
+  }
+}
+
+export { RSAPrivateKey, RSAPublicKey };