@bitwarden/sdk-internal 0.2.0-main.161 → 0.2.0-main.163

package/VERSION

@@ -1 +1 @@
-b185bc6e7ec090c68ecd8c130c2772f567890192
+90c331a251bedfcade5ed03f45656f3506453ab4

package/bitwarden_wasm_internal.d.ts

@@ -304,7 +304,8 @@ export interface CryptoError extends Error {
     | "ArgonError"
     | "ZeroNumber"
     | "OperationNotSupported"
-    | "WrongKeyType";
+    | "WrongKeyType"
+    | "InvalidNonceLength";
 }
 
 export function isCryptoError(error: any): error is CryptoError;
@@ -1227,11 +1228,36 @@ export class OutgoingMessage {
 export class PureCrypto {
   private constructor();
   free(): void;
+  /**
+   * DEPRECATED: Use `symmetric_decrypt_string` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
+   */
   static symmetric_decrypt(enc_string: string, key: Uint8Array): string;
-  static symmetric_decrypt_to_bytes(enc_string: string, key: Uint8Array): Uint8Array;
+  static symmetric_decrypt_string(enc_string: string, key: Uint8Array): string;
+  static symmetric_decrypt_bytes(enc_string: string, key: Uint8Array): Uint8Array;
+  /**
+   * DEPRECATED: Use `symmetric_decrypt_filedata` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
+   */
   static symmetric_decrypt_array_buffer(enc_bytes: Uint8Array, key: Uint8Array): Uint8Array;
-  static symmetric_encrypt(plain: string, key: Uint8Array): string;
-  static symmetric_encrypt_to_array_buffer(plain: Uint8Array, key: Uint8Array): Uint8Array;
+  static symmetric_decrypt_filedata(enc_bytes: Uint8Array, key: Uint8Array): Uint8Array;
+  static symmetric_encrypt_string(plain: string, key: Uint8Array): string;
+  static symmetric_encrypt_bytes(plain: Uint8Array, key: Uint8Array): string;
+  static symmetric_encrypt_filedata(plain: Uint8Array, key: Uint8Array): Uint8Array;
+  static decrypt_user_key_with_master_password(
+    encrypted_user_key: string,
+    master_password: string,
+    email: string,
+    kdf: Kdf,
+  ): Uint8Array;
+  static encrypt_user_key_with_master_password(
+    user_key: Uint8Array,
+    master_password: string,
+    email: string,
+    kdf: Kdf,
+  ): string;
+  static generate_user_key_aes256_cbc_hmac(): Uint8Array;
+  static generate_user_key_xchacha20_poly1305(): Uint8Array;
 }
 export class ReceiveError {
   private constructor();

package/bitwarden_wasm_internal_bg.js

@@ -613,7 +613,7 @@ function __wbg_adapter_53(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_238(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_245(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h2a33b0877ef96682(
     arg0,
     arg1,
@@ -2035,6 +2035,8 @@ export class PureCrypto {
     wasm.__wbg_purecrypto_free(ptr, 0);
   }
   /**
+   * DEPRECATED: Use `symmetric_decrypt_string` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
    * @param {string} enc_string
    * @param {Uint8Array} key
    * @returns {string}
@@ -2068,19 +2070,53 @@ export class PureCrypto {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
+  /**
+   * @param {string} enc_string
+   * @param {Uint8Array} key
+   * @returns {string}
+   */
+  static symmetric_decrypt_string(enc_string, key) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_symmetric_decrypt_string(retptr, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr3 = r0;
+      var len3 = r1;
+      if (r3) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeObject(r2);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+  }
   /**
    * @param {string} enc_string
    * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static symmetric_decrypt_to_bytes(enc_string, key) {
+  static symmetric_decrypt_bytes(enc_string, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
       const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt_to_bytes(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_decrypt_bytes(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2096,6 +2132,8 @@ export class PureCrypto {
     }
   }
   /**
+   * DEPRECATED: Use `symmetric_decrypt_filedata` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
    * @param {Uint8Array} enc_bytes
    * @param {Uint8Array} key
    * @returns {Uint8Array}
@@ -2122,12 +2160,39 @@ export class PureCrypto {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * @param {Uint8Array} enc_bytes
+   * @param {Uint8Array} key
+   * @returns {Uint8Array}
+   */
+  static symmetric_decrypt_filedata(enc_bytes, key) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_symmetric_decrypt_filedata(retptr, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v3;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
   /**
    * @param {string} plain
    * @param {Uint8Array} key
    * @returns {string}
    */
-  static symmetric_encrypt(plain, key) {
+  static symmetric_encrypt_string(plain, key) {
     let deferred4_0;
     let deferred4_1;
     try {
@@ -2136,7 +2201,41 @@ export class PureCrypto {
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_encrypt(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_encrypt_string(retptr, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr3 = r0;
+      var len3 = r1;
+      if (r3) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeObject(r2);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+  }
+  /**
+   * @param {Uint8Array} plain
+   * @param {Uint8Array} key
+   * @returns {string}
+   */
+  static symmetric_encrypt_bytes(plain, key) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_symmetric_encrypt_bytes(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2161,14 +2260,14 @@ export class PureCrypto {
    * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static symmetric_encrypt_to_array_buffer(plain, key) {
+  static symmetric_encrypt_filedata(plain, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
       const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_encrypt_to_array_buffer(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_encrypt_filedata(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2183,6 +2282,137 @@ export class PureCrypto {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * @param {string} encrypted_user_key
+   * @param {string} master_password
+   * @param {string} email
+   * @param {Kdf} kdf
+   * @returns {Uint8Array}
+   */
+  static decrypt_user_key_with_master_password(encrypted_user_key, master_password, email, kdf) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(
+        encrypted_user_key,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(
+        master_password,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len1 = WASM_VECTOR_LEN;
+      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len2 = WASM_VECTOR_LEN;
+      wasm.purecrypto_decrypt_user_key_with_master_password(
+        retptr,
+        ptr0,
+        len0,
+        ptr1,
+        len1,
+        ptr2,
+        len2,
+        addHeapObject(kdf),
+      );
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v4 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v4;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {Uint8Array} user_key
+   * @param {string} master_password
+   * @param {string} email
+   * @param {Kdf} kdf
+   * @returns {string}
+   */
+  static encrypt_user_key_with_master_password(user_key, master_password, email, kdf) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(user_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(
+        master_password,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
+      const len1 = WASM_VECTOR_LEN;
+      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len2 = WASM_VECTOR_LEN;
+      wasm.purecrypto_encrypt_user_key_with_master_password(
+        retptr,
+        ptr0,
+        len0,
+        ptr1,
+        len1,
+        ptr2,
+        len2,
+        addHeapObject(kdf),
+      );
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr4 = r0;
+      var len4 = r1;
+      if (r3) {
+        ptr4 = 0;
+        len4 = 0;
+        throw takeObject(r2);
+      }
+      deferred5_0 = ptr4;
+      deferred5_1 = len4;
+      return getStringFromWasm0(ptr4, len4);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  static generate_user_key_aes256_cbc_hmac() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.purecrypto_generate_user_key_aes256_cbc_hmac(retptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  static generate_user_key_xchacha20_poly1305() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.purecrypto_generate_user_key_xchacha20_poly1305(retptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
 }
 
 const ReceiveErrorFinalization =
@@ -2697,7 +2927,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_238(a, state0.b, arg0, arg1);
+        return __wbg_adapter_245(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -3064,13 +3294,13 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2889(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper3031(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 688, __wbg_adapter_50);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_closure_wrapper3282(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 791, __wbg_adapter_53);
+export function __wbindgen_closure_wrapper3424(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 810, __wbg_adapter_53);
   return addHeapObject(ret);
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -123,7 +123,14 @@ export const purecrypto_symmetric_decrypt: (
   d: number,
   e: number,
 ) => void;
-export const purecrypto_symmetric_decrypt_to_bytes: (
+export const purecrypto_symmetric_decrypt_string: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+) => void;
+export const purecrypto_symmetric_decrypt_bytes: (
   a: number,
   b: number,
   c: number,
@@ -137,20 +144,56 @@ export const purecrypto_symmetric_decrypt_array_buffer: (
   d: number,
   e: number,
 ) => void;
-export const purecrypto_symmetric_encrypt: (
+export const purecrypto_symmetric_decrypt_filedata: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+) => void;
+export const purecrypto_symmetric_encrypt_string: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+) => void;
+export const purecrypto_symmetric_encrypt_bytes: (
   a: number,
   b: number,
   c: number,
   d: number,
   e: number,
 ) => void;
-export const purecrypto_symmetric_encrypt_to_array_buffer: (
+export const purecrypto_symmetric_encrypt_filedata: (
   a: number,
   b: number,
   c: number,
   d: number,
   e: number,
 ) => void;
+export const purecrypto_decrypt_user_key_with_master_password: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number,
+  g: number,
+  h: number,
+) => void;
+export const purecrypto_encrypt_user_key_with_master_password: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number,
+  g: number,
+  h: number,
+) => void;
+export const purecrypto_generate_user_key_aes256_cbc_hmac: (a: number) => void;
+export const purecrypto_generate_user_key_xchacha20_poly1305: (a: number) => void;
 export const generate_ssh_key: (a: number, b: number) => void;
 export const import_ssh_key: (a: number, b: number, c: number, d: number, e: number) => void;
 export const __wbg_attachmentsclient_free: (a: number, b: number) => void;
@@ -185,10 +228,10 @@ export const bitwardenclient_exporters: (a: number) => number;
 export const vaultclient_ciphers: (a: number) => number;
 export const vaultclient_folders: (a: number) => number;
 export const __wbg_vaultclient_free: (a: number, b: number) => void;
-export const __wbg_totpclient_free: (a: number, b: number) => void;
 export const __wbg_foldersclient_free: (a: number, b: number) => void;
 export const __wbg_cryptoclient_free: (a: number, b: number) => void;
 export const __wbg_ciphersclient_free: (a: number, b: number) => void;
+export const __wbg_totpclient_free: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;