Import Aegis backup,importers API

Author: replydev

src/argument_functions.rs

@@ -1,23 +1,45 @@
-use std::fs::{read_to_string,File};
-use std::io::prelude::*;
-use super::utils::get_db_path;
 use super::database_loader;
-use super::cryptograpy;
 use super::otp_helper;
+use crate::importers;
 
 pub fn help(){
     println!("ARGUMENTS:");
     println!("-a,--add <secret> <issuer> <label>       | Add a new OTP code");
     println!("-r,--remove <secret> <issuer> <label>    | Remove an OTP code");
     println!("-e,--edit <id> <secret> <issuer> <label> | Edit an OTP code");
-    println!("-i,--import <filename>                   | Import an andOTP backup");
+    println!("-i,--import aegis,andotp <filename>      | Import a backup from a given application");
     println!("-ex,--export                             | Export the entire database in a plaintext json format");
     println!("-j,--json                                | Print results in json format");
     println!("-h,--help                                | Print this help");
 }
 
 pub fn import(args: Vec<String>){
-    import_database(&args[2]);
+    if args.len() == 4{
+        let result: Result<Vec<database_loader::OTPElement>,String>;
+        let elements: Vec<database_loader::OTPElement>;
+
+        match &args[2][..]{
+            "andotp" => result = importers::and_otp::import(&args[3]),
+            "aegis" => result = importers::aegis::import(&args[3]),
+            _=> {
+                println!("Invalid argument: {}", &args[2]);
+                return;
+            }
+        }
+
+        match result {
+            Ok(result) => elements = result,
+            Err(e) => {
+                println!("An error occurred: {}", e);
+                return;
+            }
+        }
+        database_loader::overwrite_database(elements);
+        println!("Successfully imported database");
+    }
+    else{
+        println!("Invalid arguments, type cotp --import <backup_format> <path>");
+    }
 }
 
 pub fn add(args: Vec<String>){
@@ -87,11 +109,3 @@ pub fn json(args: Vec<String>){
         println!("Invalid argument, type cotp --json");
     }
 }
-
-fn import_database(filename: &String){
-    let mut unencrypted_content = read_to_string(filename).unwrap();
-    let encrypted_content = cryptograpy::encrypt_string(&mut unencrypted_content,&cryptograpy::prompt_for_passwords("Insert password for database encryption: "));
-    let mut encrypted_file = File::create(&get_db_path()).expect("Cannot create encrypted database file");
-    encrypted_file.write_all(encrypted_content.as_bytes()).expect("Cannot write to encrypted file");
-    println!("Successfully imported database");
-}

src/database_loader.rs

@@ -170,7 +170,11 @@ pub fn export_database() -> Result<String, String> {
 
 pub fn overwrite_database(elements: Vec<OTPElement>){
     let json_string: &str = &serde_json::to_string(&elements).unwrap();
-    let encrypted = cryptograpy::encrypt_string(&mut json_string.to_string(), &cryptograpy::prompt_for_passwords("Insert password for database encryption: "));
+    overwrite_database_json(json_string);
+}
+
+pub fn overwrite_database_json(json: &str){
+    let encrypted = cryptograpy::encrypt_string(&mut json.to_string(), &cryptograpy::prompt_for_passwords("Insert password for database encryption: "));
     utils::write_to_file(&encrypted, &mut File::create(utils::get_db_path()).expect("Failed to open file"));
 }
 

src/importers/aegis.rs

@@ -0,0 +1,70 @@
+use crate::database_loader::OTPElement;
+use std::fs::read_to_string;
+use serde_json;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct AegisJson{
+    version: u64,
+    header: AegisHeader,
+    db: AegisDb,
+}
+
+#[derive(Deserialize)]
+struct AegisHeader{
+    slots: Option<String>,
+    params: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct AegisDb{
+    version: u64,
+    entries: Vec<AegisElement>,
+}
+
+#[derive(Deserialize)]
+struct AegisElement{
+    #[serde(rename = "type")]
+    _type: String,
+    uuid: String,
+    name: String,
+    issuer: String,
+    icon: Option<String>,
+    info: AegisInfo,
+}
+
+#[derive(Deserialize)]
+struct AegisInfo {
+    secret: String,
+    algo: String,
+    digits: u64,
+    period: u64,
+}
+
+pub fn import(filepath: &str) -> Result<Vec<OTPElement>,String> {
+    let file_to_import_contents = read_to_string(filepath).unwrap();
+    let result: Result<AegisJson,serde_json::Error> = serde_json::from_str(&file_to_import_contents);
+    let aegis;
+    match result {
+        Ok(element) => aegis = element,
+        Err(e) => return Err(format!("{}", e)),
+    }
+
+    let mut elements: Vec<OTPElement> = Vec::new();
+
+    for i in 0..aegis.db.entries.len() {
+        elements.push(OTPElement::new(
+            String::from(&aegis.db.entries[i].info.secret),
+            String::from(&aegis.db.entries[i].issuer), 
+            String::from(&aegis.db.entries[i].name), 
+            aegis.db.entries[i].info.digits,
+            String::from(&aegis.db.entries[i]._type), 
+            String::from(&aegis.db.entries[i].info.algo), 
+            String::from(""), 
+            0, 
+            0, 
+            aegis.db.entries[i].info.period, 
+            vec![]))
+    }
+    Ok(elements)
+}

src/importers/and_otp.rs

@@ -0,0 +1,13 @@
+use crate::database_loader::OTPElement;
+use std::fs::read_to_string;
+
+//no need to declarate andOTP json struct cause it's the same as OTP element
+
+pub fn import(filepath: &str) -> Result<Vec<OTPElement>,String>{
+    let file_to_import_contents = read_to_string(filepath).unwrap();
+    let result: Result<Vec<OTPElement>,serde_json::Error> = serde_json::from_str(&file_to_import_contents);
+    match result {
+        Ok(element) => return Ok(element),
+        Err(e) => return Err(String::from(format!("Failed to serialize file: {}",e)))
+    }
+}

src/importers/mod.rs

@@ -0,0 +1,2 @@
+pub mod and_otp;
+pub mod aegis;

src/main.rs

@@ -6,6 +6,7 @@ mod argument_functions;
 mod otp_helper;
 mod cryptograpy;
 use sodiumoxide;
+mod import_otp;
 
 #[cfg(debug_assertions)]
 fn print_title(version: &str){

src/utils.rs

@@ -2,7 +2,7 @@ use directories::BaseDirs;
 use std::fs::{File};
 use std::io::prelude::*;
 use std::path::Path;
-use super::cryptograpy;
+use super::database_loader;
 
 #[cfg(debug_assertions)]
 pub fn get_db_path() -> String{
@@ -25,9 +25,10 @@ pub fn get_home_folder() -> String {
 
 pub fn create_db_if_needed(){
     if !Path::new(&get_db_path()).exists() {
-        let mut database_file = File::create(&get_db_path()).expect("Cannot create encrypted database file");
+        /*let mut database_file = File::create(&get_db_path()).expect("Cannot create encrypted database file");
         let encrypted_content = cryptograpy::encrypt_string(&mut String::from("[]"), &cryptograpy::prompt_for_passwords("Insert password for database encryption: "));
-        write_to_file(&encrypted_content,&mut database_file);
+        write_to_file(&encrypted_content,&mut database_file);*/
+        database_loader::overwrite_database_json("[]");
     }
 }