feat: update version to 0.1.5 and enhance error handling across commands

Author: WillIsback

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "smart-locker"
-version = "0.1.4"
+version = "0.1.5"
 authors = ["William"]
 edition = "2021"
 license = "MIT"
@@ -52,6 +52,7 @@ ring = "0.17.14"
 copypasta = "0.10.1"
 colored = "3.0"
 flate2 = "1.0"
+thiserror = "1.0"
 
 [features]
 default = []

Cargo.toml

@@ -1,40 +1,48 @@
 use crate::utils::toolbox::get_locker_dir;
+use crate::SmartLockerError;
 use aes_gcm::aead::Aead;
 use aes_gcm::KeyInit;
 use aes_gcm::{Aes256Gcm, Key, Nonce};
 use flate2::read::GzDecoder;
 use std::fs;
 use std::io::Read;
 
-pub fn decrypt(name: &str) -> String {
-    let locker_dir = get_locker_dir();
+pub fn decrypt(name: &str) -> Result<String, SmartLockerError> {
+    let locker_dir = get_locker_dir()?;
     let key_path = locker_dir.join("locker.key");
 
     // Lire la clé symétrique
-    let key_data = fs::read(&key_path).expect("Unable to read symmetric key");
+    let key_data = fs::read(&key_path).map_err(|e| {
+        SmartLockerError::FileSystemError(format!("Unable to read symmetric key: {}", e))
+    })?;
     let key = Key::<Aes256Gcm>::from_slice(&key_data);
 
     // Initialiser AES-GCM avec la clé
     let cipher = Aes256Gcm::new(key);
 
     // Lire le fichier chiffré
     let input_path = locker_dir.join(format!("{}.slock", name));
-    let encrypted_data = fs::read(&input_path).expect("Unable to read encrypted file");
+    let encrypted_data = fs::read(&input_path).map_err(|e| {
+        SmartLockerError::FileSystemError(format!("Unable to read encrypted file: {}", e))
+    })?;
 
     // Extraire le nonce et les données chiffrées
     let (nonce, ciphertext) = encrypted_data.split_at(12);
     let nonce = Nonce::from_slice(nonce);
 
     // Déchiffrer les données
-    let decrypted_data = cipher
-        .decrypt(nonce, ciphertext)
-        .expect("Error during decryption");
+    let decrypted_data = cipher.decrypt(nonce, ciphertext).map_err(|e| {
+        SmartLockerError::DecryptionError(format!("Error during decryption: {}", e))
+    })?;
 
     // Décompresser les données
     let mut decoder = GzDecoder::new(&decrypted_data[..]);
     let mut decompressed_data = String::new();
     decoder
         .read_to_string(&mut decompressed_data)
-        .expect("Error during data decompression");
-    decompressed_data
+        .map_err(|e| {
+            SmartLockerError::DecryptionError(format!("Error during data decompression: {}", e))
+        })?;
+
+    Ok(decompressed_data)
 }

src/commands/decrypt.rs

@@ -1,4 +1,5 @@
 use crate::utils::toolbox::get_locker_dir;
+use crate::SmartLockerError;
 use aes_gcm::aead::Aead;
 use aes_gcm::KeyInit;
 use aes_gcm::{Aes256Gcm, Key, Nonce};
@@ -7,31 +8,41 @@ use flate2::Compression;
 use std::fs;
 use std::io::Write;
 
-pub fn encrypt(secret: &str, name: &str) {
-    let locker_dir = get_locker_dir();
+pub fn encrypt(secret: &str, name: &str) -> Result<(), SmartLockerError> {
+    let locker_dir = get_locker_dir()?;
     let key_path = locker_dir.join("locker.key");
 
-    let key_data = fs::read(&key_path).expect("Unable to read symmetric key");
+    let key_data = fs::read(&key_path).map_err(|e| {
+        SmartLockerError::FileSystemError(format!("Unable to read symmetric key: {}", e))
+    })?;
     let key = Key::<Aes256Gcm>::from_slice(&key_data);
     let cipher = Aes256Gcm::new(key);
     let random_bytes = rand::random::<[u8; 12]>();
     let nonce = Nonce::from_slice(&random_bytes);
 
     let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
-    encoder
-        .write_all(secret.as_bytes())
-        .expect("Error during data compression");
-    let compressed_data = encoder.finish().expect("Error when finalizing compression");
+    encoder.write_all(secret.as_bytes()).map_err(|e| {
+        SmartLockerError::EncryptionError(format!("Error during data compression: {}", e))
+    })?;
+    let compressed_data = encoder.finish().map_err(|e| {
+        SmartLockerError::EncryptionError(format!("Error when finalizing compression: {}", e))
+    })?;
 
     let ciphertext = cipher
         .encrypt(nonce, compressed_data.as_ref())
-        .expect("Error during encryption");
+        .map_err(|e| {
+            SmartLockerError::EncryptionError(format!("Error during encryption: {}", e))
+        })?;
 
     let output_path = locker_dir.join(format!("{}.slock", name));
     let mut output_data = Vec::new();
     output_data.extend_from_slice(nonce);
     output_data.extend_from_slice(&ciphertext);
 
-    fs::write(&output_path, output_data).expect("Error when writing encrypted file");
+    fs::write(&output_path, output_data).map_err(|e| {
+        SmartLockerError::FileSystemError(format!("Error when writing encrypted file: {}", e))
+    })?;
     println!("✅ Secret encrypted and saved in: {:?}", output_path);
+
+    Ok(())
 }

src/commands/encrypt.rs

@@ -1,10 +1,12 @@
 use crate::utils::toolbox::get_locker_dir;
+use crate::SmartLockerError;
 use std::fs;
 
 /// Returns a list of available secrets in the secure folder.
-pub fn list_secrets() -> Vec<String> {
-    let locker_dir = get_locker_dir();
+pub fn list_secrets() -> Result<Vec<String>, SmartLockerError> {
+    let locker_dir = get_locker_dir()?;
     let mut secrets = Vec::new();
+
     if let Ok(entries) = fs::read_dir(&locker_dir) {
         for entry in entries.flatten() {
             if let Ok(file_type) = entry.file_type() {
@@ -17,5 +19,6 @@ pub fn list_secrets() -> Vec<String> {
             }
         }
     }
-    secrets
+
+    Ok(secrets)
 }

src/commands/list.rs

@@ -1,19 +1,24 @@
 use crate::utils::toolbox::get_locker_dir;
+use crate::SmartLockerError;
 use std::fs;
 
-pub fn remove_secret(name: &str) {
-    let locker_dir = get_locker_dir();
+pub fn remove_secret(name: &str) -> Result<(), SmartLockerError> {
+    let locker_dir = get_locker_dir()?;
 
     if !locker_dir.exists() {
         println!("No secure folder found. Run `init` to create it.");
-        return;
+        return Ok(());
     }
 
     let file_path = locker_dir.join(format!("{}.slock", name));
     if file_path.exists() {
-        fs::remove_file(&file_path).expect("Error when deleting the file");
+        fs::remove_file(&file_path).map_err(|e| {
+            SmartLockerError::FileSystemError(format!("Error when deleting the file: {}", e))
+        })?;
         println!("Secret '{}' has been successfully deleted.", name);
     } else {
         println!("Secret '{}' doesn't exist.", name);
     }
+
+    Ok(())
 }

src/commands/remove.rs

@@ -1,6 +1,22 @@
+use thiserror::Error;
+
 pub mod commands;
 pub use crate::commands::{
     decrypt::decrypt, encrypt::encrypt, list::list_secrets, remove::remove_secret,
 };
 pub mod utils;
 pub use crate::utils::toolbox::{derive_key_from_passphrase, get_locker_dir, init_locker};
+
+#[derive(Error, Debug)]
+pub enum SmartLockerError {
+    #[error("File system error: {0}")]
+    FileSystemError(String),
+    #[error("Encryption error: {0}")]
+    EncryptionError(String),
+    #[error("Decryption error: {0}")]
+    DecryptionError(String),
+    #[error("Initialization error: {0}")]
+    InitializationError(String),
+    #[error("Unknown error: {0}")]
+    UnknownError(String),
+}