Stronghold

GitHubnpmcrates.io

Referencia de API

Almacena secretos y claves utilizando el motor de gestión de secretos IOTA Stronghold.

Plataformas Soportadas

Este plugin requiere una versión de Rust de al menos 1.77.2

Plataforma	Nivel	Notas
windows
linux
macos
android
ios

Configuración

Instala el plugin stronghold para comenzar.

Automático

Usa el gestor de paquetes de tu proyecto para agregar la dependencia:

npm

npm run tauri add stronghold

yarn

yarn run tauri add stronghold

pnpm

pnpm tauri add stronghold

deno

deno task tauri add stronghold

bun

bun tauri add stronghold

cargo

cargo tauri add stronghold

Manual

1. Ejecuta el siguiente comando en la carpeta src-tauri para agregar el plugin a las dependencias del proyecto en Cargo.toml:

   cargo add tauri-plugin-stronghold

2. Modifica lib.rs para inicializar el plugin:

   src-tauri/src/lib.rs

   #[cfg_attr(mobile, tauri::mobile_entry_point)]
   pub fn run() {
       tauri::Builder::default()
           .plugin(tauri_plugin_stronghold::Builder::new(|password| {}).build())
           .run(tauri::generate_context!())
           .expect("error while running tauri application");
   }

3. Instala los bindings de JavaScript utilizando tu gestor de paquetes de JavaScript preferido:

   npm

   npm install @tauri-apps/plugin-stronghold

   yarn

   yarn add @tauri-apps/plugin-stronghold

   pnpm

   pnpm add @tauri-apps/plugin-stronghold

   deno

   deno add npm:@tauri-apps/plugin-stronghold

   bun

   bun add @tauri-apps/plugin-stronghold

Debido a un error ascendente, también recomendamos que añadas esto a tu archivo Cargo.toml:

[profile.dev.package.scrypt]
opt-level = 3

Uso

El plugin se debe inicializar con una función de hash de contraseña, que toma la cadena de la contraseña y debe devolver un hash de 32 bytes derivado de ella.

Inicializar con la función de hash de contraseña argon2

El plugin de Stronghold ofrece una función de hash por defecto utilizando el algoritmo argon2.

src-tauri/src/lib.rs

use tauri::Manager;

