@otoplo/wallet-common 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otoplo/wallet-common",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Shared common library for internal use in Otoplo wallet",
   "license": "MIT",
   "author": "vgrunner",
@@ -31,8 +31,6 @@
     "url": "git+https://gitlab.com/nexa/otoplo/otoplo-wallet-common.git"
   },
   "dependencies": {
-    "@noble/ciphers": "^2.1.1",
-    "@noble/hashes": "^2.0.1",
     "@scure/bip39": "^2.0.1",
     "jszip": "^3.10.1"
   },

package/src/utils/seed.ts

@@ -1,8 +1,3 @@
-import { gcm } from "@noble/ciphers/aes.js";
-import { argon2idAsync } from "@noble/hashes/argon2.js";
-import { pbkdf2Async } from "@noble/hashes/pbkdf2.js";
-import { scryptAsync } from "@noble/hashes/scrypt.js";
-import { sha256 } from "@noble/hashes/sha2.js";
 import { generateMnemonic, validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
 import { BufferUtils } from "libnexa-ts";
@@ -15,49 +10,76 @@ export function isMnemonicValid(mnemonic: string): boolean {
   return validateMnemonic(mnemonic, wordlist);
 }
 
-async function deriveKey(password: string, salt: Uint8Array): Promise<Uint8Array> {
-  let start = performance.now();
-  const key = await argon2idAsync(password, salt, { t: 2, m: 19456, p: 1, dkLen: 32 });
-  console.log(performance.now() - start);
+async function deriveKey(secret: Uint8Array, salt: Uint8Array): Promise<CryptoKey> {
+  const perf = performance.now();
+  const baseKey = await crypto.subtle.importKey(
+    'raw',
+    new Uint8Array(secret),
+    'PBKDF2',
+    false,
+    ['deriveKey']
+  );
 
-  let start2 = performance.now();
-  const key2 = await pbkdf2Async(sha256, password, salt, { c: 210_000, dkLen: 32 });
-  console.log(performance.now() - start2);
-
-  let start3 = performance.now();
-  const key3 = await pbkdf2Async(sha256, password, salt, { c: 100_000, dkLen: 32 });
-  console.log(performance.now() - start3);
-
-  let start4 = performance.now();
-  const key4 = await argon2idAsync(password, salt, { t: 4, m: 9216, p: 1, dkLen: 32 });
-  console.log(performance.now() - start4);
+  const key = await crypto.subtle.deriveKey(
+    {
+      name: 'PBKDF2',
+      salt: new Uint8Array(salt),
+      iterations: 210_000,
+      hash: 'SHA-256',
+    },
+    baseKey,
+    {
+      name: 'AES-GCM',
+      length: 256,
+    },
+    false,
+    ['encrypt', 'decrypt']
+  );
 
+  console.log(performance.now() - perf);
   return key;
 }
 
 export async function encryptMnemonic(phrase: string, password: string): Promise<string> {
+  const secret = BufferUtils.utf8ToBuffer(password);
   const salt = BufferUtils.getRandomBuffer(16);
   const iv = BufferUtils.getRandomBuffer(12);
   const data = BufferUtils.utf8ToBuffer(phrase);
 
-  const key = await deriveKey(password, salt);
+  const key = await deriveKey(secret, salt);
+
+  const cipher = await crypto.subtle.encrypt(
+    {
+      name: 'AES-GCM',
+      iv: new Uint8Array(iv),
+    },
+    key,
+    new Uint8Array(data)
+  );
 
-  const cipher = gcm(key, iv).encrypt(data);
-  const encBuf = BufferUtils.concat([salt, iv, cipher]);
+  const encBuf = BufferUtils.concat([salt, iv, new Uint8Array(cipher)]);
   return BufferUtils.bufferToBase64(encBuf);
 }
 
 async function decryptMnemonic(encSeed: string, password: string): Promise<string> {
+  const secret = BufferUtils.utf8ToBuffer(password);
   const encBuf = BufferUtils.base64ToBuffer(encSeed);
 
-  const salt = encBuf.subarray(0, 16);
-  const iv = encBuf.subarray(16, 28);
-  const cipher = encBuf.subarray(28);
+  const salt = encBuf.slice(0, 16);
+  const iv = encBuf.slice(16, 28);
+  const cipher = encBuf.slice(28);
 
-  const key = await deriveKey(password, salt);
+  const key = await deriveKey(secret, salt);
 
-  const data = gcm(key, iv).decrypt(cipher);
-  return BufferUtils.bufferToUtf8(data);
+  const data = await crypto.subtle.decrypt(
+    {
+      name: 'AES-GCM',
+      iv,
+    },
+    key,
+    cipher
+  );
+  return BufferUtils.bufferToUtf8(new Uint8Array(data));
 }
 
 export async function validateAndDecryptMnemonic(encSeed: string, password: string): Promise<string | false> {