Stronghold

GitHub npm crates.io

API 参考

使用 IOTA Stronghold 密钥管理引擎存储密钥和秘密。

支持的平台

此插件需要至少 1.77.2 版本的 Rust

平台	级别	注释
windows
linux
macos
android
ios

设置

安装 stronghold 插件即可开始。

自动

使用项目的包管理器添加依赖项

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

手动

1. 在 src-tauri 文件夹中运行以下命令，将插件添加到 Cargo.toml 项目的依赖项中

   cargo add tauri-plugin-stronghold

2. 修改 lib.rs 以初始化插件

   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. 使用您首选的 JavaScript 包管理器安装 JavaScript Guest 绑定

   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

用法

插件必须使用密码哈希函数初始化，该函数接受密码字符串，并且必须返回从中派生的 32 字节哈希值。

使用 argon2 密码哈希函数初始化

Stronghold 插件提供使用 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");
}

使用自定义密码哈希函数初始化

或者，您可以使用 tauri_plugin_stronghold::Builder::new 构造函数提供您自己的哈希算法。

注意

密码哈希必须正好包含 32 个字节。 这是 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");
}

JavaScript 中的用法

stronghold 插件在 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);

权限

默认情况下，所有潜在危险的插件命令和作用域都被阻止，并且无法访问。 您必须修改 capabilities 配置中的权限才能启用这些。

有关更多信息，请参阅功能概述和使用插件权限的分步指南。

src-tauri/capabilities/default.json

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

默认权限

此权限集配置了 stronghold 插件中可用的操作类型。

已授予的权限

默认情况下，所有非破坏性操作均已启用。

此默认权限集包括以下内容

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

权限表

标识符	描述
stronghold:allow-create-client	启用 create_client 命令，无需任何预配置的作用域。
stronghold:deny-create-client	拒绝 create_client 命令，无需任何预配置的作用域。
stronghold:allow-destroy	启用 destroy 命令，无需任何预配置的作用域。
stronghold:deny-destroy	拒绝 destroy 命令，无需任何预配置的作用域。
stronghold:allow-execute-procedure	启用 execute_procedure 命令，无需任何预配置的作用域。
stronghold:deny-execute-procedure	拒绝 execute_procedure 命令，无需任何预配置的作用域。
stronghold:allow-get-store-record	启用 get_store_record 命令，无需任何预配置的作用域。
stronghold:deny-get-store-record	拒绝 get_store_record 命令，无需任何预配置的作用域。
stronghold:allow-initialize	启用 initialize 命令，无需任何预配置的作用域。
stronghold:deny-initialize	拒绝 initialize 命令，无需任何预配置的作用域。
stronghold:allow-load-client	启用 load_client 命令，无需任何预配置的作用域。
stronghold:deny-load-client	拒绝 load_client 命令，无需任何预配置的作用域。
stronghold:allow-remove-secret	启用 remove_secret 命令，无需任何预配置的作用域。
stronghold:deny-remove-secret	拒绝 remove_secret 命令，无需任何预配置的作用域。
stronghold:allow-remove-store-record	启用 remove_store_record 命令，无需任何预配置的作用域。
stronghold:deny-remove-store-record	拒绝 remove_store_record 命令，无需任何预配置的作用域。
stronghold:allow-save	启用 save 命令，无需任何预配置的作用域。
stronghold:deny-save	拒绝 save 命令，无需任何预配置的作用域。
stronghold:allow-save-secret	启用 save_secret 命令，无需任何预配置的作用域。
stronghold:deny-save-secret	拒绝 deny_save_secret 命令，无需任何预配置的作用域。
stronghold:allow-save-store-record	启用 save_store_record 命令，无需任何预配置的作用域。
stronghold:deny-save-store-record	拒绝 deny_save_store_record 命令，无需任何预配置的作用域。