@bitwarden/sdk-internal 0.2.0-main.201 → 0.2.0-main.203

package/VERSION

@@ -1 +1 @@
-0e948af85dd51dec72fad210a896b64fe4604a52
+138223508066b9e2e319cc08c956eb819a0bf199

package/bitwarden_wasm_internal.d.ts

@@ -117,6 +117,10 @@ export interface InitUserCryptoRequest {
    * The user\'s encrypted private key
    */
   privateKey: EncString;
+  /**
+   * The user\'s signing key
+   */
+  signingKey: EncString | undefined;
   /**
    * The initialization method to use
    */
@@ -253,6 +257,24 @@ export interface VerifyAsymmetricKeysResponse {
   validPrivateKey: boolean;
 }
 
+/**
+ * A new signing key pair along with the signed public key
+ */
+export interface MakeUserSigningKeysResponse {
+  /**
+   * Base64 encoded verifying key
+   */
+  verifyingKey: string;
+  /**
+   * Signing key, encrypted with the user\'s symmetric key
+   */
+  signingKey: EncString;
+  /**
+   * The user\'s public key, signed by the signing key
+   */
+  signedPublicKey: SignedPublicKey;
+}
+
 /**
  * NewType wrapper for `OrganizationId`
  */
@@ -360,6 +382,13 @@ export type UnsignedSharedKey = string;
 
 export type EncString = string;
 
+export type SignedPublicKey = string;
+
+/**
+ * The type of key / signature scheme used for signing and verifying.
+ */
+export type SignatureAlgorithm = "ed25519";
+
 /**
  * Key Derivation Function for Bitwarden Account
  *
@@ -391,7 +420,10 @@ export interface CryptoError extends Error {
     | "ZeroNumber"
     | "OperationNotSupported"
     | "WrongKeyType"
-    | "InvalidNonceLength";
+    | "WrongCoseKeyId"
+    | "InvalidNonceLength"
+    | "SignatureError"
+    | "EncodingError";
 }
 
 export function isCryptoError(error: any): error is CryptoError;
@@ -1167,6 +1199,10 @@ export class CryptoClient {
    * Crypto initialization not required.
    */
   verify_asymmetric_keys(request: VerifyAsymmetricKeysRequest): VerifyAsymmetricKeysResponse;
+  /**
+   * Makes a new signing key pair and signs the public key for the user
+   */
+  make_user_signing_keys_for_enrollment(): MakeUserSigningKeysResponse;
 }
 export class ExporterClient {
   private constructor();
@@ -1411,6 +1447,25 @@ export class PureCrypto {
     encapsulated_key: string,
     decapsulation_key: Uint8Array,
   ): Uint8Array;
+  /**
+   * Given a wrapped signing key and the symmetric key it is wrapped with, this returns
+   * the corresponding verifying key.
+   */
+  static verifying_key_for_signing_key(signing_key: string, wrapping_key: Uint8Array): Uint8Array;
+  /**
+   * Returns the algorithm used for the given verifying key.
+   */
+  static key_algorithm_for_verifying_key(verifying_key: Uint8Array): SignatureAlgorithm;
+  /**
+   * For a given signing identity (verifying key), this function verifies that the signing
+   * identity claimed ownership of the public key. This is a one-sided claim and merely shows
+   * that the signing identity has the intent to receive messages encrypted to the public
+   * key.
+   */
+  static verify_and_unwrap_signed_public_key(
+    signed_public_key: Uint8Array,
+    verifying_key: Uint8Array,
+  ): Uint8Array;
 }
 export class TotpClient {
   private constructor();

package/bitwarden_wasm_internal_bg.js

@@ -711,7 +711,7 @@ function __wbg_adapter_56(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_256(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_260(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h334034c47a371f71(
     arg0,
     arg1,
@@ -1323,6 +1323,25 @@ export class CryptoClient {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * Makes a new signing key pair and signs the public key for the user
+   * @returns {MakeUserSigningKeysResponse}
+   */
+  make_user_signing_keys_for_enrollment() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.cryptoclient_make_user_signing_keys_for_enrollment(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
 }
 
 const ExporterClientFinalization =
@@ -2831,6 +2850,88 @@ export class PureCrypto {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * Given a wrapped signing key and the symmetric key it is wrapped with, this returns
+   * the corresponding verifying key.
+   * @param {string} signing_key
+   * @param {Uint8Array} wrapping_key
+   * @returns {Uint8Array}
+   */
+  static verifying_key_for_signing_key(signing_key, wrapping_key) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_verifying_key_for_signing_key(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);
+    }
+  }
+  /**
+   * Returns the algorithm used for the given verifying key.
+   * @param {Uint8Array} verifying_key
+   * @returns {SignatureAlgorithm}
+   */
+  static key_algorithm_for_verifying_key(verifying_key) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.purecrypto_key_algorithm_for_verifying_key(retptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * For a given signing identity (verifying key), this function verifies that the signing
+   * identity claimed ownership of the public key. This is a one-sided claim and merely shows
+   * that the signing identity has the intent to receive messages encrypted to the public
+   * key.
+   * @param {Uint8Array} signed_public_key
+   * @param {Uint8Array} verifying_key
+   * @returns {Uint8Array}
+   */
+  static verify_and_unwrap_signed_public_key(signed_public_key, verifying_key) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(signed_public_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_verify_and_unwrap_signed_public_key(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);
+    }
+  }
 }
 
 const TotpClientFinalization =
@@ -3230,7 +3331,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_256(a, state0.b, arg0, arg1);
+        return __wbg_adapter_260(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -3587,18 +3688,18 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2339(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper2476(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 717, __wbg_adapter_50);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_closure_wrapper3178(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 753, __wbg_adapter_53);
+export function __wbindgen_closure_wrapper3315(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 801, __wbg_adapter_53);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_closure_wrapper3588(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 875, __wbg_adapter_56);
+export function __wbindgen_closure_wrapper3728(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 924, __wbg_adapter_56);
   return addHeapObject(ret);
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -6,6 +6,7 @@ export const cryptoclient_initialize_user_crypto: (a: number, b: number) => numb
 export const cryptoclient_initialize_org_crypto: (a: number, b: number) => number;
 export const cryptoclient_make_key_pair: (a: number, b: number, c: number, d: number) => void;
 export const cryptoclient_verify_asymmetric_keys: (a: number, b: number, c: number) => void;
+export const cryptoclient_make_user_signing_keys_for_enrollment: (a: number, b: number) => void;
 export const isDeriveKeyConnectorError: (a: number) => number;
 export const isEnrollAdminPasswordResetError: (a: number) => number;
 export const isCryptoClientError: (a: number) => number;
@@ -273,6 +274,21 @@ export const purecrypto_decapsulate_key_unsigned: (
   d: number,
   e: number,
 ) => void;
+export const purecrypto_verifying_key_for_signing_key: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+) => void;
+export const purecrypto_key_algorithm_for_verifying_key: (a: number, b: number, c: number) => void;
+export const purecrypto_verify_and_unwrap_signed_public_key: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: 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 isTestError: (a: number) => number;