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

package/node/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/node/bitwarden_wasm_internal.js

@@ -2390,10 +2390,10 @@ 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();
@@ -2406,10 +2406,10 @@ 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();
@@ -2420,6 +2420,8 @@ 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}
@@ -2454,6 +2456,8 @@ 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}
@@ -2481,6 +2485,11 @@ 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}
@@ -2515,6 +2524,8 @@ 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}
@@ -2542,6 +2553,8 @@ 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}
@@ -2576,6 +2589,8 @@ 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}
@@ -2603,6 +2618,9 @@ 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}
@@ -2637,6 +2655,9 @@ 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/node/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,

package/package.json

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