@bitwarden/sdk-internal 0.2.0-main.109 → 0.2.0-main.110

package/VERSION

@@ -1 +1 @@
-782cbdfd51b58a1de0de54bfc5ce8947ec097454
+131cbfae6dbd68f3ee53e94181fcbb4646e372ae

package/bitwarden_wasm_internal.d.ts

@@ -415,6 +415,21 @@ export class CryptoClient {
    */
   verify_asymmetric_keys(request: VerifyAsymmetricKeysRequest): VerifyAsymmetricKeysResponse;
 }
+/**
+ * This module represents a stopgap solution to provide access to primitive crypto functions for JS
+ * clients. It is not intended to be used outside of the JS clients and this pattern should not be
+ * proliferated. It is necessary because we want to use SDK crypto prior to the SDK being fully
+ * responsible for state and keys.
+ */
+export class PureCrypto {
+  private constructor();
+  free(): void;
+  static symmetric_decrypt(enc_string: string, key_b64: string): string;
+  static symmetric_decrypt_to_bytes(enc_string: string, key_b64: string): Uint8Array;
+  static symmetric_decrypt_array_buffer(enc_bytes: Uint8Array, key_b64: string): Uint8Array;
+  static symmetric_encrypt(plain: string, key_b64: string): string;
+  static symmetric_encrypt_to_array_buffer(plain: Uint8Array, key_b64: string): Uint8Array;
+}
 export class VaultClient {
   private constructor();
   free(): void;

package/bitwarden_wasm_internal_bg.js

@@ -323,6 +323,17 @@ export function init_sdk(log_level) {
   wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
 /**
  * Generate a new SSH key pair
  *
@@ -388,7 +399,7 @@ function __wbg_adapter_42(arg0, arg1, arg2) {
   wasm.closure544_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_147(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_152(arg0, arg1, arg2, arg3) {
   wasm.closure402_externref_shim(arg0, arg1, arg2, arg3);
 }
 
@@ -684,6 +695,140 @@ export class CryptoClient {
   }
 }
 
+const PureCryptoFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_purecrypto_free(ptr >>> 0, 1));
+/**
+ * This module represents a stopgap solution to provide access to primitive crypto functions for JS
+ * clients. It is not intended to be used outside of the JS clients and this pattern should not be
+ * proliferated. It is necessary because we want to use SDK crypto prior to the SDK being fully
+ * responsible for state and keys.
+ */
+export class PureCrypto {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    PureCryptoFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_purecrypto_free(ptr, 0);
+  }
+  /**
+   * @param {string} enc_string
+   * @param {string} key_b64
+   * @returns {string}
+   */
+  static symmetric_decrypt(enc_string, key_b64) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      const ret = wasm.purecrypto_symmetric_decrypt(ptr0, len0, ptr1, len1);
+      var ptr3 = ret[0];
+      var len3 = ret[1];
+      if (ret[3]) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+  }
+  /**
+   * @param {string} enc_string
+   * @param {string} key_b64
+   * @returns {Uint8Array}
+   */
+  static symmetric_decrypt_to_bytes(enc_string, key_b64) {
+    const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.purecrypto_symmetric_decrypt_to_bytes(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+  /**
+   * @param {Uint8Array} enc_bytes
+   * @param {string} key_b64
+   * @returns {Uint8Array}
+   */
+  static symmetric_decrypt_array_buffer(enc_bytes, key_b64) {
+    const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.purecrypto_symmetric_decrypt_array_buffer(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+  /**
+   * @param {string} plain
+   * @param {string} key_b64
+   * @returns {string}
+   */
+  static symmetric_encrypt(plain, key_b64) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+      const ptr0 = passStringToWasm0(plain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      const ret = wasm.purecrypto_symmetric_encrypt(ptr0, len0, ptr1, len1);
+      var ptr3 = ret[0];
+      var len3 = ret[1];
+      if (ret[3]) {
+        ptr3 = 0;
+        len3 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
+    } finally {
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+  }
+  /**
+   * @param {Uint8Array} plain
+   * @param {string} key_b64
+   * @returns {Uint8Array}
+   */
+  static symmetric_encrypt_to_array_buffer(plain, key_b64) {
+    const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(key_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.purecrypto_symmetric_encrypt_to_array_buffer(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+}
+
 const VaultClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -950,7 +1095,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_147(a, state0.b, arg0, arg1);
+        return __wbg_adapter_152(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -1267,7 +1412,7 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2129(arg0, arg1, arg2) {
+export function __wbindgen_closure_wrapper2142(arg0, arg1, arg2) {
   const ret = makeMutClosure(arg0, arg1, 545, __wbg_adapter_42);
   return ret;
 }

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -28,6 +28,37 @@ export const cryptoclient_make_key_pair: (
 export const cryptoclient_verify_asymmetric_keys: (a: number, b: any) => [number, number, number];
 export const set_log_level: (a: number) => void;
 export const init_sdk: (a: number) => void;
+export const __wbg_purecrypto_free: (a: number, b: number) => void;
+export const purecrypto_symmetric_decrypt: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [number, number, number, number];
+export const purecrypto_symmetric_decrypt_to_bytes: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [number, number, number, number];
+export const purecrypto_symmetric_decrypt_array_buffer: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [number, number, number, number];
+export const purecrypto_symmetric_encrypt: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [number, number, number, number];
+export const purecrypto_symmetric_encrypt_to_array_buffer: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+) => [number, number, number, number];
 export const generate_ssh_key: (a: any) => [number, number, number];
 export const import_ssh_key: (
   a: number,