@twin.org/crypto 0.0.1-next.9 → 0.0.2-next.10

package/dist/esm/index.mjs

@@ -1,20 +1,19 @@
 import { bech32 } from '@scure/base';
-import { Guards, BaseError, GeneralError, Is, Converter, GuardError, Base32, RandomHelper, Validation } from '@twin.org/core';
-import { ed25519, edwardsToMontgomeryPriv, edwardsToMontgomeryPub } from '@noble/curves/ed25519';
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { blake2b } from '@noble/hashes/blake2b';
+import { Guards, BaseError, GeneralError, Is, Uint8ArrayHelper, Converter, GuardError, Base32, RandomHelper, Validation } from '@twin.org/core';
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { blake2b } from '@noble/hashes/blake2.js';
 import { HDKey as HDKey$1 } from '@scure/bip32';
 import { HDKey } from 'micro-key-producer/slip10.js';
-import { chacha20poly1305 } from '@noble/ciphers/chacha';
-import { blake3 } from '@noble/hashes/blake3';
-import { hmac } from '@noble/hashes/hmac';
-import { sha1 } from '@noble/hashes/sha1';
-import { sha256, sha224 } from '@noble/hashes/sha256';
-import { sha512_224, sha512_256, sha384, sha512 } from '@noble/hashes/sha512';
-import { pbkdf2 } from '@noble/hashes/pbkdf2';
-import { sha3_224, sha3_256, sha3_384, sha3_512 } from '@noble/hashes/sha3';
+import { chacha20poly1305 } from '@noble/ciphers/chacha.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha1 } from '@noble/hashes/legacy.js';
+import { sha256, sha224, sha512_224, sha512_256, sha384, sha512 } from '@noble/hashes/sha2.js';
+import { pbkdf2 } from '@noble/hashes/pbkdf2.js';
+import { sha3_224, sha3_256, sha3_384, sha3_512 } from '@noble/hashes/sha3.js';
 import * as bip39 from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
+import { wordlist } from '@scure/bip39/wordlists/english.js';
 import * as otp from 'micro-key-producer/otp.js';
 
 // Copyright 2024 IOTA Stiftung.
@@ -166,6 +165,39 @@ class Ed25519 {
             return false;
         }
     }
