@bitwarden/sdk-internal 0.2.0-main.166 → 0.2.0-main.168

package/VERSION

@@ -1 +1 @@
-5449a5abba7456a405b59e4f68845ee875d2d13a
+0b95464f8dc591cd00f1d8b25d4ad293b4d6580a

package/bitwarden_wasm_internal.d.ts

@@ -1256,15 +1256,52 @@ export class PureCrypto {
     email: string,
     kdf: Kdf,
   ): string;
-  static generate_user_key_aes256_cbc_hmac(): Uint8Array;
-  static generate_user_key_xchacha20_poly1305(): Uint8Array;
+  static make_user_key_aes256_cbc_hmac(): Uint8Array;
+  static make_user_key_xchacha20_poly1305(): Uint8Array;
+  /**
+   * Wraps (encrypts) a symmetric key using a symmetric wrapping key, returning the wrapped key
+   * as an EncString.
+   */
   static wrap_symmetric_key(key_to_be_wrapped: Uint8Array, wrapping_key: Uint8Array): string;
+  /**
+   * Unwraps (decrypts) a wrapped symmetric key using a symmetric wrapping key, returning the
+   * unwrapped key as a serialized byte array.
+   */
   static unwrap_symmetric_key(wrapped_key: string, wrapping_key: Uint8Array): Uint8Array;
+  /**
+   * Wraps (encrypts) an SPKI DER encoded encapsulation (public) key using a symmetric wrapping
+   * key. Note: Usually, a public key is - by definition - public, so this should not be
+   * used. The specific use-case for this function is to enable rotateable key sets, where
+   * the "public key" is not public, with the intent of preventing the server from being able
+   * to overwrite the user key unlocked by the rotateable keyset.
+   */
   static wrap_encapsulation_key(encapsulation_key: Uint8Array, wrapping_key: Uint8Array): string;
+  /**
+   * Unwraps (decrypts) a wrapped SPKI DER encoded encapsulation (public) key using a symmetric
+   * wrapping key.
+   */
   static unwrap_encapsulation_key(wrapped_key: string, wrapping_key: Uint8Array): Uint8Array;
+  /**
+   * Wraps (encrypts) a PKCS8 DER encoded decapsulation (private) key using a symmetric wrapping
+   * key,
+   */
   static wrap_decapsulation_key(decapsulation_key: Uint8Array, wrapping_key: Uint8Array): string;
+  /**
+   * Unwraps (decrypts) a wrapped PKCS8 DER encoded decapsulation (private) key using a symmetric
+   * wrapping key.
+   */
   static unwrap_decapsulation_key(wrapped_key: string, wrapping_key: Uint8Array): Uint8Array;
+  /**
+   * Encapsulates (encrypts) a symmetric key using an asymmetric encapsulation key (public key)
+   * in SPKI format, returning the encapsulated key as a string. Note: This is unsigned, so
+   * the sender's authenticity cannot be verified by the recipient.
+   */
   static encapsulate_key_unsigned(shared_key: Uint8Array, encapsulation_key: Uint8Array): string;
