@twin.org/crypto 0.0.2-next.3 → 0.0.2-next.4

package/dist/cjs/index.cjs

@@ -726,6 +726,16 @@ class RSA {
      * @internal
      */
     static _CLASS_NAME = "RSA";
+    /**
+     * The public key for encryption.
+     * @internal
+     */
+    _publicKeyBytes;
+    /**
+     * The private key for decryption.
+     * @internal
+     */
+    _privateKeyBytes;
     /**
      * The public key for encryption.
      * @internal
@@ -753,37 +763,15 @@ class RSA {
      */
     constructor(publicKey, privateKey) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "publicKey", publicKey);
-        this._publicKey = node_crypto.createPublicKey({
-            key: Buffer.from(publicKey),
-            format: "der",
-            type: "spki"
-        });
-        if (!core.Is.empty(privateKey)) {
-            this._privateKey = node_crypto.createPrivateKey({
-                key: Buffer.from(privateKey),
-                format: "der",
-                type: "pkcs8"
-            });
-        }
-        // Get modulus length in bits from key details
-        const modulusLengthBits = this._publicKey.asymmetricKeyDetails?.modulusLength;
-        if (core.Is.empty(modulusLengthBits)) {
-            throw new core.GeneralError(RSA._CLASS_NAME, "invalidKeySize");
-        }
-        // Convert bits to bytes
-        this._keySize = Math.ceil(modulusLengthBits / 8);
-        // Calculate block size for OAEP with SHA-256
-        // Formula: keySize - 2 * hashLength - 2
-        const hashLength = 32; // SHA-256 = 32 bytes
-        // eslint-disable-next-line no-mixed-operators
-        this._blockSize = this._keySize - 2 * hashLength - 2;
+        this._publicKeyBytes = publicKey;
+        this._privateKeyBytes = privateKey;
     }
     /**
      * Generate a new RSA key pair in PKCS8 format.
      * @param modulusLength The key size in bits (default: 2048).
      * @returns The public and private keys as Uint8Array.
      */
