@bitwarden/sdk-internal 0.2.0-main.45 → 0.2.0-main.47

package/node/bitwarden_wasm_internal.d.ts

@@ -1,6 +1,32 @@
 /* tslint:disable */
 /* eslint-disable */
-export function generate_ssh_key(key_algorithm: KeyAlgorithm): GenerateSshKeyResult;
+/**
+ * Generate a new SSH key pair
+ *
+ * # Arguments
+ * - `key_algorithm` - The algorithm to use for the key pair
+ *
+ * # Returns
+ * - `Ok(SshKey)` if the key was successfully generated
+ * - `Err(KeyGenerationError)` if the key could not be generated
+ */
+export function generate_ssh_key(key_algorithm: KeyAlgorithm): SshKey;
+/**
+ * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
+ * to an OpenSSH private key with public key and fingerprint
+ *
+ * # Arguments
+ * - `imported_key` - The private key to convert
+ * - `password` - The password to use for decrypting the key
+ *
+ * # Returns
+ * - `Ok(SshKey)` if the key was successfully coneverted
+ * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
+ * - `Err(WrongPassword)` if the password provided is incorrect
+ * - `Err(ParsingError)` if the key could not be parsed
+ * - `Err(UnsupportedKeyType)` if the key type is not supported
+ */
+export function import_ssh_key(imported_key: string, password?: string): SshKey;
 export enum LogLevel {
   Trace = 0,
   Debug = 1,
@@ -199,7 +225,10 @@ export type Kdf =
   | { pBKDF2: { iterations: NonZeroU32 } }
   | { argon2id: { iterations: NonZeroU32; memory: NonZeroU32; parallelism: NonZeroU32 } };
 
-export interface GenerateSshKeyResult {
+export interface SshKey {
+  /**
+   * The private key in OpenSSH format
+   */
   private_key: string;
   public_key: string;
   key_fingerprint: string;
@@ -207,6 +236,20 @@ export interface GenerateSshKeyResult {
 
 export type KeyAlgorithm = "Ed25519" | "Rsa3072" | "Rsa4096";
 
+export interface SshKeyExportError extends Error {
+  name: "SshKeyExportError";
+  variant: "KeyConversionError";
+}
+
+export function isSshKeyExportError(error: any): error is SshKeyExportError;
+
+export interface SshKeyImportError extends Error {
+  name: "SshKeyImportError";
+  variant: "ParsingError" | "PasswordRequired" | "WrongPassword" | "UnsupportedKeyType";
+}
+
+export function isSshKeyImportError(error: any): error is SshKeyImportError;
+
 export interface KeyGenerationError extends Error {
   name: "KeyGenerationError";
   variant: "KeyGenerationError" | "KeyConversionError";
@@ -263,10 +306,18 @@ export class BitwardenClient {
    * Test method, calls http endpoint
    */
   http_get(url: string): Promise<string>;
-  crypto(): ClientCrypto;
-  vault(): ClientVault;
+  crypto(): CryptoClient;
+  vault(): VaultClient;
 }
-export class ClientCrypto {
+export class ClientFolders {
+  private constructor();
+  free(): void;
+  /**
+   * Decrypt folder
+   */
+  decrypt(folder: Folder): FolderView;
+}
+export class CryptoClient {
   private constructor();
   free(): void;
   /**
@@ -291,15 +342,7 @@ export class ClientCrypto {
    */
   verify_asymmetric_keys(request: VerifyAsymmetricKeysRequest): VerifyAsymmetricKeysResponse;
 }
-export class ClientFolders {
-  private constructor();
-  free(): void;
-  /**
-   * Decrypt folder
-   */
-  decrypt(folder: Folder): FolderView;
-}
-export class ClientVault {
+export class VaultClient {
   private constructor();
   free(): void;
   folders(): ClientFolders;

package/node/bitwarden_wasm_internal.js

@@ -266,6 +266,32 @@ module.exports.isEncryptionSettingsError = function (error) {
   }
 };
 
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+module.exports.isSshKeyExportError = function (error) {
+  try {
+    const ret = wasm.isSshKeyExportError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+};
+
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+module.exports.isSshKeyImportError = function (error) {
+  try {
+    const ret = wasm.isSshKeyImportError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+};
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -293,8 +319,16 @@ module.exports.isTestError = function (error) {
 };
 
 /**
+ * Generate a new SSH key pair
+ *
+ * # Arguments
+ * - `key_algorithm` - The algorithm to use for the key pair
+ *
+ * # Returns
+ * - `Ok(SshKey)` if the key was successfully generated
+ * - `Err(KeyGenerationError)` if the key could not be generated
  * @param {KeyAlgorithm} key_algorithm
- * @returns {GenerateSshKeyResult}
+ * @returns {SshKey}
  */
 module.exports.generate_ssh_key = function (key_algorithm) {
   try {
@@ -312,6 +346,46 @@ module.exports.generate_ssh_key = function (key_algorithm) {
   }
 };
 
+/**
+ * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
+ * to an OpenSSH private key with public key and fingerprint
+ *
+ * # Arguments
+ * - `imported_key` - The private key to convert
+ * - `password` - The password to use for decrypting the key
+ *
+ * # Returns
+ * - `Ok(SshKey)` if the key was successfully coneverted
+ * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
+ * - `Err(WrongPassword)` if the password provided is incorrect
+ * - `Err(ParsingError)` if the key could not be parsed
+ * - `Err(UnsupportedKeyType)` if the key type is not supported
+ * @param {string} imported_key
+ * @param {string | undefined} [password]
+ * @returns {SshKey}
+ */
+module.exports.import_ssh_key = function (imported_key, password) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(password)
+      ? 0
+      : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    wasm.import_ssh_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);
+    if (r2) {
+      throw takeObject(r1);
+    }
+    return takeObject(r0);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+};
+
 function __wbg_adapter_38(arg0, arg1, arg2) {
   wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb80710307d9edf75(
     arg0,
@@ -320,7 +394,7 @@ function __wbg_adapter_38(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_127(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_130(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h1aea760ed40205bc(
     arg0,
     arg1,
@@ -451,46 +525,94 @@ class BitwardenClient {
     return takeObject(ret);
   }
   /**
-   * @returns {ClientCrypto}
+   * @returns {CryptoClient}
    */
   crypto() {
     const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
-    return ClientCrypto.__wrap(ret);
+    return CryptoClient.__wrap(ret);
   }
   /**
-   * @returns {ClientVault}
+   * @returns {VaultClient}
    */
   vault() {
     const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
-    return ClientVault.__wrap(ret);
+    return VaultClient.__wrap(ret);
   }
 }
 module.exports.BitwardenClient = BitwardenClient;
 
-const ClientCryptoFinalization =
+const ClientFoldersFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientcrypto_free(ptr >>> 0, 1));
+    : new FinalizationRegistry((ptr) => wasm.__wbg_clientfolders_free(ptr >>> 0, 1));
 
-class ClientCrypto {
+class ClientFolders {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(ClientCrypto.prototype);
+    const obj = Object.create(ClientFolders.prototype);
     obj.__wbg_ptr = ptr;
-    ClientCryptoFinalization.register(obj, obj.__wbg_ptr, obj);
+    ClientFoldersFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
 
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    ClientCryptoFinalization.unregister(this);
+    ClientFoldersFinalization.unregister(this);
     return ptr;
   }
 
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientcrypto_free(ptr, 0);
+    wasm.__wbg_clientfolders_free(ptr, 0);
+  }
+  /**
+   * Decrypt folder
+   * @param {Folder} folder
+   * @returns {FolderView}
+   */
+  decrypt(folder) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.clientfolders_decrypt(retptr, this.__wbg_ptr, addHeapObject(folder));
+      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);
+    }
+  }
+}
+module.exports.ClientFolders = ClientFolders;
+
+const CryptoClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_cryptoclient_free(ptr >>> 0, 1));
+
+class CryptoClient {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(CryptoClient.prototype);
+    obj.__wbg_ptr = ptr;
+    CryptoClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    CryptoClientFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_cryptoclient_free(ptr, 0);
   }
   /**
    * Initialization method for the user crypto. Needs to be called before any other crypto
@@ -499,7 +621,7 @@ class ClientCrypto {
    * @returns {Promise<void>}
    */
   initialize_user_crypto(req) {
-    const ret = wasm.clientcrypto_initialize_user_crypto(this.__wbg_ptr, addHeapObject(req));
+    const ret = wasm.cryptoclient_initialize_user_crypto(this.__wbg_ptr, addHeapObject(req));
     return takeObject(ret);
   }
   /**
@@ -509,7 +631,7 @@ class ClientCrypto {
    * @returns {Promise<void>}
    */
   initialize_org_crypto(req) {
-    const ret = wasm.clientcrypto_initialize_org_crypto(this.__wbg_ptr, addHeapObject(req));
+    const ret = wasm.cryptoclient_initialize_org_crypto(this.__wbg_ptr, addHeapObject(req));
     return takeObject(ret);
   }
   /**
@@ -523,7 +645,7 @@ class ClientCrypto {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
       const ptr0 = passStringToWasm0(user_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      wasm.clientcrypto_make_key_pair(retptr, this.__wbg_ptr, ptr0, len0);
+      wasm.cryptoclient_make_key_pair(retptr, this.__wbg_ptr, 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);
@@ -545,7 +667,7 @@ class ClientCrypto {
   verify_asymmetric_keys(request) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientcrypto_verify_asymmetric_keys(retptr, this.__wbg_ptr, addHeapObject(request));
+      wasm.cryptoclient_verify_asymmetric_keys(retptr, this.__wbg_ptr, addHeapObject(request));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -558,80 +680,32 @@ class ClientCrypto {
     }
   }
 }
-module.exports.ClientCrypto = ClientCrypto;
-
-const ClientFoldersFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientfolders_free(ptr >>> 0, 1));
-
-class ClientFolders {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ClientFolders.prototype);
-    obj.__wbg_ptr = ptr;
-    ClientFoldersFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    ClientFoldersFinalization.unregister(this);
-    return ptr;
-  }
-
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientfolders_free(ptr, 0);
-  }
-  /**
-   * Decrypt folder
-   * @param {Folder} folder
-   * @returns {FolderView}
-   */
-  decrypt(folder) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientfolders_decrypt(retptr, this.__wbg_ptr, addHeapObject(folder));
-      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);
-    }
-  }
-}
-module.exports.ClientFolders = ClientFolders;
+module.exports.CryptoClient = CryptoClient;
 
-const ClientVaultFinalization =
+const VaultClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientvault_free(ptr >>> 0, 1));
+    : new FinalizationRegistry((ptr) => wasm.__wbg_vaultclient_free(ptr >>> 0, 1));
 
-class ClientVault {
+class VaultClient {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(ClientVault.prototype);
+    const obj = Object.create(VaultClient.prototype);
     obj.__wbg_ptr = ptr;
-    ClientVaultFinalization.register(obj, obj.__wbg_ptr, obj);
+    VaultClientFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
 
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    ClientVaultFinalization.unregister(this);
+    VaultClientFinalization.unregister(this);
     return ptr;
   }
 
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientvault_free(ptr, 0);
+    wasm.__wbg_vaultclient_free(ptr, 0);
   }
   /**
    * @returns {ClientFolders}
@@ -641,7 +715,7 @@ class ClientVault {
     return ClientFolders.__wrap(ret);
   }
 }
-module.exports.ClientVault = ClientVault;
+module.exports.VaultClient = VaultClient;
 
 module.exports.__wbg_String_8f0eb39a4a4c2f66 = function (arg0, arg1) {
   const ret = String(getObject(arg1));
@@ -874,7 +948,7 @@ module.exports.__wbg_new_3d446df9155128ef = function (arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_127(a, state0.b, arg0, arg1);
+        return __wbg_adapter_130(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -1179,8 +1253,8 @@ module.exports.__wbindgen_cb_drop = function (arg0) {
   return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper1929 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 545, __wbg_adapter_38);
+module.exports.__wbindgen_closure_wrapper2041 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 546, __wbg_adapter_38);
   return addHeapObject(ret);
 };
 

package/node/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -3,6 +3,8 @@
 export const memory: WebAssembly.Memory;
 export const isCoreError: (a: number) => number;
 export const isEncryptionSettingsError: (a: number) => number;
+export const isSshKeyExportError: (a: number) => number;
+export const isSshKeyImportError: (a: number) => number;
 export const isKeyGenerationError: (a: number) => number;
 export const __wbg_bitwardenclient_free: (a: number, b: number) => void;
 export const bitwardenclient_new: (a: number, b: number) => number;
@@ -12,17 +14,18 @@ export const bitwardenclient_throw: (a: number, b: number, c: number, d: number)
 export const bitwardenclient_http_get: (a: number, b: number, c: number) => number;
 export const bitwardenclient_crypto: (a: number) => number;
 export const isTestError: (a: number) => number;
-export const clientcrypto_initialize_user_crypto: (a: number, b: number) => number;
-export const clientcrypto_initialize_org_crypto: (a: number, b: number) => number;
-export const clientcrypto_make_key_pair: (a: number, b: number, c: number, d: number) => void;
-export const clientcrypto_verify_asymmetric_keys: (a: number, b: number, c: number) => void;
+export const cryptoclient_initialize_user_crypto: (a: number, b: number) => number;
+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 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 clientfolders_decrypt: (a: number, b: number, c: number) => void;
-export const __wbg_clientcrypto_free: (a: number, b: number) => void;
+export const __wbg_cryptoclient_free: (a: number, b: number) => void;
 export const __wbg_clientfolders_free: (a: number, b: number) => void;
-export const __wbg_clientvault_free: (a: number, b: number) => void;
+export const __wbg_vaultclient_free: (a: number, b: number) => void;
 export const bitwardenclient_vault: (a: number) => number;
-export const clientvault_folders: (a: number) => number;
+export const vaultclient_folders: (a: number) => number;
 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.45",
+  "version": "0.2.0-main.47",
   "license": "GPL-3.0",
   "files": [
     "bitwarden_wasm_internal_bg.js",