diff --git a/apps/vault/tools/vaultbackup-rs/README.md b/apps/vault/tools/vaultbackup-rs/README.md index 4950d0809..389869034 100644 --- a/apps/vault/tools/vaultbackup-rs/README.md +++ b/apps/vault/tools/vaultbackup-rs/README.md @@ -44,6 +44,7 @@ OPTIONS: SUBCOMMANDS: backup Backup data from device + format Format a known password manager export for Vault help Print this message or the help of the given subcommand(s) restore Restore data to device ``` @@ -64,3 +65,18 @@ vaultbackup-rs `PATH` specifies the path where `vaultbackup-rs` reads/writes data. The output format is JSON. + +## Importing other password manager's exports + +`vaultbackup-rs` supports importing other password manager's export data in Vault, but to do so, you have to format it to Vault's format first. + +The `subcommand` does this for you. + +Supported password managers: + - Bitwarden: TOTP, logins + +Example: + +```bash +$ vaultbackup-rs format bitwarden your-bitwarden-export.json +``` diff --git a/apps/vault/tools/vaultbackup-rs/src/bitwarden.rs b/apps/vault/tools/vaultbackup-rs/src/bitwarden.rs new file mode 100644 index 000000000..90c030ff2 --- /dev/null +++ b/apps/vault/tools/vaultbackup-rs/src/bitwarden.rs @@ -0,0 +1,123 @@ +use serde::{Deserialize, Serialize}; +use serde_json; +use serde_repr::{Deserialize_repr, Serialize_repr}; + +#[derive(Serialize_repr, Debug, Deserialize_repr, PartialEq)] +#[repr(u8)] +pub enum EntryType { + Login = 1, + SecureNote = 2, + Card = 3, + Identity = 4, +} + +#[derive(Serialize, Debug, Deserialize)] +pub struct Entry { + #[serde(rename = "type")] + pub entry_type: EntryType, + pub name: String, + pub login: Option, + pub notes: Option, +} + +#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Login { + pub username: Option, + pub password: Option, + pub totp: Option, +} + +#[derive(Debug)] +pub enum LoginSanificationError { + BadUsername, + BadPassword, +} + +impl std::fmt::Display for LoginSanificationError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::BadUsername => write!(f, "bad username format"), + Self::BadPassword => write!(f, "bad password format"), + } + } +} + +impl std::error::Error for LoginSanificationError {} + +impl Login { + pub fn sane(&self) -> Result<(), LoginSanificationError> { + if self.username.is_none() { + return Err(LoginSanificationError::BadUsername); + } else { + if self.username.as_ref().unwrap_or(&String::new()).is_empty() { + return Err(LoginSanificationError::BadUsername); + } + } + + if self.password.is_none() { + return Err(LoginSanificationError::BadPassword); + } else { + if self.password.as_ref().unwrap_or(&String::new()).is_empty() { + return Err(LoginSanificationError::BadPassword); + } + } + + Ok(()) + } +} + +#[derive(Serialize, Deserialize, Debug)] +pub struct Items { + pub items: Vec, +} + +impl Items { + pub fn logins(&self) -> Vec<&Entry> { + let ret: Vec<&Entry> = self + .items + .iter() + .filter(|element| element.entry_type == EntryType::Login && element.login.is_some()) + .collect(); + ret + } +} + +#[derive(Debug)] +pub enum FormatError { + SerdeError(serde_json::Error), +} + +impl std::fmt::Display for FormatError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::SerdeError(err) => write!(f, "bitwarden deserialization error, {:?}", err), + } + } +} + +impl std::error::Error for FormatError {} + +impl From for FormatError { + fn from(e: serde_json::Error) -> FormatError { + FormatError::SerdeError(e) + } +} + +impl TryFrom> for Items { + type Error = FormatError; + + fn try_from(data: Vec) -> Result { + let ret: Items = serde_json::from_slice(&data)?; + Ok(ret) + } +} + +impl TryFrom for Items { + type Error = FormatError; + + fn try_from(data: std::fs::File) -> Result { + let ret: Items = serde_json::from_reader(data)?; + Ok(ret) + } +} diff --git a/apps/vault/tools/vaultbackup-rs/src/main.rs b/apps/vault/tools/vaultbackup-rs/src/main.rs index 600bd53e5..69df300c8 100644 --- a/apps/vault/tools/vaultbackup-rs/src/main.rs +++ b/apps/vault/tools/vaultbackup-rs/src/main.rs @@ -1,8 +1,8 @@ -use std::time::Instant; - +mod bitwarden; use anyhow::Result; use clap::Parser; use clap::Subcommand; +use std::time::Instant; #[derive(Debug, Parser)] #[clap(name = "vaultbackup")] @@ -38,6 +38,22 @@ struct SubcommandFields { path: String, } +#[derive(Debug, PartialEq, clap::ValueEnum, Clone)] +enum FormatTargets { + Bitwarden, +} + +#[derive(Debug, PartialEq, clap::Args, Clone)] +struct FormatFields { + /// The target for which to run the action + #[clap(required = true, value_enum)] + target: FormatTargets, + + /// The path to read input data from + #[clap(required = true, value_parser)] + path: String, +} + #[derive(Debug, Subcommand)] enum Commands { /// Backup data from device @@ -47,6 +63,10 @@ enum Commands { /// Restore data to device #[clap(arg_required_else_help = true)] Restore(SubcommandFields), + + /// Format a known password manager export for Vault. + #[clap(arg_required_else_help = true)] + Format(FormatFields), } #[derive(Debug)] @@ -69,10 +89,7 @@ impl std::error::Error for ProgramError {} const PRECURSOR_VENDOR_ID: u16 = 0x1209; const PRECURSOR_PRODUCT_ID: u16 = 0x3613; -fn main() -> Result<()> { - env_logger::init(); - let wp = CLI::parse(); - +fn open_precursor() -> Result { let ha = hidapi::HidApi::new()?; let dl = ha.device_list(); @@ -95,10 +112,81 @@ fn main() -> Result<()> { device.vendor_command(ctaphid::command::VendorCommand::H44, &vec![])?; log::debug!("sent session reset command"); + Ok(device) +} + +fn main() -> Result<()> { + env_logger::init(); + let wp = CLI::parse(); + let start = Instant::now(); match wp.command { + Commands::Format(params) => { + let f = std::fs::File::open(params.path)?; + + match params.target { + FormatTargets::Bitwarden => { + let items = bitwarden::Items::try_from(f)?; + let items = items.logins(); + + let mut passwords = backup::PasswordEntries::default(); + let mut totps = backup::TotpEntries::default(); + + for (idx, item) in items.into_iter().enumerate() { + let mut pw = backup::PasswordEntry::default(); + let login = item.login.as_ref().unwrap(); + + match login.sane() { + Ok(()) => (), + Err(err) => { + log::error!("entry {} is invalid: {}", idx, err); + continue + } + } + + pw.password = login.password.as_ref().unwrap().clone(); + pw.username = login.username.as_ref().unwrap().clone(); + pw.description = item.name.clone(); + pw.notes = item.notes.as_ref().unwrap_or(&String::new()).clone(); + + passwords.0.push(pw); + + if login.totp.is_some() { + let totp = login.totp.as_ref().unwrap(); + + let mut t = backup::TotpEntry::default(); + t.name = item.name.clone(); + t.algorithm = backup::HashAlgorithms::SHA256; + t.digit_count = 6; + t.step_seconds = 30; + t.shared_secret = totp + .strip_prefix("otpauth://totp/") + .unwrap_or(&totp) + .to_string(); + + totps.0.push(t); + } + } + + std::fs::write( + "bitwarden_to_vault_passwords.json", + serde_json::ser::to_vec(&passwords)?, + )?; + + if totps.0.len() > 0 { + std::fs::write( + "bitwarden_to_vault_totps.json", + serde_json::ser::to_vec(&totps)?, + )?; + } + + Ok(()) + } + } + } Commands::Backup(params) => { + let device = open_precursor()?; log::info!("receiving data..."); let bd = { let mut data = vec![]; @@ -141,13 +229,14 @@ fn main() -> Result<()> { data }; - let json = unmarshal_backup_data( bd)?; + let json = unmarshal_backup_data(bd)?; std::fs::write(params.path, json)?; log::info!("done! elapsed: {:?}", start.elapsed()); Ok(()) } Commands::Restore(params) => { + let device = open_precursor()?; log::info!("sending data..."); let hbf = read_human_backup_file(¶ms.path, params.target)?; let chunks: backup::Wires = backup::Wires::from(hbf);