@libp2p/crypto 3.0.4-856ccd708 → 3.0.4-ddaa59a60

package/dist/src/util.js

@@ -1,5 +1,30 @@
+import 'node-forge/lib/util.js';
+import 'node-forge/lib/jsbn.js';
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js';
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat';
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string';
+export function bigIntegerToUintBase64url(num, len) {
+    // Call `.abs()` to convert to unsigned
+    let buf = Uint8Array.from(num.abs().toByteArray()); // toByteArray converts to big endian
+    // toByteArray() gives us back a signed array, which will include a leading 0
+    // byte if the most significant bit of the number is 1:
+    // https://docs.microsoft.com/en-us/windows/win32/seccertenroll/about-integer
+    // Our number will always be positive so we should remove the leading padding.
+    buf = buf[0] === 0 ? buf.subarray(1) : buf;
+    if (len != null) {
+        if (buf.length > len)
+            throw new Error('byte array longer than desired length');
+        buf = uint8ArrayConcat([new Uint8Array(len - buf.length), buf]);
+    }
+    return uint8ArrayToString(buf, 'base64url');
+}
+// Convert a base64url encoded string to a BigInteger
+export function base64urlToBigInteger(str) {
+    const buf = base64urlToBuffer(str);
+    return new forge.jsbn.BigInteger(uint8ArrayToString(buf, 'base16'), 16);
+}
 export function base64urlToBuffer(str, len) {
     let buf = uint8ArrayFromString(str, 'base64urlpad');
     if (len != null) {

package/dist/src/util.js.map

@@ -1 +1 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAE5E,MAAM,UAAU,iBAAiB,CAAE,GAAW,EAAE,GAAY;IAC1D,IAAI,GAAG,GAAG,oBAAoB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAA;IAEnD,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;QAC9E,GAAG,GAAG,gBAAgB,CAAC,CAAC,IAAI,UAAU,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;IACjE,CAAC;IAED,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,MAAM,UAAU,SAAS,CAAgB,KAAU;IACjD,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;QACrC,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;QACjC,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CAAA;AACvC,CAAC"}
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,CAAA;AAC/B,OAAO,wBAAwB,CAAA;AAC/B,qCAAqC;AACrC,OAAO,KAAK,MAAM,yBAAyB,CAAA;AAC3C,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,UAAU,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAEtE,MAAM,UAAU,yBAAyB,CAAE,GAAmB,EAAE,GAAY;IAC1E,uCAAuC;IACvC,IAAI,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA,CAAC,qCAAqC;IAExF,6EAA6E;IAC7E,uDAAuD;IACvD,6EAA6E;IAC7E,8EAA8E;IAC9E,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;IAE1C,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;QAC9E,GAAG,GAAG,gBAAgB,CAAC,CAAC,IAAI,UAAU,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;IACjE,CAAC;IAED,OAAO,kBAAkB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAA;AAC7C,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,qBAAqB,CAAE,GAAW;IAChD,MAAM,GAAG,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAA;IAClC,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAA;AACzE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAE,GAAW,EAAE,GAAY;IAC1D,IAAI,GAAG,GAAG,oBAAoB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAA;IAEnD,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;QAC9E,GAAG,GAAG,gBAAgB,CAAC,CAAC,IAAI,UAAU,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;IACjE,CAAC;IAED,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,MAAM,UAAU,SAAS,CAAgB,KAAU;IACjD,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;QACrC,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;QACjC,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CAAA;AACvC,CAAC"}

package/dist/src/webcrypto.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" />
-import { webcrypto } from 'crypto';
 declare const _default: {
-    get(win?: typeof globalThis): webcrypto.Crypto;
+    get(win?: typeof globalThis): Crypto;
 };
 export default _default;
 //# sourceMappingURL=webcrypto.d.ts.map

package/dist/src/webcrypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["../../src/webcrypto.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;;;;AAIlC,wBAIC"}
+{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["../../src/webcrypto.ts"],"names":[],"mappings":";;;AAIA,wBAmBC"}

package/dist/src/webcrypto.js

@@ -1,10 +1,17 @@
 /* eslint-env browser */
-import { webcrypto } from 'crypto';
-// globalThis `SubtleCrypto` shipped in node.js 19.x, Electron currently uses
-// v18.x so this override file is necessary until Electron updates
+// Check native crypto exists and is enabled (In insecure context `self.crypto`
+// exists but `self.crypto.subtle` does not).
 export default {
     get(win = globalThis) {
-        return webcrypto;
+        const nativeCrypto = win.crypto;
+        if (nativeCrypto == null || nativeCrypto.subtle == null) {
+            throw Object.assign(new Error('Missing Web Crypto API. ' +
+                'The most likely cause of this error is that this page is being accessed ' +
+                'from an insecure context (i.e. not HTTPS). For more information and ' +
+                'possible resolutions see ' +
+                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api'), { code: 'ERR_MISSING_WEB_CRYPTO' });
+        }
+        return nativeCrypto;
     }
 };
 //# sourceMappingURL=webcrypto.js.map

package/dist/src/webcrypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["../../src/webcrypto.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAElC,6EAA6E;AAC7E,kEAAkE;AAClE,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,OAAO,SAAS,CAAA;IAClB,CAAC;CACF,CAAA"}
+{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["../../src/webcrypto.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,+EAA+E;AAC/E,6CAA6C;AAC7C,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAA;QAE/B,IAAI,YAAY,IAAI,IAAI,IAAI,YAAY,CAAC,MAAM,IAAI,IAAI,EAAE,CAAC;YACxD,MAAM,MAAM,CAAC,MAAM,CACjB,IAAI,KAAK,CACP,0BAA0B;gBAC1B,0EAA0E;gBAC1E,sEAAsE;gBACtE,2BAA2B;gBAC3B,wFAAwF,CACzF,EACD,EAAE,IAAI,EAAE,wBAAwB,EAAE,CACnC,CAAA;QACH,CAAC;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;CACF,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/crypto",
-  "version": "3.0.4-856ccd708",
+  "version": "3.0.4-ddaa59a60",
   "description": "Crypto primitives for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/crypto#readme",
@@ -51,6 +51,10 @@
       "types": "./src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./aes": {
+      "types": "./dist/src/aes/index.d.ts",
+      "import": "./dist/src/aes/index.js"
+    },
     "./hmac": {
       "types": "./dist/src/hmac/index.d.ts",
       "import": "./dist/src/hmac/index.js"
@@ -65,7 +69,10 @@
     "parserOptions": {
       "project": true,
       "sourceType": "module"
-    }
+    },
+    "ignorePatterns": [
+      "src/*.d.ts"
+    ]
   },
   "scripts": {
     "clean": "aegir clean",
@@ -83,13 +90,13 @@
     "generate": "protons ./src/keys/keys.proto"
   },
   "dependencies": {
-    "@libp2p/interface": "1.1.1-856ccd708",
+    "@libp2p/interface": "1.1.1-ddaa59a60",
     "@noble/curves": "^1.1.0",
-    "@noble/hashes": "^1.3.3",
-    "asn1js": "^3.0.5",
+    "@noble/hashes": "^1.3.1",
     "multiformats": "^13.0.0",
+    "node-forge": "^1.1.0",
     "protons-runtime": "^5.0.0",
-    "uint8arraylist": "^2.4.7",
+    "uint8arraylist": "^2.4.3",
     "uint8arrays": "^5.0.0"
   },
   "devDependencies": {
@@ -99,12 +106,12 @@
     "protons": "^7.3.0"
   },
   "browser": {
+    "./dist/src/aes/ciphers.js": "./dist/src/aes/ciphers-browser.js",
     "./dist/src/ciphers/aes-gcm.js": "./dist/src/ciphers/aes-gcm.browser.js",
     "./dist/src/hmac/index.js": "./dist/src/hmac/index-browser.js",
     "./dist/src/keys/ecdh.js": "./dist/src/keys/ecdh-browser.js",
     "./dist/src/keys/ed25519.js": "./dist/src/keys/ed25519-browser.js",
     "./dist/src/keys/rsa.js": "./dist/src/keys/rsa-browser.js",
-    "./dist/src/keys/secp256k1.js": "./dist/src/keys/secp256k1-browser.js",
-    "./dist/src/webcrypto.js": "./dist/src/webcrypto-browser.js"
+    "./dist/src/keys/secp256k1.js": "./dist/src/keys/secp256k1-browser.js"
   }
 }

package/src/aes/cipher-mode.ts

@@ -0,0 +1,15 @@
+import { CodeError } from '@libp2p/interface'
+
+const CIPHER_MODES = {
+  16: 'aes-128-ctr',
+  32: 'aes-256-ctr'
+}
+
+export function cipherMode (key: Uint8Array): string {
+  if (key.length === 16 || key.length === 32) {
+    return CIPHER_MODES[key.length]
+  }
+
+  const modes = Object.entries(CIPHER_MODES).map(([k, v]) => `${k} (${v})`).join(' / ')
+  throw new CodeError(`Invalid key length ${key.length} bytes. Must be ${modes}`, 'ERR_INVALID_KEY_LENGTH')
+}

package/src/aes/ciphers-browser.ts

@@ -0,0 +1,31 @@
+import 'node-forge/lib/aes.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+
+export interface Cipher {
+  update(data: Uint8Array): Uint8Array
+}
+
+export function createCipheriv (mode: any, key: Uint8Array, iv: Uint8Array): Cipher {
+  const cipher2 = forge.cipher.createCipher('AES-CTR', uint8ArrayToString(key, 'ascii'))
+  cipher2.start({ iv: uint8ArrayToString(iv, 'ascii') })
+  return {
+    update: (data: Uint8Array) => {
+      cipher2.update(forge.util.createBuffer(uint8ArrayToString(data, 'ascii')))
+      return uint8ArrayFromString(cipher2.output.getBytes(), 'ascii')
+    }
+  }
+}
+
+export function createDecipheriv (mode: any, key: Uint8Array, iv: Uint8Array): Cipher {
+  const cipher2 = forge.cipher.createDecipher('AES-CTR', uint8ArrayToString(key, 'ascii'))
+  cipher2.start({ iv: uint8ArrayToString(iv, 'ascii') })
+  return {
+    update: (data: Uint8Array) => {
+      cipher2.update(forge.util.createBuffer(uint8ArrayToString(data, 'ascii')))
+      return uint8ArrayFromString(cipher2.output.getBytes(), 'ascii')
+    }
+  }
+}

package/src/aes/ciphers.ts

@@ -0,0 +1,4 @@
+import crypto from 'crypto'
+
+export const createCipheriv = crypto.createCipheriv
+export const createDecipheriv = crypto.createDecipheriv

package/src/aes/index.ts

@@ -0,0 +1,70 @@
+/**
+ * @packageDocumentation
+ *
+ * Exposes an interface to AES encryption (formerly Rijndael), as defined in U.S. Federal Information Processing Standards Publication 197.
+ *
+ * This uses `CTR` mode.
+ *
+ * /**
+ * @example
+ *
+ * ```js
+ * import { create } from '@libp2p/crypto/aes'
+ *
+ * // Setting up Key and IV
+ *
+ * // A 16 bytes array, 128 Bits, AES-128 is chosen
+ * const key128 = Uint8Array.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+ *
+ * // A 16 bytes array, 128 Bits,
+ * const IV = Uint8Array.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+ *
+ * const decryptedMessage = 'Hello, world!'
+ *
+ * // Encrypting
+ * const cipher = await crypto.aes.create(key128, IV)
+ * const encryptedBuffer = await encrypt(Uint8Array.from(decryptedMessage))
+ * console.log(encryptedBuffer)
+ * // prints: <Uint8Array 42 f1 67 d9 2e 42 d0 32 9e b1 f8 3c>
+ *
+ * // Decrypting
+ * const decipher = await crypto.aes.create(key128, IV)
+ * const decryptedBuffer = await decrypt(encryptedBuffer)
+ *
+ * console.log(decryptedBuffer)
+ * // prints: <Uint8Array 42 f1 67 d9 2e 42 d0 32 9e b1 f8 3c>
+ *
+ * console.log(decryptedBuffer.toString('utf-8'))
+ * // prints: Hello, world!
+ * ```
+ */
+
+import { cipherMode } from './cipher-mode.js'
+import * as ciphers from './ciphers.js'
+
+export interface AESCipher {
+  encrypt(data: Uint8Array): Promise<Uint8Array>
+  decrypt(data: Uint8Array): Promise<Uint8Array>
+}
+
+/**
+ * @param key - The key, if length `16` then `AES 128` is used. For length `32`, `AES 256` is used
+ * @param iv - Must have length `16`
+ */
+export function create (key: Uint8Array, iv: Uint8Array): AESCipher {
+  const mode = cipherMode(key)
+  const cipher = ciphers.createCipheriv(mode, key, iv)
+  const decipher = ciphers.createDecipheriv(mode, key, iv)
+
+  const res: AESCipher = {
+    async encrypt (data) {
+      return cipher.update(data)
+    },
+
+    async decrypt (data) {
+      return decipher.update(data)
+    }
+  }
+
+  return res
+}

package/src/index.ts

@@ -8,11 +8,13 @@
  * To enable the Web Crypto API and allow `@libp2p/crypto` to work fully, please serve your page over HTTPS.
  */
 
+import * as aes from './aes/index.js'
 import * as hmac from './hmac/index.js'
 import * as keys from './keys/index.js'
 import pbkdf2 from './pbkdf2.js'
 import randomBytes from './random-bytes.js'
 
+export { aes }
 export { hmac }
 export { keys }
 export { randomBytes }

package/src/keys/ed25519-browser.ts

@@ -1,5 +1,5 @@
 import { ed25519 as ed } from '@noble/curves/ed25519'
-import type { Uint8ArrayKeyPair } from './interface.js'
+import type { Uint8ArrayKeyPair } from './interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PUBLIC_KEY_BYTE_LENGTH = 32

package/src/keys/index.ts

@@ -10,14 +10,18 @@
  * For encryption / decryption support, RSA keys should be used.
  */
 
+import 'node-forge/lib/asn1.js'
+import 'node-forge/lib/pbe.js'
 import { CodeError } from '@libp2p/interface'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import * as Ed25519 from './ed25519-class.js'
 import generateEphemeralKeyPair from './ephemeral-keys.js'
 import { importer } from './importer.js'
 import { keyStretcher } from './key-stretcher.js'
 import * as keysPBM from './keys.js'
 import * as RSA from './rsa-class.js'
-import { importFromPem } from './rsa-utils.js'
 import * as Secp256k1 from './secp256k1-class.js'
 import type { PrivateKey, PublicKey } from '@libp2p/interface'
 
@@ -27,11 +31,6 @@ export { keysPBM }
 
 export type KeyTypes = 'RSA' | 'Ed25519' | 'secp256k1'
 
-export { RsaPrivateKey, RsaPublicKey, MAX_RSA_KEY_SIZE } from './rsa-class.js'
-export { Ed25519PrivateKey, Ed25519PublicKey } from './ed25519-class.js'
-export { Secp256k1PrivateKey, Secp256k1PublicKey } from './secp256k1-class.js'
-export type { JWKKeyPair } from './interface.js'
-
 export const supportedKeys = {
   rsa: RSA,
   ed25519: Ed25519,
@@ -145,9 +144,12 @@ export async function importKey (encryptedKey: string, password: string): Promis
     // Ignore and try the old pem decrypt
   }
 
-  if (!encryptedKey.includes('BEGIN')) {
-    throw new CodeError('Encrypted key was not a libp2p-key or a PEM file', 'ERR_INVALID_IMPORT_FORMAT')
+  // Only rsa supports pem right now
+  const key = forge.pki.decryptRsaPrivateKey(encryptedKey, password)
+  if (key === null) {
+    throw new CodeError('Cannot read the key, most likely the password is wrong or not a RSA key', 'ERR_CANNOT_DECRYPT_PEM')
   }
-
-  return importFromPem(encryptedKey, password)
+  let der = forge.asn1.toDer(forge.pki.privateKeyToAsn1(key))
+  der = uint8ArrayFromString(der.getBytes(), 'ascii')
+  return supportedKeys.rsa.unmarshalRsaPrivateKey(der)
 }

package/src/keys/jwk2pem.ts

@@ -0,0 +1,21 @@
+import 'node-forge/lib/rsa.js'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
+import { base64urlToBigInteger } from '../util.js'
+
+export interface JWK {
+  encrypt(msg: string): string
+  decrypt(msg: string): string
+}
+
+function convert (key: any, types: string[]): Array<typeof forge.jsbn.BigInteger> {
+  return types.map(t => base64urlToBigInteger(key[t]))
+}
+
+export function jwk2priv (key: JsonWebKey): JWK {
+  return forge.pki.setRsaPrivateKey(...convert(key, ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi']))
+}
+
+export function jwk2pub (key: JsonWebKey): JWK {
+  return forge.pki.setRsaPublicKey(...convert(key, ['n', 'e']))
+}

package/src/keys/rsa-browser.ts

@@ -1,7 +1,9 @@
 import { CodeError } from '@libp2p/interface'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import randomBytes from '../random-bytes.js'
 import webcrypto from '../webcrypto.js'
+import { jwk2pub, jwk2priv } from './jwk2pem.js'
 import * as utils from './rsa-utils.js'
 import type { JWKKeyPair } from './interface.js'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -128,6 +130,33 @@ async function derivePublicFromPrivate (jwKey: JsonWebKey): Promise<CryptoKey> {
   )
 }
 
+/*
+
+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 | Uint8ArrayList, handle: (msg: string, key: { encrypt(msg: string): string, decrypt(msg: string): string }) => string): Uint8Array {
+  const fkey = pub ? jwk2pub(key) : jwk2priv(key)
+  const fmsg = uint8ArrayToString(msg instanceof Uint8Array ? msg : msg.subarray(), 'ascii')
+  const fomsg = handle(fmsg, fkey)
+  return uint8ArrayFromString(fomsg, 'ascii')
+}
+
+export function encrypt (key: JsonWebKey, msg: Uint8Array | Uint8ArrayList): Uint8Array {
+  return convertKey(key, true, msg, (msg, key) => key.encrypt(msg))
+}
+
+export function decrypt (key: JsonWebKey, msg: Uint8Array | Uint8ArrayList): Uint8Array {
+  return convertKey(key, false, msg, (msg, key) => key.decrypt(msg))
+}
+
 export function keySize (jwk: JsonWebKey): number {
   if (jwk.kty !== 'RSA') {
     throw new CodeError('invalid key type', 'ERR_INVALID_KEY_TYPE')

package/src/keys/rsa-class.ts

@@ -1,6 +1,9 @@
 import { CodeError } from '@libp2p/interface'
 import { sha256 } from 'multiformats/hashes/sha2'
+// @ts-expect-error types are missing
+import forge from 'node-forge/lib/forge.js'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import 'node-forge/lib/sha512.js'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { isPromise } from '../util.js'
 import { exporter } from './exporter.js'
@@ -9,7 +12,7 @@ import * as crypto from './rsa.js'
 import type { Multibase } from 'multiformats'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-export const MAX_RSA_KEY_SIZE = 8192
+export const MAX_KEY_SIZE = 8192
 
 export class RsaPublicKey {
   private readonly _key: JsonWebKey
@@ -33,6 +36,10 @@ export class RsaPublicKey {
     }).subarray()
   }
 
+  encrypt (bytes: Uint8Array | Uint8ArrayList): Uint8Array {
+    return crypto.encrypt(this._key, bytes)
+  }
+
   equals (key: any): boolean | boolean {
     return uint8ArrayEquals(this.bytes, key.bytes)
   }
@@ -73,6 +80,10 @@ export class RsaPrivateKey {
     return new RsaPublicKey(this._publicKey)
   }
 
+  decrypt (bytes: Uint8Array | Uint8ArrayList): Uint8Array {
+    return crypto.decrypt(this._key, bytes)
+  }
+
   marshal (): Uint8Array {
     return crypto.utils.jwkToPkcs1(this._key)
   }
@@ -111,15 +122,21 @@ export class RsaPrivateKey {
   }
 
   /**
-   * Exports the key as libp2p-key - a aes-gcm encrypted value with the key
-   * derived from the password.
-   *
-   * To export it as a password protected PEM file, please use the `exportPEM`
-   * function from `@libp2p/rsa`.
+   * Exports the key into a password protected PEM format
    */
   async export (password: string, format = 'pkcs-8'): Promise<Multibase<'m'>> {
     if (format === 'pkcs-8') {
-      return crypto.utils.exportToPem(this, password)
+      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 exporter(this.bytes, password)
     } else {
@@ -131,7 +148,7 @@ export class RsaPrivateKey {
 export async function unmarshalRsaPrivateKey (bytes: Uint8Array): Promise<RsaPrivateKey> {
   const jwk = crypto.utils.pkcs1ToJwk(bytes)
 
-  if (crypto.keySize(jwk) > MAX_RSA_KEY_SIZE) {
+  if (crypto.keySize(jwk) > MAX_KEY_SIZE) {
     throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE')
   }
 
@@ -143,7 +160,7 @@ export async function unmarshalRsaPrivateKey (bytes: Uint8Array): Promise<RsaPri
 export function unmarshalRsaPublicKey (bytes: Uint8Array): RsaPublicKey {
   const jwk = crypto.utils.pkixToJwk(bytes)
 
-  if (crypto.keySize(jwk) > MAX_RSA_KEY_SIZE) {
+  if (crypto.keySize(jwk) > MAX_KEY_SIZE) {
     throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE')
   }
 
@@ -151,7 +168,7 @@ export function unmarshalRsaPublicKey (bytes: Uint8Array): RsaPublicKey {
 }
 
 export async function fromJwk (jwk: JsonWebKey): Promise<RsaPrivateKey> {
-  if (crypto.keySize(jwk) > MAX_RSA_KEY_SIZE) {
+  if (crypto.keySize(jwk) > MAX_KEY_SIZE) {
     throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE')
   }
 
@@ -161,7 +178,7 @@ export async function fromJwk (jwk: JsonWebKey): Promise<RsaPrivateKey> {
 }
 
 export async function generateKeyPair (bits: number): Promise<RsaPrivateKey> {
-  if (bits > MAX_RSA_KEY_SIZE) {
+  if (bits > MAX_KEY_SIZE) {
     throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE')
   }