pub fn run() {
    tauri::Builder::default()
        .setup(|app| {
            let salt_path = app
                .path()
                .app_local_data_dir()
                .expect("could not resolve app local data path")
                .join("salt.txt");
            app.handle().plugin(tauri_plugin_stronghold::Builder::with_argon2(&salt_path).build())?;
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Inicializar con una función de hash de contraseña personalizada

Alternativamente puedes proporcionar tu propio algoritmo de hash utilizando el constructor tauri_plugin_stronghold::Builder::new.

Nota

El hash de la contraseña debe contener exactamente 32 bytes. Este es un requisito de Stronghold.

src-tauri/src/lib.rs

pub fn run() {
    tauri::Builder::default()
        .plugin(
            tauri_plugin_stronghold::Builder::new(|password| {
                // Hash the password here with e.g. argon2, blake2b or any other secure algorithm
                // Here is an example implementation using the `rust-argon2` crate for hashing the password
                use argon2::{hash_raw, Config, Variant, Version};

                let config = Config {
                    lanes: 4,
                    mem_cost: 10_000,
                    time_cost: 10,
                    variant: Variant::Argon2id,
                    version: Version::Version13,
                    ..Default::default()
                };
                let salt = "your-salt".as_bytes();
                let key = hash_raw(password.as_ref(), salt, &config).expect("failed to hash password");

                key.to_vec()
            })
            .build(),
        )
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Uso desde JavaScript

El plugin stronghold está disponible en JavaScript.

import { Client, Stronghold } from '@tauri-apps/plugin-stronghold';
// when using `"withGlobalTauri": true`, you may use
// const { Client, Stronghold } = window.__TAURI__.stronghold;
import { appDataDir } from '@tauri-apps/api/path';
// when using `"withGlobalTauri": true`, you may use
// const { appDataDir } = window.__TAURI__.path;

const initStronghold = async () => {
  const vaultPath = `${await appDataDir()}/vault.hold`;
  const vaultPassword = 'vault password';
  const stronghold = await Stronghold.load(vaultPath, vaultPassword);

  let client: Client;
  const clientName = 'name your client';
  try {
    client = await stronghold.loadClient(clientName);
  } catch {
    client = await stronghold.createClient(clientName);
  }

  return {
    stronghold,
    client,
  };
};

// Insert a record to the store
async function insertRecord(store: any, key: string, value: string) {
  const data = Array.from(new TextEncoder().encode(value));
  await store.insert(key, data);
}

// Read a record from store
async function getRecord(store: any, key: string): Promise<string> {
  const data = await store.get(key);
  return new TextDecoder().decode(new Uint8Array(data));
}

const { stronghold, client } = await initStronghold();

const store = client.getStore();
const key = 'my_key';

// Insert a record to the store
insertRecord(store, key, 'secret value');

// Read a record from store
const value = await getRecord(store, key);
console.log(value); // 'secret value'

// Save your updates
await stronghold.save();

// Remove a record from store
await store.remove(key);

Permisos

De forma predeterminada, todos los comandos y alcances (scopes) potencialmente peligrosos del plugin están bloqueados y no se puede acceder a ellos. Debes modificar los permisos en tu configuración de capabilities para habilitarlos.

Consulta la Visión General de Capacidades para obtener más información y la guía paso a paso para usar permisos de plugins.

src-tauri/capabilities/default.json

{
  ...,
  "permissions": [
    "stronghold:default",
  ]
}

Permiso Predeterminado

Este conjunto de permisos configura qué tipo de operaciones están disponibles desde el plugin stronghold.

Permisos Otorgados

Todas las operaciones no destructivas están habilitadas por defecto.

Este conjunto de permisos predeterminado incluye lo siguiente:

• allow-create-client
• allow-get-store-record
• allow-initialize
• allow-execute-procedure
• allow-load-client
• allow-save-secret
• allow-save-store-record
• allow-save

Tabla de Permisos

Identificador	Descripción
stronghold:allow-create-client	Habilita el comando create_client sin ningún ámbito preconfigurado.
stronghold:deny-create-client	Deniega el comando create_client sin ningún ámbito preconfigurado.
stronghold:allow-destroy	Habilita el comando destroy sin ningún ámbito preconfigurado.
stronghold:deny-destroy	Deniega el comando destroy sin ningún ámbito preconfigurado.
stronghold:allow-execute-procedure	Habilita el comando execute_procedure sin ningún ámbito preconfigurado.
stronghold:deny-execute-procedure	Deniega el comando execute_procedure sin ningún ámbito preconfigurado.
stronghold:allow-get-store-record	Habilita el comando get_store_record sin ningún ámbito preconfigurado.
stronghold:deny-get-store-record	Deniega el comando get_store_record sin ningún ámbito preconfigurado.
stronghold:allow-initialize	Habilita el comando initialize sin ningún ámbito preconfigurado.
stronghold:deny-initialize	Deniega el comando initialize sin ningún ámbito preconfigurado.
stronghold:allow-load-client	Habilita el comando load_client sin ningún ámbito preconfigurado.
stronghold:deny-load-client	Deniega el comando load_client sin ningún ámbito preconfigurado.
stronghold:allow-remove-secret	Habilita el comando remove_secret sin ningún ámbito preconfigurado.
stronghold:deny-remove-secret	Deniega el comando remove_secret sin ningún ámbito preconfigurado.
stronghold:allow-remove-store-record	Habilita el comando remove_store_record sin ningún ámbito preconfigurado.
stronghold:deny-remove-store-record	Deniega el comando remove_store_record sin ningún ámbito preconfigurado.
stronghold:allow-save	Habilita el comando save sin ningún ámbito preconfigurado.
stronghold:deny-save	Deniega el comando save sin ningún ámbito preconfigurado.
stronghold:allow-save-secret	Habilita el comando save_secret sin ningún ámbito preconfigurado.
stronghold:deny-save-secret	Deniega el comando save_secret sin ningún ámbito preconfigurado.
stronghold:allow-save-store-record	Habilita el comando save_store_record sin ningún ámbito preconfigurado.
stronghold:deny-save-store-record	Deniega el comando save_store_record sin ningún ámbito preconfigurado.