-    static generateKeyPair(modulusLength = 2048) {
+    static async generateKeyPair(modulusLength = 2048) {
         const { publicKey, privateKey } = node_crypto.generateKeyPairSync("rsa", {
             modulusLength,
             publicKeyEncoding: {
@@ -805,7 +793,7 @@ class RSA {
      * @param pkcs1Key The PKCS1 key as Uint8Array.
      * @returns The PKCS8 key as Uint8Array.
      */
-    static convertPkcs1ToPkcs8(pkcs1Key) {
+    static async convertPkcs1ToPkcs8(pkcs1Key) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "pkcs1Key", pkcs1Key);
         const privateKey = node_crypto.createPrivateKey({
             key: Buffer.from(pkcs1Key),
@@ -822,7 +810,7 @@ class RSA {
      * @param pkcs8Key The PKCS8 key as Uint8Array.
      * @returns The key components.
      */
-    static getPrivateKeyComponents(pkcs8Key) {
+    static async getPrivateKeyComponents(pkcs8Key) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "pkcs8Key", pkcs8Key);
         const privateKey = node_crypto.createPrivateKey({
             key: Buffer.from(pkcs8Key),
@@ -846,7 +834,7 @@ class RSA {
      * @param spkiKey The SPKI key as Uint8Array.
      * @returns The key components.
      */
-    static getPublicKeyComponents(spkiKey) {
+    static async getPublicKeyComponents(spkiKey) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "spkiKey", spkiKey);
         const publicKey = node_crypto.createPublicKey({
             key: Buffer.from(spkiKey),
@@ -876,21 +864,22 @@ class RSA {
         return BigInt(`0x${hexString}`);
     }
     /**
-     * Encrypt the data.
+     * Encrypt the data using the public key.
      * @param data The data to encrypt.
      * @returns The data encrypted.
      */
-    encrypt(data) {
+    async publicEncrypt(data) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "data", data);
         if (data.length === 0) {
             return new Uint8Array(0);
         }
+        const keyDetails = await this.calculateKeyDetails();
         const blocks = [];
         // Split data into blocks of block size
-        for (let i = 0; i < data.length; i += this._blockSize) {
-            const block = data.slice(i, i + this._blockSize);
+        for (let i = 0; i < data.length; i += keyDetails.blockSize) {
+            const block = data.slice(i, i + keyDetails.blockSize);
             const encryptedBlock = node_crypto.publicEncrypt({
-                key: this._publicKey,
+                key: keyDetails.publicKey,
                 padding: node_crypto.constants.RSA_PKCS1_OAEP_PADDING
             }, block);
             blocks.push(encryptedBlock);
@@ -898,14 +887,41 @@ class RSA {
         return core.Uint8ArrayHelper.concat(blocks);
     }
     /**
-     * Decrypt the data.
+     * Encrypt the data using the private key.
+     * @param data The data to encrypt.
+     * @returns The data encrypted.
+     */
+    async privateEncrypt(data) {
+        core.Guards.uint8Array(RSA._CLASS_NAME, "data", data);
+        const keyDetails = await this.calculateKeyDetails();
+        if (core.Is.empty(keyDetails.privateKey)) {
+            throw new core.GeneralError(RSA._CLASS_NAME, "noPrivateKey");
+        }
+        if (data.length === 0) {
+            return new Uint8Array(0);
+        }
+        const blocks = [];
+        // Split data into blocks of block size
+        for (let i = 0; i < data.length; i += keyDetails.blockSize) {
+            const block = data.slice(i, i + keyDetails.blockSize);
+            const encryptedBlock = node_crypto.privateEncrypt({
+                key: keyDetails.privateKey,
+                padding: node_crypto.constants.RSA_PKCS1_PADDING
+            }, block);
+            blocks.push(encryptedBlock);
+        }
+        return core.Uint8ArrayHelper.concat(blocks);
+    }
+    /**
+     * Decrypt the data using the private key.
      * @param data The data to decrypt.
      * @returns The data decrypted.
      * @throws GeneralError If no private key is provided.
      */
-    decrypt(data) {
+    async privateDecrypt(data) {
         core.Guards.uint8Array(RSA._CLASS_NAME, "data", data);
-        if (core.Is.empty(this._privateKey)) {
+        const keyDetails = await this.calculateKeyDetails();
+        if (core.Is.empty(keyDetails.privateKey)) {
             throw new core.GeneralError(RSA._CLASS_NAME, "noPrivateKey");
         }
         if (data.length === 0) {
@@ -913,16 +929,77 @@ class RSA {
         }
         const blocks = [];
         // Split encrypted data into blocks of key size
-        for (let i = 0; i < data.length; i += this._keySize) {
-            const block = data.slice(i, i + this._keySize);
+        for (let i = 0; i < data.length; i += keyDetails.keySize) {
+            const block = data.slice(i, i + keyDetails.keySize);
             const decryptedBlock = node_crypto.privateDecrypt({
-                key: this._privateKey,
+                key: keyDetails.privateKey,
                 padding: node_crypto.constants.RSA_PKCS1_OAEP_PADDING
             }, block);
             blocks.push(decryptedBlock);
         }
         return core.Uint8ArrayHelper.concat(blocks);
     }
+    /**
+     * Decrypt the data using the public key.
+     * @param data The data to decrypt.
+     * @returns The data decrypted.
+     */
+    async publicDecrypt(data) {
+        core.Guards.uint8Array(RSA._CLASS_NAME, "data", data);
+        const keyDetails = await this.calculateKeyDetails();
+        if (data.length === 0) {
+            return new Uint8Array(0);
+        }
+        const blocks = [];
+        // Split encrypted data into blocks of key size
+        for (let i = 0; i < data.length; i += keyDetails.keySize) {
+            const block = data.slice(i, i + keyDetails.keySize);
+            const decryptedBlock = node_crypto.publicDecrypt({
+                key: keyDetails.publicKey,
+                padding: node_crypto.constants.RSA_PKCS1_PADDING
+            }, block);
+            blocks.push(decryptedBlock);
+        }
+        return core.Uint8ArrayHelper.concat(blocks);
+    }
+    /**
+     * Calculate key details.
+     * @internal
+     */
+    async calculateKeyDetails() {
+        if (core.Is.empty(this._publicKey) || core.Is.empty(this._keySize) || core.Is.empty(this._blockSize)) {
+            this._publicKey = node_crypto.createPublicKey({
+                key: Buffer.from(this._publicKeyBytes),
+                format: "der",
+                type: "spki"
+            });
+            if (!core.Is.empty(this._privateKeyBytes)) {
+                this._privateKey = node_crypto.createPrivateKey({
+                    key: Buffer.from(this._privateKeyBytes),
+                    format: "der",
+                    type: "pkcs8"
+                });
+            }
+            // Get modulus length in bits from key details
+            const modulusLengthBits = this._publicKey.asymmetricKeyDetails?.modulusLength;
+            if (core.Is.empty(modulusLengthBits)) {
+                throw new core.GeneralError(RSA._CLASS_NAME, "invalidKeySize");
+            }
+            // Convert bits to bytes
+            this._keySize = Math.ceil(modulusLengthBits / 8);
+            // Calculate block size for OAEP with SHA-256
+            // Formula: keySize - 2 * hashLength - 2
+            const hashLength = 32; // SHA-256 = 32 bytes
+            // eslint-disable-next-line no-mixed-operators
+            this._blockSize = this._keySize - 2 * hashLength - 2;
+        }
+        return {
+            publicKey: this._publicKey,
+            privateKey: this._privateKey,
+            keySize: this._keySize,
+            blockSize: this._blockSize
+        };
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.

package/dist/esm/index.mjs

@@ -6,7 +6,7 @@ import { blake2b } from '@noble/hashes/blake2b';
 import { HDKey as HDKey$1 } from '@scure/bip32';
 import { HDKey } from 'micro-key-producer/slip10.js';
 import { chacha20poly1305 } from '@noble/ciphers/chacha';
-import { createPublicKey, createPrivateKey, generateKeyPairSync, publicEncrypt, constants, privateDecrypt } from 'node:crypto';
+import { generateKeyPairSync, createPrivateKey, createPublicKey, publicEncrypt, constants, privateEncrypt, privateDecrypt, publicDecrypt } from 'node:crypto';
 import { blake3 } from '@noble/hashes/blake3';
 import { hmac } from '@noble/hashes/hmac';
 import { sha1 } from '@noble/hashes/sha1';
@@ -704,6 +704,16 @@ class RSA {
      * @internal
      */
     static _CLASS_NAME = "RSA";
+    /**
+     * The public key for encryption.
+     * @internal
+     */
+    _publicKeyBytes;
+    /**
+     * The private key for decryption.
+     * @internal
+     */
+    _privateKeyBytes;
     /**
      * The public key for encryption.
      * @internal
@@ -731,37 +741,15 @@ class RSA {
      */
     constructor(publicKey, privateKey) {
         Guards.uint8Array(RSA._CLASS_NAME, "publicKey", publicKey);
-        this._publicKey = createPublicKey({
-            key: Buffer.from(publicKey),
-            format: "der",
-            type: "spki"
-        });
-        if (!Is.empty(privateKey)) {
-            this._privateKey = createPrivateKey({
-                key: Buffer.from(privateKey),
-                format: "der",
-                type: "pkcs8"
-            });
-        }
-        // Get modulus length in bits from key details
-        const modulusLengthBits = this._publicKey.asymmetricKeyDetails?.modulusLength;
-        if (Is.empty(modulusLengthBits)) {
-            throw new GeneralError(RSA._CLASS_NAME, "invalidKeySize");
-        }
-        // Convert bits to bytes
-        this._keySize = Math.ceil(modulusLengthBits / 8);
-        // Calculate block size for OAEP with SHA-256
-        // Formula: keySize - 2 * hashLength - 2
-        const hashLength = 32; // SHA-256 = 32 bytes
-        // eslint-disable-next-line no-mixed-operators
-        this._blockSize = this._keySize - 2 * hashLength - 2;
+        this._publicKeyBytes = publicKey;
+        this._privateKeyBytes = privateKey;
     }
     /**
      * Generate a new RSA key pair in PKCS8 format.
      * @param modulusLength The key size in bits (default: 2048).
      * @returns The public and private keys as Uint8Array.
      */
-    static generateKeyPair(modulusLength = 2048) {
+    static async generateKeyPair(modulusLength = 2048) {
         const { publicKey, privateKey } = generateKeyPairSync("rsa", {
             modulusLength,
             publicKeyEncoding: {
@@ -783,7 +771,7 @@ class RSA {
      * @param pkcs1Key The PKCS1 key as Uint8Array.
      * @returns The PKCS8 key as Uint8Array.
      */
-    static convertPkcs1ToPkcs8(pkcs1Key) {
+    static async convertPkcs1ToPkcs8(pkcs1Key) {
         Guards.uint8Array(RSA._CLASS_NAME, "pkcs1Key", pkcs1Key);
         const privateKey = createPrivateKey({
             key: Buffer.from(pkcs1Key),
@@ -800,7 +788,7 @@ class RSA {
      * @param pkcs8Key The PKCS8 key as Uint8Array.
      * @returns The key components.
      */
-    static getPrivateKeyComponents(pkcs8Key) {
+    static async getPrivateKeyComponents(pkcs8Key) {
         Guards.uint8Array(RSA._CLASS_NAME, "pkcs8Key", pkcs8Key);
         const privateKey = createPrivateKey({
             key: Buffer.from(pkcs8Key),
@@ -824,7 +812,7 @@ class RSA {
      * @param spkiKey The SPKI key as Uint8Array.
      * @returns The key components.
      */
-    static getPublicKeyComponents(spkiKey) {
+    static async getPublicKeyComponents(spkiKey) {
         Guards.uint8Array(RSA._CLASS_NAME, "spkiKey", spkiKey);
         const publicKey = createPublicKey({
             key: Buffer.from(spkiKey),
@@ -854,21 +842,22 @@ class RSA {
         return BigInt(`0x${hexString}`);
     }
     /**
-     * Encrypt the data.
+     * Encrypt the data using the public key.
      * @param data The data to encrypt.
      * @returns The data encrypted.
      */
-    encrypt(data) {
+    async publicEncrypt(data) {
         Guards.uint8Array(RSA._CLASS_NAME, "data", data);
         if (data.length === 0) {
             return new Uint8Array(0);
         }
+        const keyDetails = await this.calculateKeyDetails();
         const blocks = [];
         // Split data into blocks of block size
-        for (let i = 0; i < data.length; i += this._blockSize) {
-            const block = data.slice(i, i + this._blockSize);
+        for (let i = 0; i < data.length; i += keyDetails.blockSize) {
+            const block = data.slice(i, i + keyDetails.blockSize);
             const encryptedBlock = publicEncrypt({
-                key: this._publicKey,
+                key: keyDetails.publicKey,
                 padding: constants.RSA_PKCS1_OAEP_PADDING
             }, block);
             blocks.push(encryptedBlock);
@@ -876,14 +865,41 @@ class RSA {
         return Uint8ArrayHelper.concat(blocks);
     }
     /**
-     * Decrypt the data.
+     * Encrypt the data using the private key.
+     * @param data The data to encrypt.
+     * @returns The data encrypted.
+     */
+    async privateEncrypt(data) {
+        Guards.uint8Array(RSA._CLASS_NAME, "data", data);
+        const keyDetails = await this.calculateKeyDetails();
+        if (Is.empty(keyDetails.privateKey)) {
+            throw new GeneralError(RSA._CLASS_NAME, "noPrivateKey");
+        }
+        if (data.length === 0) {
+            return new Uint8Array(0);
+        }
+        const blocks = [];
+        // Split data into blocks of block size
+        for (let i = 0; i < data.length; i += keyDetails.blockSize) {
+            const block = data.slice(i, i + keyDetails.blockSize);
+            const encryptedBlock = privateEncrypt({
+                key: keyDetails.privateKey,
+                padding: constants.RSA_PKCS1_PADDING
+            }, block);
+            blocks.push(encryptedBlock);
+        }
+        return Uint8ArrayHelper.concat(blocks);
+    }
+    /**
+     * Decrypt the data using the private key.
      * @param data The data to decrypt.
      * @returns The data decrypted.
      * @throws GeneralError If no private key is provided.
      */
-    decrypt(data) {
+    async privateDecrypt(data) {
         Guards.uint8Array(RSA._CLASS_NAME, "data", data);
-        if (Is.empty(this._privateKey)) {
+        const keyDetails = await this.calculateKeyDetails();
+        if (Is.empty(keyDetails.privateKey)) {
             throw new GeneralError(RSA._CLASS_NAME, "noPrivateKey");
         }
         if (data.length === 0) {
@@ -891,16 +907,77 @@ class RSA {
         }
         const blocks = [];
         // Split encrypted data into blocks of key size
-        for (let i = 0; i < data.length; i += this._keySize) {
-            const block = data.slice(i, i + this._keySize);
+        for (let i = 0; i < data.length; i += keyDetails.keySize) {
+            const block = data.slice(i, i + keyDetails.keySize);
             const decryptedBlock = privateDecrypt({
-                key: this._privateKey,
+                key: keyDetails.privateKey,
                 padding: constants.RSA_PKCS1_OAEP_PADDING
             }, block);
             blocks.push(decryptedBlock);
         }
         return Uint8ArrayHelper.concat(blocks);
     }
+    /**
+     * Decrypt the data using the public key.
+     * @param data The data to decrypt.
+     * @returns The data decrypted.
+     */
+    async publicDecrypt(data) {
+        Guards.uint8Array(RSA._CLASS_NAME, "data", data);
+        const keyDetails = await this.calculateKeyDetails();
+        if (data.length === 0) {
+            return new Uint8Array(0);
+        }
+        const blocks = [];
+        // Split encrypted data into blocks of key size
+        for (let i = 0; i < data.length; i += keyDetails.keySize) {
+            const block = data.slice(i, i + keyDetails.keySize);
+            const decryptedBlock = publicDecrypt({
+                key: keyDetails.publicKey,
+                padding: constants.RSA_PKCS1_PADDING
+            }, block);
+            blocks.push(decryptedBlock);
+        }
+        return Uint8ArrayHelper.concat(blocks);
+    }
+    /**
+     * Calculate key details.
+     * @internal
+     */
+    async calculateKeyDetails() {
+        if (Is.empty(this._publicKey) || Is.empty(this._keySize) || Is.empty(this._blockSize)) {
+            this._publicKey = createPublicKey({
+                key: Buffer.from(this._publicKeyBytes),
+                format: "der",
+                type: "spki"
+            });
+            if (!Is.empty(this._privateKeyBytes)) {
+                this._privateKey = createPrivateKey({
+                    key: Buffer.from(this._privateKeyBytes),
+                    format: "der",
+                    type: "pkcs8"
+                });
+            }
+            // Get modulus length in bits from key details
+            const modulusLengthBits = this._publicKey.asymmetricKeyDetails?.modulusLength;
+            if (Is.empty(modulusLengthBits)) {
+                throw new GeneralError(RSA._CLASS_NAME, "invalidKeySize");
+            }
+            // Convert bits to bytes
+            this._keySize = Math.ceil(modulusLengthBits / 8);
+            // Calculate block size for OAEP with SHA-256
+            // Formula: keySize - 2 * hashLength - 2
+            const hashLength = 32; // SHA-256 = 32 bytes
+            // eslint-disable-next-line no-mixed-operators
+            this._blockSize = this._keySize - 2 * hashLength - 2;
+        }
+        return {
+            publicKey: this._publicKey,
+            privateKey: this._privateKey,
+            keySize: this._keySize,
+            blockSize: this._blockSize
+        };
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.

package/dist/types/ciphers/rsa.d.ts

@@ -13,22 +13,22 @@ export declare class RSA {
      * @param modulusLength The key size in bits (default: 2048).
      * @returns The public and private keys as Uint8Array.
      */
-    static generateKeyPair(modulusLength?: number): {
+    static generateKeyPair(modulusLength?: number): Promise<{
         publicKey: Uint8Array;
         privateKey: Uint8Array;
-    };
+    }>;
     /**
      * Convert a PKCS1 key to a PKCS8 key.
      * @param pkcs1Key The PKCS1 key as Uint8Array.
      * @returns The PKCS8 key as Uint8Array.
      */
-    static convertPkcs1ToPkcs8(pkcs1Key: Uint8Array): Uint8Array;
+    static convertPkcs1ToPkcs8(pkcs1Key: Uint8Array): Promise<Uint8Array>;
     /**
      * Break the private key down in to its components.
      * @param pkcs8Key The PKCS8 key as Uint8Array.
      * @returns The key components.
      */
-    static getPrivateKeyComponents(pkcs8Key: Uint8Array): {
+    static getPrivateKeyComponents(pkcs8Key: Uint8Array): Promise<{
         n: bigint;
         e: bigint;
         d: bigint;
@@ -37,27 +37,39 @@ export declare class RSA {
         dp: bigint;
         dq: bigint;
         qi: bigint;
-    };
+    }>;
     /**
      * Break the public key down in to its components.
      * @param spkiKey The SPKI key as Uint8Array.
      * @returns The key components.
      */
-    static getPublicKeyComponents(spkiKey: Uint8Array): {
+    static getPublicKeyComponents(spkiKey: Uint8Array): Promise<{
         n: bigint;
         e: bigint;
-    };
+    }>;
     /**
-     * Encrypt the data.
+     * Encrypt the data using the public key.
      * @param data The data to encrypt.
      * @returns The data encrypted.
      */
-    encrypt(data: Uint8Array): Uint8Array;
+    publicEncrypt(data: Uint8Array): Promise<Uint8Array>;
     /**
-     * Decrypt the data.
+     * Encrypt the data using the private key.
+     * @param data The data to encrypt.
+     * @returns The data encrypted.
+     */
+    privateEncrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt the data using the private key.
      * @param data The data to decrypt.
      * @returns The data decrypted.
      * @throws GeneralError If no private key is provided.
      */
-    decrypt(data: Uint8Array): Uint8Array;
+    privateDecrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt the data using the public key.
+     * @param data The data to decrypt.
+     * @returns The data decrypted.
+     */
+    publicDecrypt(data: Uint8Array): Promise<Uint8Array>;
 }

package/docs/changelog.md

@@ -1,5 +1,23 @@
 # @twin.org/crypto - Changelog
 
+## [0.0.2-next.4](https://github.com/twinfoundation/framework/compare/crypto-v0.0.2-next.3...crypto-v0.0.2-next.4) (2025-08-15)
+
+
+### Features
+
+* additional RSA methods and async ([1fceee2](https://github.com/twinfoundation/framework/commit/1fceee2d1248a24a7620846025fcf906495c07f4))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/core bumped from 0.0.2-next.3 to 0.0.2-next.4
+    * @twin.org/nameof bumped from 0.0.2-next.3 to 0.0.2-next.4
+  * devDependencies
+    * @twin.org/nameof-transformer bumped from 0.0.2-next.3 to 0.0.2-next.4
+    * @twin.org/nameof-vitest-plugin bumped from 0.0.2-next.3 to 0.0.2-next.4
+
 ## [0.0.2-next.3](https://github.com/twinfoundation/framework/compare/crypto-v0.0.2-next.2...crypto-v0.0.2-next.3) (2025-08-06)
 
 

package/docs/reference/classes/RSA.md

@@ -32,7 +32,7 @@ The private key for decryption (DER format as Uint8Array).
 
 ### generateKeyPair()
 
-> `static` **generateKeyPair**(`modulusLength`): `object`
+> `static` **generateKeyPair**(`modulusLength`): `Promise`\<\{ `publicKey`: `Uint8Array`; `privateKey`: `Uint8Array`; \}\>
 
 Generate a new RSA key pair in PKCS8 format.
 
@@ -46,23 +46,15 @@ The key size in bits (default: 2048).
 
 #### Returns
 
-`object`
+`Promise`\<\{ `publicKey`: `Uint8Array`; `privateKey`: `Uint8Array`; \}\>
 
 The public and private keys as Uint8Array.
 
-##### publicKey
-
-> **publicKey**: `Uint8Array`
-
-##### privateKey
-
-> **privateKey**: `Uint8Array`
-
 ***
 
 ### convertPkcs1ToPkcs8()
 
-> `static` **convertPkcs1ToPkcs8**(`pkcs1Key`): `Uint8Array`
+> `static` **convertPkcs1ToPkcs8**(`pkcs1Key`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
 Convert a PKCS1 key to a PKCS8 key.
 
@@ -76,7 +68,7 @@ The PKCS1 key as Uint8Array.
 
 #### Returns
 
-`Uint8Array`
+`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
 The PKCS8 key as Uint8Array.
 
@@ -84,7 +76,7 @@ The PKCS8 key as Uint8Array.
 
 ### getPrivateKeyComponents()
 
-> `static` **getPrivateKeyComponents**(`pkcs8Key`): `object`
+> `static` **getPrivateKeyComponents**(`pkcs8Key`): `Promise`\<\{ `n`: `bigint`; `e`: `bigint`; `d`: `bigint`; `p`: `bigint`; `q`: `bigint`; `dp`: `bigint`; `dq`: `bigint`; `qi`: `bigint`; \}\>
 
 Break the private key down in to its components.
 
@@ -98,79 +90,61 @@ The PKCS8 key as Uint8Array.
 
 #### Returns
 
-`object`
+`Promise`\<\{ `n`: `bigint`; `e`: `bigint`; `d`: `bigint`; `p`: `bigint`; `q`: `bigint`; `dp`: `bigint`; `dq`: `bigint`; `qi`: `bigint`; \}\>
 
 The key components.
 
-##### n
-
-> **n**: `bigint`
-
-##### e
-
-> **e**: `bigint`
-
-##### d
-
-> **d**: `bigint`
+***
 
-##### p
+### getPublicKeyComponents()
 
-> **p**: `bigint`
+> `static` **getPublicKeyComponents**(`spkiKey`): `Promise`\<\{ `n`: `bigint`; `e`: `bigint`; \}\>
 
-##### q
+Break the public key down in to its components.
 
-> **q**: `bigint`
+#### Parameters
 
-##### dp
+##### spkiKey
 
-> **dp**: `bigint`
+`Uint8Array`
 
-##### dq
+The SPKI key as Uint8Array.
 
-> **dq**: `bigint`
+#### Returns
 
-##### qi
+`Promise`\<\{ `n`: `bigint`; `e`: `bigint`; \}\>
 
-> **qi**: `bigint`
+The key components.
 
 ***
 
-### getPublicKeyComponents()
+### publicEncrypt()
 
-> `static` **getPublicKeyComponents**(`spkiKey`): `object`
+> **publicEncrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
-Break the public key down in to its components.
+Encrypt the data using the public key.
 
 #### Parameters
 
-##### spkiKey
+##### data
 
 `Uint8Array`
 
-The SPKI key as Uint8Array.
+The data to encrypt.
 
 #### Returns
 
-`object`
+`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
-The key components.
-
-##### n
-
-> **n**: `bigint`
-
-##### e
-
-> **e**: `bigint`
+The data encrypted.
 
 ***
 
-### encrypt()
+### privateEncrypt()
 
-> **encrypt**(`data`): `Uint8Array`
+> **privateEncrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
-Encrypt the data.
+Encrypt the data using the private key.
 
 #### Parameters
 
@@ -182,17 +156,17 @@ The data to encrypt.
 
 #### Returns
 
-`Uint8Array`
+`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
 The data encrypted.
 
 ***
 
-### decrypt()
+### privateDecrypt()
 
-> **decrypt**(`data`): `Uint8Array`
+> **privateDecrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
-Decrypt the data.
+Decrypt the data using the private key.
 
 #### Parameters
 
@@ -204,10 +178,32 @@ The data to decrypt.
 
 #### Returns
 
-`Uint8Array`
+`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
 
 The data decrypted.
 
 #### Throws
 
 GeneralError If no private key is provided.
+
+***
+
+### publicDecrypt()
+
+> **publicDecrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
+
+Decrypt the data using the public key.
+
+#### Parameters
+
+##### data
+
+`Uint8Array`
+
+The data to decrypt.
+
+#### Returns
+
+`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
+
+The data decrypted.

package/locales/en.json

@@ -65,7 +65,7 @@
 			"invalidSeed": "The seed is invalid \"{seed}\""
 		},
 		"rsa": {
-			"noPrivateKey": "Private key is required for decryption",
+			"noPrivateKey": "Private key is required for this operation",
 			"invalidKeySize": "Invalid RSA key size"
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/crypto",
-	"version": "0.0.2-next.3",
+	"version": "0.0.2-next.4",
 	"description": "Contains helper methods and classes which implement cryptographic functions",
 	"repository": {
 		"type": "git",
@@ -20,8 +20,9 @@
 		"@scure/base": "1.2.6",
 		"@scure/bip32": "1.7.0",
 		"@scure/bip39": "1.6.0",
-		"@twin.org/core": "0.0.2-next.3",
-		"@twin.org/nameof": "0.0.2-next.3",
+		"@twin.org/core": "0.0.2-next.4",
+		"@twin.org/nameof": "0.0.2-next.4",
+		"crypto-browserify": "3.12.1",
 		"micro-key-producer": "0.7.6"
 	},
 	"main": "./dist/cjs/index.cjs",