notedeck

linux_key_storage.rs (6818B)

---

 #![cfg(target_os = "linux")]
 
 use enostr::{Keypair, SerializableKeypair};
 use std::fs;
 use std::io::Write;
 use std::path::PathBuf;
 use std::{env, fs::File};
 
 use crate::key_storage::{KeyStorage, KeyStorageError, KeyStorageResponse};
 use tracing::debug;
 
 enum LinuxKeyStorageType {
     BasicFileStorage,
     // TODO(kernelkind): could use the secret service api, and maybe even allow password manager integration via a settings menu
 }
 
 pub struct LinuxKeyStorage {}
 
 // TODO(kernelkind): read from settings instead of hard-coding
 static USE_MECHANISM: LinuxKeyStorageType = LinuxKeyStorageType::BasicFileStorage;
 
 impl LinuxKeyStorage {
     pub fn new() -> Self {
         Self {}
     }
 }
 
 impl KeyStorage for LinuxKeyStorage {
     fn get_keys(&self) -> KeyStorageResponse<Vec<enostr::Keypair>> {
         match USE_MECHANISM {
             LinuxKeyStorageType::BasicFileStorage => BasicFileStorage::new().get_keys(),
         }
     }
 
     fn add_key(&self, key: &enostr::Keypair) -> KeyStorageResponse<()> {
         match USE_MECHANISM {
             LinuxKeyStorageType::BasicFileStorage => BasicFileStorage::new().add_key(key),
         }
     }
 
     fn remove_key(&self, key: &enostr::Keypair) -> KeyStorageResponse<()> {
         match USE_MECHANISM {
             LinuxKeyStorageType::BasicFileStorage => BasicFileStorage::new().remove_key(key),
         }
     }
 }
 
 struct BasicFileStorage {
     credential_dir_name: String,
 }
 
 impl BasicFileStorage {
     pub fn new() -> Self {
         Self {
             credential_dir_name: ".credentials".to_string(),
         }
     }
 
     fn mock() -> Self {
         Self {
             credential_dir_name: ".credentials_test".to_string(),
         }
     }
 
     fn get_cred_dirpath(&self) -> Result<PathBuf, KeyStorageError> {
         let home_dir = env::var("HOME")
             .map_err(|_| KeyStorageError::OSError("HOME env variable not set".to_string()))?;
         let home_path = std::path::PathBuf::from(home_dir);
         let project_path_str = "notedeck";
 
         let config_path = {
             if let Some(xdg_config_str) = env::var_os("XDG_CONFIG_HOME") {
                 let xdg_path = PathBuf::from(xdg_config_str);
                 let xdg_path_config = if xdg_path.is_absolute() {
                     xdg_path
                 } else {
                     home_path.join(".config")
                 };
                 xdg_path_config.join(project_path_str)
             } else {
                 home_path.join(format!(".{}", project_path_str))
             }
         }
         .join(self.credential_dir_name.clone());
 
         std::fs::create_dir_all(&config_path).map_err(|_| {
             KeyStorageError::OSError(format!(
                 "could not create config path: {}",
                 config_path.display()
             ))
         })?;
 
         Ok(config_path)
     }
 
     fn add_key_internal(&self, key: &Keypair) -> Result<(), KeyStorageError> {
         let mut file_path = self.get_cred_dirpath()?;
         file_path.push(format!("{}", &key.pubkey));
 
         let mut file = File::create(file_path)
             .map_err(|_| KeyStorageError::Addition("could not create or open file".to_string()))?;
 
         let json_str = serde_json::to_string(&SerializableKeypair::from_keypair(key, "", 7))
             .map_err(|e| KeyStorageError::Addition(e.to_string()))?;
         file.write_all(json_str.as_bytes()).map_err(|_| {
             KeyStorageError::Addition("could not write keypair to file".to_string())
         })?;
 
         Ok(())
     }
 
     fn get_keys_internal(&self) -> Result<Vec<Keypair>, KeyStorageError> {
         let file_path = self.get_cred_dirpath()?;
         let mut keys: Vec<Keypair> = Vec::new();
 
         if !file_path.is_dir() {
             return Err(KeyStorageError::Retrieval(
                 "path is not a directory".to_string(),
             ));
         }
 
         let dir = fs::read_dir(file_path).map_err(|_| {
             KeyStorageError::Retrieval("problem accessing credentials directory".to_string())
         })?;
 
         for entry in dir {
             let entry = entry.map_err(|_| {
                 KeyStorageError::Retrieval("problem accessing crediential file".to_string())
             })?;
 
             let path = entry.path();
 
             if path.is_file() {
                 if let Some(path_str) = path.to_str() {
                     debug!("key path {}", path_str);
                     let json_string = fs::read_to_string(path_str).map_err(|e| {
                         KeyStorageError::OSError(format!("File reading problem: {}", e))
                     })?;
                     let key: SerializableKeypair =
                         serde_json::from_str(&json_string).map_err(|e| {
                             KeyStorageError::OSError(format!(
                                 "Deserialization problem: {}",
                                 (e.to_string().as_str())
                             ))
                         })?;
                     keys.push(key.to_keypair(""))
                 }
             }
         }
 
         Ok(keys)
     }
 
     fn remove_key_internal(&self, key: &Keypair) -> Result<(), KeyStorageError> {
         let path = self.get_cred_dirpath()?;
 
         let filepath = path.join(key.pubkey.to_string());
 
         if filepath.exists() && filepath.is_file() {
             fs::remove_file(&filepath)
                 .map_err(|e| KeyStorageError::OSError(format!("failed to remove file: {}", e)))?;
         }
 
         Ok(())
     }
 }
 
 impl KeyStorage for BasicFileStorage {
     fn get_keys(&self) -> crate::key_storage::KeyStorageResponse<Vec<enostr::Keypair>> {
         KeyStorageResponse::ReceivedResult(self.get_keys_internal())
     }
 
     fn add_key(&self, key: &enostr::Keypair) -> crate::key_storage::KeyStorageResponse<()> {
         KeyStorageResponse::ReceivedResult(self.add_key_internal(key))
     }
 
     fn remove_key(&self, key: &enostr::Keypair) -> crate::key_storage::KeyStorageResponse<()> {
         KeyStorageResponse::ReceivedResult(self.remove_key_internal(key))
     }
 }
 
 mod tests {
     use crate::key_storage::{KeyStorage, KeyStorageResponse};
 
     use super::BasicFileStorage;
 
     #[test]
     fn test_basic() {
         let kp = enostr::FullKeypair::generate().to_keypair();
         let resp = BasicFileStorage::mock().add_key(&kp);
 
         assert_eq!(resp, KeyStorageResponse::ReceivedResult(Ok(())));
         assert_num_storage(1);
 
         let resp = BasicFileStorage::mock().remove_key(&kp);
         assert_eq!(resp, KeyStorageResponse::ReceivedResult(Ok(())));
         assert_num_storage(0);
     }
 
     #[allow(dead_code)]
     fn assert_num_storage(n: usize) {
         let resp = BasicFileStorage::mock().get_keys();
 
         if let KeyStorageResponse::ReceivedResult(Ok(vec)) = resp {
             assert_eq!(vec.len(), n);
             return;
         }
         panic!();
     }
 }