diff --git a/apps/vault/tools/vaultbackup-rs/Cargo.toml b/apps/vault/tools/vaultbackup-rs/Cargo.toml index 2f75cbadf..e6e1740bd 100644 --- a/apps/vault/tools/vaultbackup-rs/Cargo.toml +++ b/apps/vault/tools/vaultbackup-rs/Cargo.toml @@ -14,3 +14,5 @@ hidapi = {version = "1.4.1", default_features = false} serde_json = "1.0.82" serde = {version = "1.0.138", features = ["derive"]} hex = "0.4.3" +clap = { version = "3.2.12", features = ["derive"] } +anyhow = "1.0.58" diff --git a/apps/vault/tools/vaultbackup-rs/src/main.rs b/apps/vault/tools/vaultbackup-rs/src/main.rs index 391fa30d8..9af764be1 100644 --- a/apps/vault/tools/vaultbackup-rs/src/main.rs +++ b/apps/vault/tools/vaultbackup-rs/src/main.rs @@ -1,47 +1,56 @@ -use argh::FromArgs; -use std::error::Error; +use anyhow::Result; +use clap::Parser; +use clap::Subcommand; -#[derive(FromArgs, PartialEq, Debug)] -#[argh(description = "A tool to backup/restore TOTP settings for the vault app via USB.")] -struct WithPositional { - #[argh(option)] - #[argh(description = "backup TOTP settings from device to file")] - backup: Option, - - #[argh(option)] - #[argh(description = "restore TOTP settings from file to device")] - restore: Option, +#[derive(Debug, Parser)] +#[clap(name = "vaultbackup")] +#[clap(about = "A backup/restore tool for the Precursor vault app.", long_about = None)] +struct CLI { + #[clap(subcommand)] + command: Commands, } -enum CLIAction { - Backup(String), - Restore(String), +#[derive(Debug, PartialEq, clap::ValueEnum, Clone)] +enum Target { + TOTP, + Password, } -impl TryInto for WithPositional { - type Error = ProgramError; - - fn try_into(self) -> Result { - if self.backup.is_some() && self.restore.is_some() { - return Err(ProgramError::CantBackupAndRestoreAtTheSameTime); +impl From<&Target> for backup::PayloadType { + fn from(t: &Target) -> backup::PayloadType { + match t { + Target::TOTP => backup::PayloadType::TOTP, + Target::Password => backup::PayloadType::Password, } - - if self.backup.is_some() { - return Ok(CLIAction::Backup(self.backup.unwrap())); - } - - if self.restore.is_some() { - return Ok(CLIAction::Restore(self.restore.unwrap())); - } - - panic!("impossible!") } } + +#[derive(Debug, PartialEq, clap::Args, Clone)] +struct SubcommandFields { + /// The target for which to run the action + #[clap(required = true, value_enum)] + target: Target, + + /// The path to read backup data from + #[clap(required = true, value_parser)] + path: String, +} + +#[derive(Debug, Subcommand)] +enum Commands { + /// Backup data from device + #[clap(arg_required_else_help = true)] + Backup(SubcommandFields), + + /// Restore data to device + #[clap(arg_required_else_help = true)] + Restore(SubcommandFields), +} + #[derive(Debug)] enum ProgramError { NoDevicesFound, - CantBackupAndRestoreAtTheSameTime, DeviceError(Vec), } @@ -49,9 +58,6 @@ impl std::fmt::Display for ProgramError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ProgramError::NoDevicesFound => write!(f, "no CTAP2 devices found"), - ProgramError::CantBackupAndRestoreAtTheSameTime => { - write!(f, "can't backup and restore at the same time") - } ProgramError::DeviceError(code) => write!(f, "device returned code {:?}", code), } } @@ -63,9 +69,8 @@ const OKAY_CANARY: &[u8] = &[0xca, 0xfe, 0xba, 0xbe]; const PRECURSOR_VENDOR_ID: u16 = 0x1209; const PRECURSOR_PRODUCT_ID: u16 = 0x3613; -fn main() -> Result<(), Box> { - let wp: WithPositional = argh::from_env(); - let argument: CLIAction = wp.try_into()?; +fn main() -> Result<()> { + let wp = CLI::parse(); let ha = hidapi::HidApi::new()?; let dl = ha.device_list(); @@ -79,27 +84,30 @@ fn main() -> Result<(), Box> { } if precursor.is_none() { - return Err(Box::new(ProgramError::NoDevicesFound)); + return Err(ProgramError::NoDevicesFound)?; } let device = ctaphid::Device::connect(&ha, precursor.unwrap())?; - match argument { - CLIAction::Backup(path) => { - let bd = device.vendor_command(ctaphid::command::VendorCommand::H42, &vec![])?; + match wp.command { + Commands::Backup(params) => { + let pt: backup::PayloadType = (¶ms.target).into(); + let ops: u8 = (&pt).into(); - let json = unmarshal_backup_data(bd)?; + let bd = device.vendor_command(ctaphid::command::VendorCommand::H42, &vec![ops])?; - std::fs::write(path, json)?; + let json = unmarshal_backup_data(bd, params.target)?; + + std::fs::write(params.path, json)?; Ok(()) - }, - CLIAction::Restore(path) => { - let hbf = read_human_backup_file(&path)?; + } + Commands::Restore(params) => { + let hbf = read_human_backup_file(¶ms.path, params.target)?; let vcres = device.vendor_command(ctaphid::command::VendorCommand::H41, &hbf)?; if vcres.ne(OKAY_CANARY) { - return Err(Box::new(ProgramError::DeviceError(vcres))); + return Err(ProgramError::DeviceError(vcres))?; } Ok(()) @@ -107,18 +115,40 @@ fn main() -> Result<(), Box> { } } -fn read_human_backup_file(path: &str) -> Result, Box> { +fn read_human_backup_file(path: &str, target: Target) -> Result> { let f = std::fs::File::open(path)?; - let backup_json: backup::TotpEntries = serde_json::from_reader(f)?; + match target { + Target::TOTP => { + let backup_json: backup::TotpEntries = serde_json::from_reader(f)?; - Ok(backup_json.bytes()) + let backup_object = backup::DataPacket::TOTP(backup_json); + + Ok(backup_object.into()) + } + Target::Password => { + let backup_json: backup::PasswordEntries = serde_json::from_reader(f)?; + + let backup_object = backup::DataPacket::Password(backup_json); + + Ok(backup_object.into()) + } + } } -fn unmarshal_backup_data(data: Vec) -> Result, Box> { +fn unmarshal_backup_data(data: Vec, target: Target) -> Result> { let raw_cbor = cbor::read(&data).unwrap(); - let data: backup::TotpEntries = raw_cbor.try_into()?; + match target { + Target::TOTP => { + let data: backup::TotpEntries = raw_cbor.try_into()?; - Ok(serde_json::ser::to_vec(&data).unwrap()) -} \ No newline at end of file + Ok(serde_json::ser::to_vec(&data).unwrap()) + } + Target::Password => { + let data: backup::PasswordEntries = raw_cbor.try_into()?; + + Ok(serde_json::ser::to_vec(&data).unwrap()) + } + } +}