+  /**
+   * Decapsulates (decrypts) a symmetric key using an decapsulation key (private key) in PKCS8
+   * DER format. Note: This is unsigned, so the sender's authenticity cannot be verified by the
+   * recipient.
+   */
   static decapsulate_key_unsigned(
     encapsulated_key: string,
     decapsulation_key: Uint8Array,

package/bitwarden_wasm_internal_bg.js

@@ -2384,10 +2384,10 @@ export class PureCrypto {
   /**
    * @returns {Uint8Array}
    */
-  static generate_user_key_aes256_cbc_hmac() {
+  static make_user_key_aes256_cbc_hmac() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.purecrypto_generate_user_key_aes256_cbc_hmac(retptr);
+      wasm.purecrypto_make_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();
@@ -2400,10 +2400,10 @@ export class PureCrypto {
   /**
    * @returns {Uint8Array}
    */
-  static generate_user_key_xchacha20_poly1305() {
+  static make_user_key_xchacha20_poly1305() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.purecrypto_generate_user_key_xchacha20_poly1305(retptr);
+      wasm.purecrypto_make_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();
@@ -2414,6 +2414,8 @@ export class PureCrypto {
     }
   }
   /**
+   * Wraps (encrypts) a symmetric key using a symmetric wrapping key, returning the wrapped key
+   * as an EncString.
    * @param {Uint8Array} key_to_be_wrapped
    * @param {Uint8Array} wrapping_key
    * @returns {string}
@@ -2448,6 +2450,8 @@ export class PureCrypto {
     }
   }
   /**
+   * Unwraps (decrypts) a wrapped symmetric key using a symmetric wrapping key, returning the
+   * unwrapped key as a serialized byte array.
    * @param {string} wrapped_key
    * @param {Uint8Array} wrapping_key
    * @returns {Uint8Array}
@@ -2475,6 +2479,11 @@ export class PureCrypto {
     }
   }
   /**
+   * Wraps (encrypts) an SPKI DER encoded encapsulation (public) key using a symmetric wrapping
+   * key. Note: Usually, a public key is - by definition - public, so this should not be
+   * used. The specific use-case for this function is to enable rotateable key sets, where
+   * the "public key" is not public, with the intent of preventing the server from being able
+   * to overwrite the user key unlocked by the rotateable keyset.
    * @param {Uint8Array} encapsulation_key
    * @param {Uint8Array} wrapping_key
    * @returns {string}
@@ -2509,6 +2518,8 @@ export class PureCrypto {
     }
   }
   /**
+   * Unwraps (decrypts) a wrapped SPKI DER encoded encapsulation (public) key using a symmetric
+   * wrapping key.
    * @param {string} wrapped_key
    * @param {Uint8Array} wrapping_key
    * @returns {Uint8Array}
@@ -2536,6 +2547,8 @@ export class PureCrypto {
     }
   }
   /**
+   * Wraps (encrypts) a PKCS8 DER encoded decapsulation (private) key using a symmetric wrapping
+   * key,
    * @param {Uint8Array} decapsulation_key
    * @param {Uint8Array} wrapping_key
    * @returns {string}
@@ -2570,6 +2583,8 @@ export class PureCrypto {
     }
   }
   /**
+   * Unwraps (decrypts) a wrapped PKCS8 DER encoded decapsulation (private) key using a symmetric
+   * wrapping key.
    * @param {string} wrapped_key
    * @param {Uint8Array} wrapping_key
    * @returns {Uint8Array}
@@ -2597,6 +2612,9 @@ export class PureCrypto {
     }
   }
   /**
+   * Encapsulates (encrypts) a symmetric key using an asymmetric encapsulation key (public key)
+   * in SPKI format, returning the encapsulated key as a string. Note: This is unsigned, so
+   * the sender's authenticity cannot be verified by the recipient.
    * @param {Uint8Array} shared_key
    * @param {Uint8Array} encapsulation_key
    * @returns {string}
@@ -2631,6 +2649,9 @@ export class PureCrypto {
     }
   }
   /**
+   * Decapsulates (decrypts) a symmetric key using an decapsulation key (private key) in PKCS8
+   * DER format. Note: This is unsigned, so the sender's authenticity cannot be verified by the
+   * recipient.
    * @param {string} encapsulated_key
    * @param {Uint8Array} decapsulation_key
    * @returns {Uint8Array}

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -192,8 +192,8 @@ export const purecrypto_encrypt_user_key_with_master_password: (
   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 purecrypto_make_user_key_aes256_cbc_hmac: (a: number) => void;
+export const purecrypto_make_user_key_xchacha20_poly1305: (a: number) => void;
 export const purecrypto_wrap_symmetric_key: (
   a: number,
   b: number,