Implement extract subcommand and password insertion through stdin (#403)

Extract subcommand prints the code of the selected OTP code.
Password insertion through standard input permits non interactive access
to OTP codes.

Author: replydev

src/args.rs

@@ -13,6 +13,9 @@ use crate::{
 pub struct CotpArgs {
     #[command(subcommand)]
     command: Option<CotpSubcommands>,
+    /// Fetch the password from standard input
+    #[arg(long = "password-stdin", default_value_t = false)]
+    pub password_from_stdin: bool,
 }
 
 #[derive(Subcommand)]
@@ -25,6 +28,8 @@ enum CotpSubcommands {
     Import(ImportArgs),
     /// Export cotp database
     Export(ExportArgs),
+    /// Copies the selected code into the clipboard
+    Extract(ExtractArgs),
     /// Change database password
     Passwd,
 }
@@ -123,6 +128,25 @@ pub struct ImportArgs {
     pub path: PathBuf,
 }
 
+#[derive(Args)]
+pub struct ExtractArgs {
+    /// Code Index
+    #[arg(short, long, required_unless_present_any=["issuer", "label"])]
+    pub index: Option<usize>,
+
+    /// Code issuer
+    #[arg(short = 's', long, required_unless_present_any=["index","label"])]
+    pub issuer: Option<String>,
+
+    /// Code label
+    #[arg(short, long, required_unless_present_any=["index", "issuer"])]
+    pub label: Option<String>,
+
+    /// Copy the code to the clipboard
+    #[arg(short, long = "copy-clipboard", default_value_t = false)]
+    pub copy_to_clipboard: bool,
+}
+
 #[derive(Args)]
 pub struct ExportArgs {
     /// Export file path
@@ -219,6 +243,7 @@ pub fn args_parser(matches: CotpArgs, read_result: OTPDatabase) -> color_eyre::R
         Some(CotpSubcommands::Edit(args)) => argument_functions::edit(args, read_result),
         Some(CotpSubcommands::Import(args)) => argument_functions::import(args, read_result),
         Some(CotpSubcommands::Export(args)) => argument_functions::export(args, read_result),
+        Some(CotpSubcommands::Extract(args)) => argument_functions::extract(args, read_result),
         Some(CotpSubcommands::Passwd) => argument_functions::change_password(read_result),
         // no args, show dashboard
         None => dashboard(read_result).map_err(|e| eyre!("An error occurred: {e}")),

src/argument_functions.rs

@@ -1,4 +1,4 @@
-use crate::args::{AddArgs, EditArgs, ExportArgs, ImportArgs};
+use crate::args::{AddArgs, EditArgs, ExportArgs, ExtractArgs, ImportArgs};
 use crate::exporters::do_export;
 use crate::exporters::otp_uri::OtpUriList;
 use crate::importers::aegis::AegisJson;
@@ -8,7 +8,7 @@ use crate::importers::converted::ConvertedJsonList;
 use crate::importers::freeotp_plus::FreeOTPPlusJson;
 use crate::importers::importer::import_from_path;
 use crate::otp::otp_element::{OTPDatabase, OTPElement};
-use crate::utils;
+use crate::{clipboard, utils};
 use color_eyre::eyre::{eyre, ErrReport};
 use zeroize::Zeroize;
 
@@ -158,6 +158,27 @@ pub fn export(matches: ExportArgs, database: OTPDatabase) -> color_eyre::Result<
     .map_err(|e| eyre!("An error occurred while exporting database: {e}"))
 }
 
+pub fn extract(args: ExtractArgs, database: OTPDatabase) -> color_eyre::Result<OTPDatabase> {
+    let first_with_filters = database
+        .elements
+        .iter()
+        .enumerate()
+        .find(|(index, code)| filter_extract(&args, index, code))
+        .map(|(_, code)| code);
+
+    if let Some(otp) = first_with_filters {
+        let code = otp.get_otp_code()?;
+        println!("{}", code);
+        if args.copy_to_clipboard {
+            let _ = clipboard::copy_string_to_clipboard(code.as_str())?;
+            println!("Copied to clipboard");
+        }
+        Ok(database)
+    } else {
+        Err(eyre!("No such code found with these fields"))
+    }
+}
+
 pub fn change_password(mut database: OTPDatabase) -> color_eyre::Result<OTPDatabase> {
     let mut new_password = utils::verified_password("New password: ", 8);
     database
@@ -166,3 +187,17 @@ pub fn change_password(mut database: OTPDatabase) -> color_eyre::Result<OTPDatab
     new_password.zeroize();
     Ok(database)
 }
+
+fn filter_extract(args: &ExtractArgs, index: &usize, code: &OTPElement) -> bool {
+    let match_by_index = args.index.map_or(true, |i| i == *index);
+
+    let match_by_issuer = args.issuer.as_ref().map_or(true, |issuer| {
+        code.issuer.to_lowercase() == issuer.to_lowercase()
+    });
+
+    let match_by_label = args.label.as_ref().map_or(true, |label| {
+        code.label.to_lowercase() == label.to_lowercase()
+    });
+
+    match_by_index && match_by_issuer && match_by_label
+}

src/clipboard.rs

@@ -1,4 +1,5 @@
 use base64::{engine::general_purpose, Engine as _};
+use color_eyre::eyre::eyre;
 use copypasta_ext::prelude::*;
 #[cfg(target_os = "linux")]
 use copypasta_ext::wayland_bin::WaylandBinClipboardContext;
@@ -12,13 +13,13 @@ pub enum CopyType {
     OSC52,
 }
 
-pub fn copy_string_to_clipboard(content: String) -> Result<CopyType, ()> {
-    if ssh_clipboard(content.as_str()) {
+pub fn copy_string_to_clipboard(content: &str) -> color_eyre::Result<CopyType> {
+    if ssh_clipboard(content) {
         Ok(CopyType::OSC52)
-    } else if wayland_clipboard(content.as_str()) || other_platform_clipboard(content.as_str()) {
+    } else if wayland_clipboard(content) || other_platform_clipboard(content) {
         Ok(CopyType::Native)
     } else {
-        Err(())
+        Err(eyre!("Cannot detect clipboard implementation"))
     }
 }
 

src/interface/handler.rs

@@ -217,7 +217,7 @@ fn copy_selected_code_to_clipboard(app: &mut App) -> String {
         Some(selected) => match app.table.items.get(selected) {
             Some(element) => match element.values.get(3) {
                 Some(otp_code) => {
-                    if let Ok(result) = copy_string_to_clipboard(otp_code.to_owned()) {
+                    if let Ok(result) = copy_string_to_clipboard(otp_code) {
                         match result {
                             CopyType::Native => "Copied!".to_string(),
                             CopyType::OSC52 => "Remote copied!".to_string(),

src/main.rs

@@ -9,7 +9,7 @@ use interface::ui::Tui;
 use otp::otp_element::{OTPDatabase, CURRENT_DATABASE_VERSION};
 use ratatui::prelude::CrosstermBackend;
 use ratatui::Terminal;
-use reading::{get_elements, ReadResult};
+use reading::{get_elements_from_input, get_elements_from_stdin, ReadResult};
 use std::{io, vec};
 use zeroize::Zeroize;
 
@@ -25,7 +25,7 @@ mod path;
 mod reading;
 mod utils;
 
-fn init() -> color_eyre::Result<ReadResult> {
+fn init(read_password_from_stdin: bool) -> color_eyre::Result<ReadResult> {
     match utils::init_app() {
         Ok(first_run) => {
             if first_run {
@@ -39,8 +39,10 @@ fn init() -> color_eyre::Result<ReadResult> {
                 let save_result = database.save_with_pw(&pw);
                 pw.zeroize();
                 save_result.map(|(key, salt)| (database, key, salt.to_vec()))
+            } else if read_password_from_stdin {
+                get_elements_from_stdin()
             } else {
-                get_elements()
+                get_elements_from_input()
             }
         }
         Err(()) => Err(eyre!("An error occurred during database creation")),
@@ -50,8 +52,8 @@ fn init() -> color_eyre::Result<ReadResult> {
 fn main() -> AppResult<()> {
     color_eyre::install()?;
 
-    let cotp_args = CotpArgs::parse();
-    let (database, mut key, salt) = match init() {
+    let cotp_args: CotpArgs = CotpArgs::parse();
+    let (database, mut key, salt) = match init(cotp_args.password_from_stdin) {
         Ok(v) => v,
         Err(e) => {
             println!("{e}");
@@ -71,7 +73,7 @@ fn main() -> AppResult<()> {
     let error_code = if reowned_database.is_modified() {
         match reowned_database.save(&key, &salt) {
             Ok(_) => {
-                println!("Success");
+                println!("Modifications has been persisted");
                 0
             }
             Err(_) => {
@@ -80,7 +82,6 @@ fn main() -> AppResult<()> {
             }
         }
     } else {
-        println!("Success");
         0
     };
     key.zeroize();

src/reading.rs

@@ -4,15 +4,26 @@ use crate::path::get_db_path;
 use crate::utils;
 use color_eyre::eyre::{eyre, ErrReport};
 use std::fs::read_to_string;
-use std::io;
+use std::io::{self, BufRead};
 use zeroize::Zeroize;
 
 pub type ReadResult = (OTPDatabase, Vec<u8>, Vec<u8>);
 
-pub fn get_elements() -> color_eyre::Result<ReadResult> {
-    let mut pw = utils::password("Password: ", 8);
-    let (elements, key, salt) = read_from_file(&pw)?;
-    pw.zeroize();
+pub fn get_elements_from_input() -> color_eyre::Result<ReadResult> {
+    let pw = utils::password("Password: ", 8);
+    get_elements_with_password(pw)
+}
+
+pub fn get_elements_from_stdin() -> color_eyre::Result<ReadResult> {
+    if let Some(password) = io::stdin().lock().lines().next() {
+        return get_elements_with_password(password?);
+    }
+    Err(eyre!("Failure during stdin reading"))
+}
+
+fn get_elements_with_password(mut password: String) -> color_eyre::Result<ReadResult> {
+    let (elements, key, salt) = read_from_file(&password)?;
+    password.zeroize();
     Ok((elements, key, salt))
 }