+    /**
+     * Convert a private key in PKCS8 format.
+     * @param privateKey The private key to convert.
+     * @returns The private key in PKCS8 format.
+     */
+    static async privateKeyToPkcs8(privateKey) {
+        Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
+        if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
+            throw new GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+                requiredSize: Ed25519.PRIVATE_KEY_SIZE,
+                actualSize: privateKey.length
+            });
+        }
+        // crypto.subtle.importKey does not support Ed25519 keys in raw format.
+        // We need to convert the key to PKCS8 format before importing.
+        // The PKCS8 format is the raw key prefixed with the ASN.1 sequence for an Ed25519 private key.
+        // 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", new Uint8Array(fullKey), "Ed25519", true, ["sign"]);
+    }
+    /**
+     * Convert a crypto key to raw private key.
+     * @param cryptoKey The crypto key to convert.
+     * @returns The raw private key.
+     */
+    static async pkcs8ToPrivateKey(cryptoKey) {
+        Guards.defined(Ed25519._CLASS_NAME, "cryptoKey", cryptoKey);
+        // crypto.subtle.exportKey does not support Ed25519 keys in raw format.
+        // so we export as PKCS8 and remove the ASN.1 sequence prefix.
+        const pkcs8Bytes = await crypto.subtle.exportKey("pkcs8", cryptoKey);
+        return new Uint8Array(pkcs8Bytes.slice(16));
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -216,11 +248,11 @@ class Secp256k1 {
         if (privateKey.length !== Secp256k1.PRIVATE_KEY_SIZE) {
             throw new GeneralError(Secp256k1._CLASS_NAME, "privateKeyLength", {
                 requiredSize: Secp256k1.PRIVATE_KEY_SIZE,
-                actualSize: privateKey ? privateKey.length : 0
+                actualSize: privateKey.length
             });
         }
-        const res = secp256k1.sign(block, privateKey);
-        return res.toCompactRawBytes();
+        const res = secp256k1.sign(block, privateKey, { prehash: false });
+        return res;
     }
     /**
      * Verify reports whether sig is a valid signature of block by publicKey.
@@ -241,7 +273,7 @@ class Secp256k1 {
             });
         }
         try {
-            return secp256k1.verify(signature, block, publicKey);
+            return secp256k1.verify(signature, block, publicKey, { prehash: false });
         }
         catch {
             return false;
@@ -429,7 +461,6 @@ const KeyType = {
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
 /**
  * Class to help with slip0010 key derivation
  * https://github.com/satoshilabs/slips/blob/master/slip-0010.md.
@@ -570,6 +601,24 @@ class Bip44 {
     static basePath(coinType) {
         return `m/44'/${coinType}'`;
     }
+    /**
+     * Generate an address from the seed and parts.
+     * @param seed The account seed.
+     * @param keyType The key type.
+     * @param coinType The coin type.
+     * @param accountIndex The account index.
+     * @param isInternal Is this an internal address.
+     * @param addressIndex The address index.
+     * @returns The generated path and the associated keypair.
+     */
+    static address(seed, keyType, coinType, accountIndex, isInternal, addressIndex) {
+        const keyPair = Bip44.keyPair(seed, keyType, coinType, accountIndex, isInternal, addressIndex);
+        const addressData = Blake2b.sum256(keyPair.publicKey);
+        return {
+            address: Converter.bytesToHex(addressData, true),
+            ...keyPair
+        };
+    }
     /**
      * Generate a bech32 address from the seed and parts.
      * @param seed The account seed.
@@ -643,9 +692,6 @@ class ChaCha20Poly1305 {
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/**
- * This is a TypeScript port of https://github.com/katzenpost/core/blob/master/crypto/extra25519/extra25519.go.
- */
 /**
  * Implementation of X25519.
  */
@@ -662,7 +708,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.
@@ -672,7 +718,7 @@ class X25519 {
      */
     static convertPublicKeyToX25519(ed25519PublicKey) {
         Guards.uint8Array(X25519._CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
-        return edwardsToMontgomeryPub(ed25519PublicKey);
+        return ed25519.utils.toMontgomery(ed25519PublicKey);
     }
 }
 
@@ -1453,6 +1499,48 @@ class Sha512 {
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Helper class for working with PEM (Privacy-Enhanced Mail) formatted data.
+ */
+class PemHelper {
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    static _CLASS_NAME = "PemHelper";
+    /**
+     * Strip the PEM content of its headers, footers, and newlines.
+     * @param pemContent The PEM content to strip.
+     * @returns The stripped PEM content in bas64 format.
+     */
+    static stripPemMarkers(pemContent) {
+        Guards.string(PemHelper._CLASS_NAME, "pemContent", pemContent);
+        return pemContent
+            .replace(/-----BEGIN.*-----/, "")
+            .replace(/-----END.*-----/, "")
+            .replace(/\n/g, "")
+            .trim();
+    }
+    /**
+     * Format the PEM content to have a specific line length.
+     * @param marker The marker for the PEM content, e.g. RSA PRIVATE KEY
+     * @param base64Content The base64 content to format.
+     * @param lineLength The length of each line in the PEM content, default is 64 characters.
+     * @returns The formatted PEM content.
+     */
+    static formatPem(marker, base64Content, lineLength = 64) {
+        Guards.stringValue(PemHelper._CLASS_NAME, "marker", marker);
+        Guards.stringBase64(PemHelper._CLASS_NAME, "base64Content", base64Content);
+        const lines = [];
+        for (let i = 0; i < base64Content.length; i += lineLength) {
+            lines.push(base64Content.slice(i, i + lineLength));
+        }
+        return [`-----BEGIN ${marker}-----`, ...lines, `-----END ${marker}-----`].join("\n");
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1516,11 +1604,26 @@ class Bip39 {
         Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
         return bip39.mnemonicToEntropy(mnemonic, words);
     }
+    /**
+     * Validate the mnemonic.
+     * @param mnemonic The mnemonic to validate.
+     * @param wordCount The expected number of words in the mnemonic, defaults to 24.
+     * @param words The wordlist to use, defaults to the English wordlist.
+     * @returns True if the mnemonic is valid.
+     */
+    static validateMnemonic(mnemonic, wordCount = 24, words = wordlist) {
+        Guards.string(Bip39._CLASS_NAME, "mnemonic", mnemonic);
+        Guards.integer(Bip39._CLASS_NAME, "wordCount", wordCount);
+        const mnemonicSplit = mnemonic.split(/\s+/);
+        if (mnemonicSplit.length !== wordCount) {
+            return false;
+        }
+        return bip39.validateMnemonic(mnemonic, words);
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-bitwise */
 /**
  * Perform HOTP.
  * Implementation of https://datatracker.ietf.org/doc/html/rfc4226 .
@@ -1723,4 +1826,4 @@ class PasswordValidator {
     }
 }
 
-export { Bech32, Bip32Path, Bip39, Bip44, Blake2b, Blake3, ChaCha20Poly1305, Ed25519, HmacSha1, HmacSha256, HmacSha512, Hotp, KeyType, PasswordGenerator, PasswordValidator, Pbkdf2, 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/address/bip44.d.ts

@@ -34,6 +34,21 @@ export declare class Bip44 {
      * @returns The bip44 address base path.
      */
     static basePath(coinType: number): string;
+    /**
+     * Generate an address from the seed and parts.
+     * @param seed The account seed.
+     * @param keyType The key type.
+     * @param coinType The coin type.
+     * @param accountIndex The account index.
+     * @param isInternal Is this an internal address.
+     * @param addressIndex The address index.
+     * @returns The generated path and the associated keypair.
+     */
+    static address(seed: Uint8Array, keyType: KeyType, coinType: number, accountIndex: number, isInternal: boolean, addressIndex: number): {
+        address: string;
+        privateKey: Uint8Array;
+        publicKey: Uint8Array;
+    };
     /**
      * Generate a bech32 address from the seed and parts.
      * @param seed The account seed.

package/dist/types/curves/ed25519.d.ts

@@ -34,4 +34,16 @@ export declare class Ed25519 {
      * @throws Error if the public key is not the correct length.
      */
     static verify(publicKey: Uint8Array, block: Uint8Array, signature: Uint8Array): boolean;
+    /**
+     * Convert a private key in PKCS8 format.
+     * @param privateKey The private key to convert.
+     * @returns The private key in PKCS8 format.
+     */
+    static privateKeyToPkcs8(privateKey: Uint8Array): Promise<CryptoKey>;
+    /**
+     * Convert a crypto key to raw private key.
+     * @param cryptoKey The crypto key to convert.
+     * @returns The raw private key.
+     */
+    static pkcs8ToPrivateKey(cryptoKey: CryptoKey): Promise<Uint8Array>;
 }

package/dist/types/helpers/pemHelper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Helper class for working with PEM (Privacy-Enhanced Mail) formatted data.
+ */
+export declare class PemHelper {
+    /**
+     * Strip the PEM content of its headers, footers, and newlines.
+     * @param pemContent The PEM content to strip.
+     * @returns The stripped PEM content in bas64 format.
+     */
+    static stripPemMarkers(pemContent: string): string;
+    /**
+     * Format the PEM content to have a specific line length.
+     * @param marker The marker for the PEM content, e.g. RSA PRIVATE KEY
+     * @param base64Content The base64 content to format.
+     * @param lineLength The length of each line in the PEM content, default is 64 characters.
+     * @returns The formatted PEM content.
+     */
+    static formatPem(marker: string, base64Content: string, lineLength?: number): string;
+}

package/dist/types/index.d.ts

@@ -15,6 +15,7 @@ export * from "./hashes/sha1";
 export * from "./hashes/sha256";
 export * from "./hashes/sha3";
 export * from "./hashes/sha512";
+export * from "./helpers/pemHelper";
 export * from "./keys/bip32Path";
 export * from "./keys/bip39";
 export * from "./keys/slip0010";

package/dist/types/keys/bip39.d.ts

@@ -33,4 +33,12 @@ export declare class Bip39 {
      * @throws Error if the number of words is not a multiple of 3.
      */
     static mnemonicToEntropy(mnemonic: string, words?: string[]): Uint8Array;
+    /**
+     * Validate the mnemonic.
+     * @param mnemonic The mnemonic to validate.
+     * @param wordCount The expected number of words in the mnemonic, defaults to 24.
+     * @param words The wordlist to use, defaults to the English wordlist.
+     * @returns True if the mnemonic is valid.
+     */
+    static validateMnemonic(mnemonic: string, wordCount?: number, words?: string[]): boolean;
 }