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

package/dist/cjs/index.cjs

@@ -8,7 +8,6 @@ var blake2b = require('@noble/hashes/blake2b');
 var bip32 = require('@scure/bip32');
 var slip10_js = require('micro-key-producer/slip10.js');
 var chacha = require('@noble/ciphers/chacha');
-var node_crypto = require('node:crypto');
 var blake3 = require('@noble/hashes/blake3');
 var hmac = require('@noble/hashes/hmac');
 var sha1 = require('@noble/hashes/sha1');
@@ -208,7 +207,7 @@ class Ed25519 {
         // The ASN.1 sequence is 48 46 02 01 00 30 05 06 03 2b 65 70 04 20 04 20 (0x302e020100300506032b657004220420)
         const pkcs8Prefix = new Uint8Array([48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
         const fullKey = core.Uint8ArrayHelper.concat([pkcs8Prefix, privateKey]);
-        return crypto.subtle.importKey("pkcs8", fullKey, "Ed25519", true, ["sign"]);
+        return crypto.subtle.importKey("pkcs8", new Uint8Array(fullKey), "Ed25519", true, ["sign"]);
     }
     /**
      * Convert a crypto key to raw private key.
@@ -715,293 +714,6 @@ class ChaCha20Poly1305 {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Implementation of the RSA cipher.
- */
-class RSA {
-    /**
-     * Runtime name for the class.
-     * @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
-     */
-    _publicKey;
-    /**
-     * The private key for decryption.
-     * @internal
-     */
-    _privateKey;
-    /**
-     * The block size for encryption.
-     * @internal
-     */
-    _blockSize;
-    /**
-     * The key size for decryption.
-     * @internal
-     */
-    _keySize;
-    /**
-     * Create a new instance of RSA.
-     * @param publicKey The public key for encryption (DER format as Uint8Array).
-     * @param privateKey The private key for decryption (DER format as Uint8Array).
-     */
-    constructor(publicKey, privateKey) {
-        core.Guards.uint8Array(RSA._CLASS_NAME, "publicKey", publicKey);
-        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 async generateKeyPair(modulusLength = 2048) {
-        const { publicKey, privateKey } = node_crypto.generateKeyPairSync("rsa", {
-            modulusLength,
-            publicKeyEncoding: {
-                type: "spki",
-                format: "der"
-            },
-            privateKeyEncoding: {
-                type: "pkcs8",
-                format: "der"
-            }
-        });
-        return {
-            publicKey: new Uint8Array(publicKey),
-            privateKey: new Uint8Array(privateKey)
-        };
-    }
-    /**
-     * Convert a PKCS1 key to a PKCS8 key.
-     * @param pkcs1Key The PKCS1 key as Uint8Array.
-     * @returns The PKCS8 key as Uint8Array.
-     */
-    static async convertPkcs1ToPkcs8(pkcs1Key) {
-        core.Guards.uint8Array(RSA._CLASS_NAME, "pkcs1Key", pkcs1Key);
-        const privateKey = node_crypto.createPrivateKey({
-            key: Buffer.from(pkcs1Key),
-            format: "der",
-            type: "pkcs1"
-        });
-        return new Uint8Array(privateKey.export({
-            format: "der",
-            type: "pkcs8"
-        }));
-    }
-    /**
-     * Break the private key down in to its components.
-     * @param pkcs8Key The PKCS8 key as Uint8Array.
-     * @returns The key components.
-     */
-    static async getPrivateKeyComponents(pkcs8Key) {
-        core.Guards.uint8Array(RSA._CLASS_NAME, "pkcs8Key", pkcs8Key);
-        const privateKey = node_crypto.createPrivateKey({
-            key: Buffer.from(pkcs8Key),
-            format: "der",
-            type: "pkcs8"
-        });
-        const jwk = privateKey.export({ format: "jwk" });
-        return {
-            n: this.base64UrlToBigInt(jwk.n),
-            e: this.base64UrlToBigInt(jwk.e),
-            d: this.base64UrlToBigInt(jwk.d),
-            p: this.base64UrlToBigInt(jwk.p),
-            q: this.base64UrlToBigInt(jwk.q),
-            dp: this.base64UrlToBigInt(jwk.dp),
-            dq: this.base64UrlToBigInt(jwk.dq),
-            qi: this.base64UrlToBigInt(jwk.qi)
-        };
-    }
-    /**
-     * Break the public key down in to its components.
-     * @param spkiKey The SPKI key as Uint8Array.
-     * @returns The key components.
-     */
-    static async getPublicKeyComponents(spkiKey) {
-        core.Guards.uint8Array(RSA._CLASS_NAME, "spkiKey", spkiKey);
-        const publicKey = node_crypto.createPublicKey({
-            key: Buffer.from(spkiKey),
-            format: "der",
-            type: "spki"
-        });
-        const jwk = publicKey.export({ format: "jwk" });
-        return {
-            n: this.base64UrlToBigInt(jwk.n),
-            e: this.base64UrlToBigInt(jwk.e)
-        };
-    }
-    /**
-     * Convert base64 encoded data to a big int.
-     * @param bytes The bytes to convert.
-     * @returns The bigint representation of the bytes.
-     * @internal
-     */
-    static base64UrlToBigInt(base64Url) {
-        if (core.Is.empty(base64Url)) {
-            return BigInt(0);
-        }
-        const bytes = core.Converter.base64UrlToBytes(base64Url);
-        const hexString = Array.from(bytes)
-            .map(byte => byte.toString(16).padStart(2, "0"))
-            .join("");
-        return BigInt(`0x${hexString}`);
-    }
-    /**
-     * Encrypt the data using the public key.
-     * @param data The data to encrypt.
-     * @returns The data encrypted.
-     */
-    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 += keyDetails.blockSize) {
-            const block = data.slice(i, i + keyDetails.blockSize);
-            const encryptedBlock = node_crypto.publicEncrypt({
-                key: keyDetails.publicKey,
-                padding: node_crypto.constants.RSA_PKCS1_OAEP_PADDING
-            }, block);
-            blocks.push(encryptedBlock);
-        }
-        return core.Uint8ArrayHelper.concat(blocks);
-    }
-    /**
-     * 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.
-     */
-    async privateDecrypt(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 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.privateDecrypt({
-                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.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1020,7 +732,7 @@ class X25519 {
      */
     static convertPrivateKeyToX25519(ed25519PrivateKey) {
         core.Guards.uint8Array(X25519._CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
-        return ed25519.edwardsToMontgomeryPriv(ed25519PrivateKey);
+        return ed25519.ed25519.utils.toMontgomerySecret(ed25519PrivateKey.slice(0, Ed25519.PRIVATE_KEY_SIZE));
     }
     /**
      * Convert Ed25519 public key to X25519 public key.
@@ -1030,7 +742,7 @@ class X25519 {
      */
     static convertPublicKeyToX25519(ed25519PublicKey) {
         core.Guards.uint8Array(X25519._CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
-        return ed25519.edwardsToMontgomeryPub(ed25519PublicKey);
+        return ed25519.ed25519.utils.toMontgomery(ed25519PublicKey);
     }
 }
 
@@ -2140,7 +1852,6 @@ exports.PasswordGenerator = PasswordGenerator;
 exports.PasswordValidator = PasswordValidator;
 exports.Pbkdf2 = Pbkdf2;
 exports.PemHelper = PemHelper;
-exports.RSA = RSA;
 exports.Secp256k1 = Secp256k1;
 exports.Sha1 = Sha1;
 exports.Sha256 = Sha256;

package/dist/esm/index.mjs

@@ -1,12 +1,11 @@
 import { bech32 } from '@scure/base';
 import { Guards, BaseError, GeneralError, Is, Uint8ArrayHelper, Converter, GuardError, Base32, RandomHelper, Validation } from '@twin.org/core';
-import { ed25519, edwardsToMontgomeryPriv, edwardsToMontgomeryPub } from '@noble/curves/ed25519';
+import { ed25519 } from '@noble/curves/ed25519';
 import { secp256k1 } from '@noble/curves/secp256k1';
 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 { 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';
@@ -186,7 +185,7 @@ class Ed25519 {
         // The ASN.1 sequence is 48 46 02 01 00 30 05 06 03 2b 65 70 04 20 04 20 (0x302e020100300506032b657004220420)
         const pkcs8Prefix = new Uint8Array([48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
         const fullKey = Uint8ArrayHelper.concat([pkcs8Prefix, privateKey]);
-        return crypto.subtle.importKey("pkcs8", fullKey, "Ed25519", true, ["sign"]);
+        return crypto.subtle.importKey("pkcs8", new Uint8Array(fullKey), "Ed25519", true, ["sign"]);
     }
     /**
      * Convert a crypto key to raw private key.
@@ -693,293 +692,6 @@ class ChaCha20Poly1305 {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Implementation of the RSA cipher.
- */
-class RSA {
-    /**
-     * Runtime name for the class.
-     * @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
-     */
-    _publicKey;
-    /**
-     * The private key for decryption.
-     * @internal
-     */
-    _privateKey;
-    /**
-     * The block size for encryption.
-     * @internal
-     */
-    _blockSize;
-    /**
-     * The key size for decryption.
-     * @internal
-     */
-    _keySize;
-    /**
-     * Create a new instance of RSA.
-     * @param publicKey The public key for encryption (DER format as Uint8Array).
-     * @param privateKey The private key for decryption (DER format as Uint8Array).
-     */
-    constructor(publicKey, privateKey) {
-        Guards.uint8Array(RSA._CLASS_NAME, "publicKey", publicKey);
-        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 async generateKeyPair(modulusLength = 2048) {
-        const { publicKey, privateKey } = generateKeyPairSync("rsa", {
-            modulusLength,
-            publicKeyEncoding: {
-                type: "spki",
-                format: "der"
-            },
-            privateKeyEncoding: {
-                type: "pkcs8",
-                format: "der"
-            }
-        });
-        return {
-            publicKey: new Uint8Array(publicKey),
-            privateKey: new Uint8Array(privateKey)
-        };
-    }
-    /**
-     * Convert a PKCS1 key to a PKCS8 key.
-     * @param pkcs1Key The PKCS1 key as Uint8Array.
-     * @returns The PKCS8 key as Uint8Array.
-     */
-    static async convertPkcs1ToPkcs8(pkcs1Key) {
-        Guards.uint8Array(RSA._CLASS_NAME, "pkcs1Key", pkcs1Key);
-        const privateKey = createPrivateKey({
-            key: Buffer.from(pkcs1Key),
-            format: "der",
-            type: "pkcs1"
-        });
-        return new Uint8Array(privateKey.export({
-            format: "der",
-            type: "pkcs8"
-        }));
-    }
-    /**
-     * Break the private key down in to its components.
-     * @param pkcs8Key The PKCS8 key as Uint8Array.
-     * @returns The key components.
-     */
-    static async getPrivateKeyComponents(pkcs8Key) {
-        Guards.uint8Array(RSA._CLASS_NAME, "pkcs8Key", pkcs8Key);
-        const privateKey = createPrivateKey({
-            key: Buffer.from(pkcs8Key),
-            format: "der",
-            type: "pkcs8"
-        });
-        const jwk = privateKey.export({ format: "jwk" });
-        return {
-            n: this.base64UrlToBigInt(jwk.n),
-            e: this.base64UrlToBigInt(jwk.e),
-            d: this.base64UrlToBigInt(jwk.d),
-            p: this.base64UrlToBigInt(jwk.p),
-            q: this.base64UrlToBigInt(jwk.q),
-            dp: this.base64UrlToBigInt(jwk.dp),
-            dq: this.base64UrlToBigInt(jwk.dq),
-            qi: this.base64UrlToBigInt(jwk.qi)
-        };
-    }
-    /**
-     * Break the public key down in to its components.
-     * @param spkiKey The SPKI key as Uint8Array.
-     * @returns The key components.
-     */
-    static async getPublicKeyComponents(spkiKey) {
-        Guards.uint8Array(RSA._CLASS_NAME, "spkiKey", spkiKey);
-        const publicKey = createPublicKey({
-            key: Buffer.from(spkiKey),
-            format: "der",
-            type: "spki"
-        });
-        const jwk = publicKey.export({ format: "jwk" });
-        return {
-            n: this.base64UrlToBigInt(jwk.n),
-            e: this.base64UrlToBigInt(jwk.e)
-        };
-    }
-    /**
-     * Convert base64 encoded data to a big int.
-     * @param bytes The bytes to convert.
-     * @returns The bigint representation of the bytes.
-     * @internal
-     */
-    static base64UrlToBigInt(base64Url) {
-        if (Is.empty(base64Url)) {
-            return BigInt(0);
-        }
-        const bytes = Converter.base64UrlToBytes(base64Url);
-        const hexString = Array.from(bytes)
-            .map(byte => byte.toString(16).padStart(2, "0"))
-            .join("");
-        return BigInt(`0x${hexString}`);
-    }
-    /**
-     * Encrypt the data using the public key.
-     * @param data The data to encrypt.
-     * @returns The data encrypted.
-     */
-    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 += keyDetails.blockSize) {
-            const block = data.slice(i, i + keyDetails.blockSize);
-            const encryptedBlock = publicEncrypt({
-                key: keyDetails.publicKey,
-                padding: constants.RSA_PKCS1_OAEP_PADDING
-            }, block);
-            blocks.push(encryptedBlock);
-        }
-        return Uint8ArrayHelper.concat(blocks);
-    }
-    /**
-     * 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.
-     */
-    async privateDecrypt(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 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 = privateDecrypt({
-                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.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -998,7 +710,7 @@ class X25519 {
      */
     static convertPrivateKeyToX25519(ed25519PrivateKey) {
         Guards.uint8Array(X25519._CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
-        return edwardsToMontgomeryPriv(ed25519PrivateKey);
+        return ed25519.utils.toMontgomerySecret(ed25519PrivateKey.slice(0, Ed25519.PRIVATE_KEY_SIZE));
     }
     /**
      * Convert Ed25519 public key to X25519 public key.
@@ -1008,7 +720,7 @@ class X25519 {
      */
     static convertPublicKeyToX25519(ed25519PublicKey) {
         Guards.uint8Array(X25519._CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
-        return edwardsToMontgomeryPub(ed25519PublicKey);
+        return ed25519.utils.toMontgomery(ed25519PublicKey);
     }
 }
 
@@ -2101,4 +1813,4 @@ class PasswordValidator {
     }
 }
 
-export { Bech32, Bip32Path, Bip39, Bip44, Blake2b, Blake3, ChaCha20Poly1305, Ed25519, HmacSha1, HmacSha256, HmacSha512, Hotp, KeyType, PasswordGenerator, PasswordValidator, Pbkdf2, PemHelper, RSA, Secp256k1, Sha1, Sha256, Sha3, Sha512, Slip0010, Totp, X25519, Zip215 };
+export { Bech32, Bip32Path, Bip39, Bip44, Blake2b, Blake3, ChaCha20Poly1305, Ed25519, HmacSha1, HmacSha256, HmacSha512, Hotp, KeyType, PasswordGenerator, PasswordValidator, Pbkdf2, PemHelper, Secp256k1, Sha1, Sha256, Sha3, Sha512, Slip0010, Totp, X25519, Zip215 };

package/dist/types/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./address/bech32";
 export * from "./address/bip44";
 export * from "./ciphers/chaCha20Poly1305";
-export * from "./ciphers/rsa";
 export * from "./curves/ed25519";
 export * from "./curves/secp256k1";
 export * from "./curves/x25519";

package/docs/changelog.md

@@ -1,5 +1,23 @@
 # @twin.org/crypto - Changelog
 
+## [0.0.2-next.5](https://github.com/twinfoundation/framework/compare/crypto-v0.0.2-next.4...crypto-v0.0.2-next.5) (2025-08-19)
+
+
+### Features
+
+* use cause instead of inner for errors ([1f4acc4](https://github.com/twinfoundation/framework/commit/1f4acc4d7a6b71a134d9547da9bf40de1e1e49da))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/core bumped from 0.0.2-next.4 to 0.0.2-next.5
+    * @twin.org/nameof bumped from 0.0.2-next.4 to 0.0.2-next.5
+  * devDependencies
+    * @twin.org/nameof-transformer bumped from 0.0.2-next.4 to 0.0.2-next.5
+    * @twin.org/nameof-vitest-plugin bumped from 0.0.2-next.4 to 0.0.2-next.5
+
 ## [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)
 
 

package/docs/reference/index.md

@@ -5,7 +5,6 @@
 - [Bech32](classes/Bech32.md)
 - [Bip44](classes/Bip44.md)
 - [ChaCha20Poly1305](classes/ChaCha20Poly1305.md)
-- [RSA](classes/RSA.md)
 - [Ed25519](classes/Ed25519.md)
 - [Secp256k1](classes/Secp256k1.md)
 - [X25519](classes/X25519.md)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/crypto",
-	"version": "0.0.2-next.4",
+	"version": "0.0.2-next.5",
 	"description": "Contains helper methods and classes which implement cryptographic functions",
 	"repository": {
 		"type": "git",
@@ -15,13 +15,13 @@
 	},
 	"dependencies": {
 		"@noble/ciphers": "1.3.0",
-		"@noble/curves": "1.9.2",
+		"@noble/curves": "1.9.7",
 		"@noble/hashes": "1.8.0",
 		"@scure/base": "1.2.6",
 		"@scure/bip32": "1.7.0",
 		"@scure/bip39": "1.6.0",
-		"@twin.org/core": "0.0.2-next.4",
-		"@twin.org/nameof": "0.0.2-next.4",
+		"@twin.org/core": "0.0.2-next.5",
+		"@twin.org/nameof": "0.0.2-next.5",
 		"crypto-browserify": "3.12.1",
 		"micro-key-producer": "0.7.6"
 	},

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

@@ -1,75 +0,0 @@
-/**
- * Implementation of the RSA cipher.
- */
-export declare class RSA {
-    /**
-     * Create a new instance of RSA.
-     * @param publicKey The public key for encryption (DER format as Uint8Array).
-     * @param privateKey The private key for decryption (DER format as Uint8Array).
-     */
-    constructor(publicKey: Uint8Array, privateKey?: Uint8Array);
-    /**
-     * 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?: 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): 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): Promise<{
-        n: bigint;
-        e: bigint;
-        d: bigint;
-        p: bigint;
-        q: bigint;
-        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): Promise<{
-        n: bigint;
-        e: bigint;
-    }>;
-    /**
-     * Encrypt the data using the public key.
-     * @param data The data to encrypt.
-     * @returns The data encrypted.
-     */
-    publicEncrypt(data: Uint8Array): Promise<Uint8Array>;
-    /**
-     * 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.
-     */
-    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/reference/classes/RSA.md

@@ -1,209 +0,0 @@
-# Class: RSA
-
-Implementation of the RSA cipher.
-
-## Constructors
-
-### Constructor
-
-> **new RSA**(`publicKey`, `privateKey?`): `RSA`
-
-Create a new instance of RSA.
-
-#### Parameters
-
-##### publicKey
-
-`Uint8Array`
-
-The public key for encryption (DER format as Uint8Array).
-
-##### privateKey?
-
-`Uint8Array`\<`ArrayBufferLike`\>
-
-The private key for decryption (DER format as Uint8Array).
-
-#### Returns
-
-`RSA`
-
-## Methods
-
-### generateKeyPair()
-
-> `static` **generateKeyPair**(`modulusLength`): `Promise`\<\{ `publicKey`: `Uint8Array`; `privateKey`: `Uint8Array`; \}\>
-
-Generate a new RSA key pair in PKCS8 format.
-
-#### Parameters
-
-##### modulusLength
-
-`number` = `2048`
-
-The key size in bits (default: 2048).
-
-#### Returns
-
-`Promise`\<\{ `publicKey`: `Uint8Array`; `privateKey`: `Uint8Array`; \}\>
-
-The public and private keys as Uint8Array.
-
-***
-
-### convertPkcs1ToPkcs8()
-
-> `static` **convertPkcs1ToPkcs8**(`pkcs1Key`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-Convert a PKCS1 key to a PKCS8 key.
-
-#### Parameters
-
-##### pkcs1Key
-
-`Uint8Array`
-
-The PKCS1 key as Uint8Array.
-
-#### Returns
-
-`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-The PKCS8 key as Uint8Array.
-
-***
-
-### getPrivateKeyComponents()
-
-> `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.
-
-#### Parameters
-
-##### pkcs8Key
-
-`Uint8Array`
-
-The PKCS8 key as Uint8Array.
-
-#### Returns
-
-`Promise`\<\{ `n`: `bigint`; `e`: `bigint`; `d`: `bigint`; `p`: `bigint`; `q`: `bigint`; `dp`: `bigint`; `dq`: `bigint`; `qi`: `bigint`; \}\>
-
-The key components.
-
-***
-
-### getPublicKeyComponents()
-
-> `static` **getPublicKeyComponents**(`spkiKey`): `Promise`\<\{ `n`: `bigint`; `e`: `bigint`; \}\>
-
-Break the public key down in to its components.
-
-#### Parameters
-
-##### spkiKey
-
-`Uint8Array`
-
-The SPKI key as Uint8Array.
-
-#### Returns
-
-`Promise`\<\{ `n`: `bigint`; `e`: `bigint`; \}\>
-
-The key components.
-
-***
-
-### publicEncrypt()
-
-> **publicEncrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-Encrypt the data using the public key.
-
-#### Parameters
-
-##### data
-
-`Uint8Array`
-
-The data to encrypt.
-
-#### Returns
-
-`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-The data encrypted.
-
-***
-
-### privateEncrypt()
-
-> **privateEncrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-Encrypt the data using the private key.
-
-#### Parameters
-
-##### data
-
-`Uint8Array`
-
-The data to encrypt.
-
-#### Returns
-
-`Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-The data encrypted.
-
-***
-
-### privateDecrypt()
-
-> **privateDecrypt**(`data`): `Promise`\<`Uint8Array`\<`ArrayBufferLike`\>\>
-
-Decrypt the data using the private key.
-
-#### Parameters
-
-##### data
-
-`Uint8Array`
-
-The data to decrypt.
-
-#### Returns
-
-`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.