@ursalock/client 0.4.0 → 0.4.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import { ZKCredentials } from '@z-base/zero-knowledge-credentials';
 import { useCallback, useSyncExternalStore } from 'react';
+import { encrypt, computeHmac, verifyHmac, decrypt } from '@ursalock/crypto';
 
 // src/passkey.ts
 
@@ -801,135 +802,6 @@ function useCredential(client) {
 function usePasskeySupport(client) {
   return client.supportsPasskey();
 }
-
-// ../crypto/dist/index.js
-function randomBytes(length) {
-  const bytes = new Uint8Array(length);
-  crypto.getRandomValues(bytes);
-  return bytes;
-}
-function concatBytes(...arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-var IV_LENGTH = 12;
-var WebCryptoProvider = class {
-  async encrypt(plaintext, key) {
-    if (key.length !== 32) {
-      throw new Error(`Invalid key length: expected 32 bytes, got ${key.length}`);
-    }
-    const actualIv = randomBytes(IV_LENGTH);
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength),
-      { name: "AES-GCM" },
-      false,
-      ["encrypt"]
-    );
-    const ciphertext = new Uint8Array(
-      await crypto.subtle.encrypt(
-        { name: "AES-GCM", iv: actualIv },
-        cryptoKey,
-        plaintext.buffer.slice(plaintext.byteOffset, plaintext.byteOffset + plaintext.byteLength)
-      )
-    );
-    const combined = concatBytes(actualIv, ciphertext);
-    return { iv: actualIv, ciphertext, combined };
-  }
-  async decrypt(encrypted, key) {
-    if (key.length !== 32) {
-      throw new Error(`Invalid key length: expected 32 bytes, got ${key.length}`);
-    }
-    let iv;
-    let ciphertext;
-    if (encrypted instanceof Uint8Array) {
-      if (encrypted.length < IV_LENGTH + 16) {
-        throw new Error("Invalid encrypted data: too short");
-      }
-      iv = encrypted.slice(0, IV_LENGTH);
-      ciphertext = encrypted.slice(IV_LENGTH);
-    } else {
-      iv = encrypted.iv;
-      ciphertext = encrypted.ciphertext;
-    }
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength),
-      { name: "AES-GCM" },
-      false,
-      ["decrypt"]
-    );
-    try {
-      const plaintext = await crypto.subtle.decrypt(
-        { name: "AES-GCM", iv },
-        cryptoKey,
-        ciphertext.buffer.slice(ciphertext.byteOffset, ciphertext.byteOffset + ciphertext.byteLength)
-      );
-      return new Uint8Array(plaintext);
-    } catch (error) {
-      throw new Error("Decryption failed: invalid key or corrupted data");
-    }
-  }
-};
-var defaultProvider = new WebCryptoProvider();
-async function encrypt(plaintext, key, provider = defaultProvider) {
-  return provider.encrypt(plaintext, key);
-}
-async function decrypt(encrypted, key, provider = defaultProvider) {
-  return provider.decrypt(encrypted, key);
-}
-async function computeHmac(data, key) {
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    key,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const signature = new Uint8Array(
-    await crypto.subtle.sign("HMAC", cryptoKey, data)
-  );
-  return bytesToHex(signature);
-}
-async function verifyHmac(data, key, expectedHmac) {
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    key,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["verify"]
-  );
-  const expectedBytes = hexToBytes(expectedHmac);
-  return crypto.subtle.verify(
-    "HMAC",
-    cryptoKey,
-    expectedBytes,
-    data
-  );
-}
-function bytesToHex(bytes) {
-  let hex = "";
-  for (let i = 0; i < bytes.length; i++) {
-    hex += bytes[i].toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-function hexToBytes(hex) {
-  const len = hex.length >>> 1;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-
-// src/collection.ts
 var Collection = class {
   constructor(serverUrl, vaultUid, collectionName, encryptionKey, hmacKey, getAuthHeader, httpClient) {
     this.serverUrl = serverUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ursalock/client",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Auth and API client for ursalock with E2EE passkey encryption",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,6 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@ursalock/crypto": "^0.4.0",
     "@z-base/zero-knowledge-credentials": "^1.0.2"
   },
   "peerDependencies": {