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 = {version = "1.0.138", features = ["derive"]}
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 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<String>,
#[argh(option)]
#[argh(description = "restore TOTP settings from file to device")]
restore: Option<String>,
#[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<CLIAction> for WithPositional {
type Error = ProgramError;
fn try_into(self) -> Result<CLIAction, Self::Error> {
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<u8>),
}
@ -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<dyn Error>> {
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<dyn Error>> {
}
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 = (&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(())
},
CLIAction::Restore(path) => {
let hbf = read_human_backup_file(&path)?;
}
Commands::Restore(params) => {
let hbf = read_human_backup_file(&params.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<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 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 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())
}
}
}