tenho seguinte module no rust encryptpassword.rs use argon2::{ passwordhash::{…
- User
tenho seguinte module no rust
encrypt_password.rs
use argon2::{ password_hash::{ rand_core::OsRng, PasswordHasher, PasswordVerifier, SaltString, Error as ArgonError, }, Argon2, PasswordHash, };
use serde::{Deserialize, Serialize};
// Defina a estrutura dos dados #[derive(Serialize, Deserialize)] pub struct Credentials { pub username: String, pub password_hash: String, }
// Função para hash da senha pub fn hash_password(password: &str) -> Result<String, ArgonError> { let salt = SaltString::generate(&mut OsRng); let argon2 = Argon2::default(); let password_hash = argon2.hash_password(password.as_bytes(), &salt)?.to_string(); Ok(password_hash) }
// Função para verificar a senha pub fn verify_password(hash: &str, password: &str) -> Result<bool, ArgonError> { let parsed_hash = PasswordHash::new(hash)?; let argon2 = Argon2::default(); Ok(argon2.verify_password(password.as_bytes(), &parsed_hash).is_ok()) }
No lib.rs tenho
mod encrypt_password;
#[tauri::command] fn greet(name: &str) -> String { format!("Hello, {}! You've been greeted from Rust!", name) }
#[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_shell::init()) .invoke_handler(tauri::generate_handler![greet]) .run(tauri::generate_context!()) .expect("error while running tauri application"); }
Eu preciso criar funções rust para usar no react para salvar e inserir infos salvas
e depois no run eu preciso fazer load, deve ser usado o plugin-store do tauri v2
Exemplo de uso para ler as configurações
use tauri::Wry; use tauri_plugin_store::{with_store, StoreCollection}; use serde_json::json;
#[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_store::Builder::default().build()) .setup(|app| { let stores = app.handle().try_state::<StoreCollection>().ok_or("Store not found")?; let path = PathBuf::from("store.bin");
with_store(app.handle().clone(), stores, path, |store| { // Note that values must be serde_json::Value instances, // otherwise, they will not be compatible with the JavaScript bindings. store.insert("some-key".to_string(), json!({ "value": 5 }))?; // Get a value from the store. let value = store.get("some-key").expect("Failed to get value from store"); println!("{}", value); // {"value":5} // You can manually save the store after making changes. // Otherwise, it will save upon graceful exit as described above. store.save()?; Ok(()) }); Ok(()) }) .run(tauri::generate_context!()) .expect("error while running tauri application");}
- Assistant
To help you integrate your Rust functions with your React frontend in a Tauri application using the
tauri-plugin-store, I'll guide you through creating Rust commands that can be invoked from React to save and retrieve information (like credentials). Also, we'll modify yourrunfunction to properly load and set up the store using the Tauri plugin.Here's how you can proceed:
1. Expose Rust Functions to React
First, we need to create Rust functions that can be called from the React frontend. In Tauri, we use the
#[tauri::command]attribute to expose Rust functions as commands to the frontend.Define Commands for Saving and Loading Credentials
In your
lib.rs, you can define the following commands:use tauri::{command, AppHandle}; use tauri::Manager; use tauri::Wry; use tauri_plugin_store::{with_store, StoreCollection}; use serde_json::json; use std::path::PathBuf; // Bring in the encrypt_password module mod encrypt_password; use encrypt_password::{Credentials, hash_password, verify_password}; #[command] async fn save_credentials(app: AppHandle<Wry>, username: String, password: String) -> Result<(), String> { let stores = app.state::<StoreCollection>().await.unwrap(); let path = PathBuf::from("store.bin"); // Hash the password let hashed_password = hash_password(&password).map_err(|e| e.to_string())?; let credentials = Credentials { username: username.clone(), password_hash: hashed_password.clone(), }; // Serialize the credentials to JSON let credentials_json = json!(credentials); // Save to the store with_store(app.clone(), stores, path, |store| { store.insert("credentials".to_string(), credentials_json)?; store.save()?; Ok(()) }).map_err(|e| e.to_string())?; Ok(()) } #[command] async fn load_credentials(app: AppHandle<Wry>) -> Result<Credentials, String> { let stores = app.state::<StoreCollection>().await.unwrap(); let path = PathBuf::from("store.bin"); let credentials = with_store(app.clone(), stores, path, |store| { let value = store.get("credentials").ok_or("Credentials not found in store")?; // Deserialize the value back into Credentials let credentials: Credentials = serde_json::from_value(value.clone()).map_err(|e| e.to_string())?; Ok(credentials) }).map_err(|e| e.to_string())?; Ok(credentials) } #[command] async fn verify_user_password(app: AppHandle<Wry>, username: String, password: String) -> Result<bool, String> { let credentials = load_credentials(app).await?; if credentials.username != username { return Ok(false); } let is_valid = verify_password(&credentials.password_hash, &password).map_err(|e| e.to_string())?; Ok(is_valid) }In these commands:
save_credentials: Hashes the password and saves the credentials to the store.load_credentials: Loads the credentials from the store.verify_user_password: Verifies if the provided username and password match the stored credentials.
2. Update the
runFunctionNext, we need to update the
runfunction to include thetauri-plugin-storeand register our new commands.#[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_shell::init()) .plugin(tauri_plugin_store::Builder::default().build()) .invoke_handler(tauri::generate_handler![ greet, save_credentials, load_credentials, verify_user_password ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); }With this setup, your Tauri application is now ready to handle the
save_credentials,load_credentials, andverify_user_passwordcommands from the React frontend.3. Use the Commands from React
In your React application, you can use Tauri's
invokefunction to call these commands.Example of Saving Credentials:
import { invoke } from '@tauri-apps/api/tauri'; async function saveUserCredentials(username, password) { try { await invoke('save_credentials', { username, password }); console.log('Credentials saved successfully.'); } catch (error) { console.error('Error saving credentials:', error); } }Example of Verifying User Credentials:
import { invoke } from '@tauri-apps/api/tauri'; async function verifyUserCredentials(username, password) { try { const isValid = await invoke('verify_user_password', { username, password }); if (isValid) { console.log('User credentials are valid.'); } else { console.log('Invalid username or password.'); } } catch (error) { console.error('Error verifying credentials:', error); } }4. Ensure Correct Usage of the Store Plugin
The
tauri-plugin-storeprovides an easy way to persist data in your Tauri application. In the updatedrunfunction, we're initializing the store plugin with.plugin(tauri_plugin_store::Builder::default().build()).Ensure that you have the necessary imports at the top of your
lib.rsfile:use tauri::Wry; use tauri_plugin_store::StoreBuilder;5. Handle Store Initialization in
setup(Optional)If you need to perform any actions during the application setup (like loading configurations), you can use the
.setupmethod in yourrunfunction. Here's an example:#[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_shell::init()) .plugin(tauri_plugin_store::Builder::default().build()) .setup(|app| { // Perform any setup actions here let handle = app.handle(); let stores = handle.state::<StoreCollection>(); let path = PathBuf::from("store.bin"); with_store(handle.clone(), stores, path, |store| { // Example: Initialize default values if they don't exist if !store.contains_key("credentials") { // Set default credentials or leave empty store.insert("credentials".to_string(), json!(null))?; store.save()?; } Ok(()) }).map_err(|e| e.to_string())?; Ok(()) }) .invoke_handler(tauri::generate_handler![ greet, save_credentials, load_credentials, verify_user_password ]) .run(tauri::generate_context!()) .expect("error while running tauri application"); }6. Update Your
encrypt_password.rsModule (If Necessary)Ensure that your
encrypt_password.rsmodule is compatible with the types you're using in your commands.use argon2::{ password_hash::{ rand_core::OsRng, PasswordHasher, PasswordVerifier, SaltString, Error as ArgonError, }, Argon2, PasswordHash, }; use serde::{Deserialize, Serialize}; // Define the structure of the credentials #[derive(Serialize, Deserialize, Debug)] pub struct Credentials { pub username: String, pub password_hash: String, } // Function to hash the password pub fn hash_password(password: &str) -> Result<String, ArgonError> { let salt = SaltString::generate(&mut OsRng); let argon2 = Argon2::default(); let password_hash = argon2.hash_password(password.as_bytes(), &salt)?.to_string(); Ok(password_hash) } // Function to verify the password pub fn verify_password(hash: &str, password: &str) -> Result<bool, ArgonError> { let parsed_hash = PasswordHash::new(hash)?; let argon2 = Argon2::default(); Ok(argon2.verify_password(password.as_bytes(), &parsed_hash).is_ok()) }7. Security Considerations
- Do Not Expose Plain Passwords: Ensure that you're not exposing plain-text passwords or sensitive data to the frontend or logs.
- Error Handling: Handle errors gracefully and avoid leaking sensitive information through error messages.
- Secure Storage: While
tauri-plugin-storeprovides basic storage, for sensitive data like passwords, consider using more secure storage mechanisms or encryption.
8. Dependencies
Ensure that your
Cargo.tomlincludes the necessary dependencies:[dependencies] tauri = { version = "2", features = ["wry"] } tauri-plugin-store = "2" argon2 = "0.4" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0"Summary
By following these steps, you bridge the gap between your Rust backend and React frontend in a Tauri application. You've created commands to save and load credentials securely, integrated the
tauri-plugin-storefor persistent storage, and exposed these functionalities to your React code.Feel free to customize the code snippets to better fit your application's architecture and requirements.
If you have any questions or need further assistance, please let me know!