feat(vault): better cli experience, provide backup/restore of passwords

as well
This commit is contained in:
Gianguido Sorà 2022-07-19 16:45:39 +02:00
parent 23f9717fee
commit dfd11ba5df
2 changed files with 87 additions and 55 deletions

View file

@ -14,3 +14,5 @@ hidapi = {version = "1.4.1", default_features = false}
serde_json = "1.0.82" serde_json = "1.0.82"
serde = {version = "1.0.138", features = ["derive"]} serde = {version = "1.0.138", features = ["derive"]}
hex = "0.4.3" hex = "0.4.3"
clap = { version = "3.2.12", features = ["derive"] }
anyhow = "1.0.58"

View file

@ -1,47 +1,56 @@
use argh::FromArgs; use anyhow::Result;
use std::error::Error; use clap::Parser;
use clap::Subcommand;
#[derive(FromArgs, PartialEq, Debug)] #[derive(Debug, Parser)]
#[argh(description = "A tool to backup/restore TOTP settings for the vault app via USB.")] #[clap(name = "vaultbackup")]
struct WithPositional { #[clap(about = "A backup/restore tool for the Precursor vault app.", long_about = None)]
#[argh(option)] struct CLI {
#[argh(description = "backup TOTP settings from device to file")] #[clap(subcommand)]
backup: Option<String>, command: Commands,
#[argh(option)]
#[argh(description = "restore TOTP settings from file to device")]
restore: Option<String>,
} }
enum CLIAction { #[derive(Debug, PartialEq, clap::ValueEnum, Clone)]
Backup(String), enum Target {
Restore(String), TOTP,
Password,
} }
impl TryInto<CLIAction> for WithPositional { impl From<&Target> for backup::PayloadType {
type Error = ProgramError; fn from(t: &Target) -> backup::PayloadType {
match t {
fn try_into(self) -> Result<CLIAction, Self::Error> { Target::TOTP => backup::PayloadType::TOTP,
if self.backup.is_some() && self.restore.is_some() { Target::Password => backup::PayloadType::Password,
return Err(ProgramError::CantBackupAndRestoreAtTheSameTime);
} }
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)] #[derive(Debug)]
enum ProgramError { enum ProgramError {
NoDevicesFound, NoDevicesFound,
CantBackupAndRestoreAtTheSameTime,
DeviceError(Vec<u8>), DeviceError(Vec<u8>),
} }
@ -49,9 +58,6 @@ impl std::fmt::Display for ProgramError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { match self {
ProgramError::NoDevicesFound => write!(f, "no CTAP2 devices found"), 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), 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_VENDOR_ID: u16 = 0x1209;
const PRECURSOR_PRODUCT_ID: u16 = 0x3613; const PRECURSOR_PRODUCT_ID: u16 = 0x3613;
fn main() -> Result<(), Box<dyn Error>> { fn main() -> Result<()> {
let wp: WithPositional = argh::from_env(); let wp = CLI::parse();
let argument: CLIAction = wp.try_into()?;
let ha = hidapi::HidApi::new()?; let ha = hidapi::HidApi::new()?;
let dl = ha.device_list(); let dl = ha.device_list();
@ -79,27 +84,30 @@ fn main() -> Result<(), Box<dyn Error>> {
} }
if precursor.is_none() { if precursor.is_none() {
return Err(Box::new(ProgramError::NoDevicesFound)); return Err(ProgramError::NoDevicesFound)?;
} }
let device = ctaphid::Device::connect(&ha, precursor.unwrap())?; let device = ctaphid::Device::connect(&ha, precursor.unwrap())?;
match argument { match wp.command {
CLIAction::Backup(path) => { Commands::Backup(params) => {
let bd = device.vendor_command(ctaphid::command::VendorCommand::H42, &vec![])?; let pt: backup::PayloadType = (&params.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(()) Ok(())
}, }
CLIAction::Restore(path) => { Commands::Restore(params) => {
let hbf = read_human_backup_file(&path)?; let hbf = read_human_backup_file(&params.path, params.target)?;
let vcres = device.vendor_command(ctaphid::command::VendorCommand::H41, &hbf)?; let vcres = device.vendor_command(ctaphid::command::VendorCommand::H41, &hbf)?;
if vcres.ne(OKAY_CANARY) { if vcres.ne(OKAY_CANARY) {
return Err(Box::new(ProgramError::DeviceError(vcres))); return Err(ProgramError::DeviceError(vcres))?;
} }
Ok(()) Ok(())
@ -107,18 +115,40 @@ fn main() -> Result<(), Box<dyn Error>> {
} }
} }
fn read_human_backup_file(path: &str) -> Result<Vec<u8>, Box<dyn Error>> { fn read_human_backup_file(path: &str, target: Target) -> Result<Vec<u8>> {
let f = std::fs::File::open(path)?; 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<u8>) -> Result<Vec<u8>, Box<dyn Error>> { fn unmarshal_backup_data(data: Vec<u8>, target: Target) -> Result<Vec<u8>> {
let raw_cbor = cbor::read(&data).unwrap(); 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()) 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())
}
}
}