From 9a219d8abad8aa00a9adface40b8bdb3da082c70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gianguido=20Sor=C3=A0?= Date: Sat, 13 Aug 2022 17:39:37 +0200 Subject: [PATCH 1/3] chore(vault): add default for PasswordEntries --- apps/vault/libraries/backup/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/vault/libraries/backup/src/lib.rs b/apps/vault/libraries/backup/src/lib.rs index 4888fc4e5..3afc1ee79 100644 --- a/apps/vault/libraries/backup/src/lib.rs +++ b/apps/vault/libraries/backup/src/lib.rs @@ -202,7 +202,7 @@ impl TryFrom for PasswordEntry { type Error = CborConversionError; } -#[derive(Serialize, Deserialize)] +#[derive(Serialize, Deserialize, Default)] pub struct PasswordEntries(pub Vec); impl From<&PasswordEntries> for cbor::Value { From 1defdff9153f7a86071ac6ee256bcc95ac23bc73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gianguido=20Sor=C3=A0?= Date: Sat, 13 Aug 2022 17:40:02 +0200 Subject: [PATCH 2/3] chore(vault): add serde_repr for vaultbackup-rs --- Cargo.lock | 12 ++++++++++++ apps/vault/tools/vaultbackup-rs/Cargo.toml | 1 + 2 files changed, 13 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index af888aa3e..e06f332b1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3291,6 +3291,17 @@ dependencies = [ "serde", ] +[[package]] +name = "serde_repr" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fe39d9fbb0ebf5eb2c7cb7e2a47e4f462fad1379f1166b8ae49ad9eae89a7ca" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "serde_with" version = "1.14.0" @@ -4201,6 +4212,7 @@ dependencies = [ "log", "serde", "serde_json", + "serde_repr", ] [[package]] diff --git a/apps/vault/tools/vaultbackup-rs/Cargo.toml b/apps/vault/tools/vaultbackup-rs/Cargo.toml index 8b94b5616..4a0840903 100644 --- a/apps/vault/tools/vaultbackup-rs/Cargo.toml +++ b/apps/vault/tools/vaultbackup-rs/Cargo.toml @@ -18,3 +18,4 @@ clap = { version = "3.2.12", features = ["derive"] } anyhow = "1.0.58" log = "0.4.17" env_logger = "0.9.0" +serde_repr = "0.1.9" From 5acb0af82be98b6bba9944e0dc9566bfd479f40f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gianguido=20Sor=C3=A0?= Date: Sat, 13 Aug 2022 17:40:25 +0200 Subject: [PATCH 3/3] feat(vault): support Bitwarden export formatting for Vault Allows folks with Bitwarden data to (mostly) import it in Vault, both passwords and TOTPs. --- apps/vault/tools/vaultbackup-rs/README.md | 16 +++ .../tools/vaultbackup-rs/src/bitwarden.rs | 123 ++++++++++++++++++ apps/vault/tools/vaultbackup-rs/src/main.rs | 103 ++++++++++++++- 3 files changed, 235 insertions(+), 7 deletions(-) create mode 100644 apps/vault/tools/vaultbackup-rs/src/bitwarden.rs 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);