@bitwarden/sdk-internal 0.2.0-main.160 → 0.2.0-main.162

package/node/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;
@@ -344,6 +345,21 @@ export type UsernameGeneratorRequest =
   | { catchall: { type: AppendType; domain: string } }
   | { forwarded: { service: ForwarderServiceType; website: string | undefined } };
 
+/**
+ * Configures the email forwarding service to use.
+ * For instructions on how to configure each service, see the documentation:
+ * <https://bitwarden.com/help/generator/#username-types>
+ */
+export type ForwarderServiceType =
+  | { addyIo: { api_token: string; domain: string; base_url: string } }
+  | { duckDuckGo: { token: string } }
+  | { firefox: { api_token: string } }
+  | { fastmail: { api_token: string } }
+  | { forwardEmail: { api_token: string; domain: string } }
+  | { simpleLogin: { api_key: string; base_url: string } };
+
+export type AppendType = "random" | { websiteName: { website: string } };
+
 export interface UsernameError extends Error {
   name: "UsernameError";
   variant: "InvalidApiKey" | "Unknown" | "ResponseContent" | "Reqwest";
@@ -1212,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/node/bitwarden_wasm_internal.js

@@ -607,7 +607,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,
@@ -2041,6 +2041,8 @@ 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}
@@ -2074,19 +2076,53 @@ 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);
@@ -2102,6 +2138,8 @@ 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}
@@ -2128,12 +2166,39 @@ 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 {
@@ -2142,7 +2207,41 @@ 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);
@@ -2167,14 +2266,14 @@ 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);
@@ -2189,6 +2288,137 @@ 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);
+    }
+  }
 }
 module.exports.PureCrypto = PureCrypto;
 
@@ -2708,7 +2938,7 @@ module.exports.__wbg_new_23a2665fac83c611 = function (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;
       }
@@ -3075,13 +3305,13 @@ module.exports.__wbindgen_cb_drop = function (arg0) {
   return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper2889 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_50);
+module.exports.__wbindgen_closure_wrapper3031 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 688, __wbg_adapter_50);
   return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper3282 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 791, __wbg_adapter_53);
+module.exports.__wbindgen_closure_wrapper3424 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 810, __wbg_adapter_53);
   return addHeapObject(ret);
 };
 

package/node/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitwarden/sdk-internal",
-  "version": "0.2.0-main.160",
+  "version": "0.2.0-main.162",
   "license": "GPL-3.0",
   "files": [
     "bitwarden_wasm_internal_bg.js",