From 0cb96782eff543ae447088f3779e4206a1431167 Mon Sep 17 00:00:00 2001 From: ryan Date: Sat, 17 May 2025 16:02:34 -0400 Subject: [PATCH] all crates: `cargo fmt` --- crates/daemon/keyforkd-client/src/tests.rs | 90 +++++++++---------- crates/daemon/keyforkd/src/middleware.rs | 5 +- crates/daemon/keyforkd/src/service.rs | 18 ++-- crates/daemon/keyforkd/src/test_util.rs | 5 +- crates/derive/keyfork-derive-key/src/main.rs | 5 +- .../derive/keyfork-derive-openpgp/src/main.rs | 7 +- .../src/extended_key/private_key.rs | 17 ++-- crates/derive/keyfork-derive-util/src/lib.rs | 5 +- .../keyfork-derive-util/src/public_key.rs | 2 +- .../derive/keyfork-derive-util/src/tests.rs | 5 +- .../src/bin/keyfork-shard-combine-openpgp.rs | 6 +- .../src/bin/keyfork-shard-decrypt-openpgp.rs | 8 +- .../src/bin/keyfork-shard-remote.rs | 5 +- .../src/bin/keyfork-shard-split-openpgp.rs | 10 ++- crates/keyfork-shard/src/openpgp.rs | 8 +- crates/keyfork/src/clap_ext.rs | 2 +- crates/keyfork/src/cli/derive.rs | 9 +- crates/keyfork/src/cli/mnemonic.rs | 9 +- crates/keyfork/src/cli/mod.rs | 9 +- crates/keyfork/src/cli/provision/mod.rs | 5 +- crates/keyfork/src/cli/recover.rs | 8 +- crates/keyfork/src/cli/shard.rs | 13 ++- crates/keyfork/src/main.rs | 3 +- crates/qrcode/keyfork-qrcode/src/lib.rs | 1 - crates/qrcode/keyfork-zbar-sys/build.rs | 2 +- crates/qrcode/keyfork-zbar/src/image.rs | 7 +- .../qrcode/keyfork-zbar/src/image_scanner.rs | 5 +- crates/qrcode/keyfork-zbar/src/lib.rs | 2 +- crates/util/keyfork-bin/src/lib.rs | 18 ++-- .../src/bin/keyfork-mnemonic-from-seed.rs | 2 +- crates/util/keyfork-mnemonic/src/lib.rs | 6 +- crates/util/keyfork-prompt/src/terminal.rs | 16 ++-- crates/util/keyfork-prompt/src/validators.rs | 6 +- 33 files changed, 172 insertions(+), 147 deletions(-) diff --git a/crates/daemon/keyforkd-client/src/tests.rs b/crates/daemon/keyforkd-client/src/tests.rs index e0e2f8c..07ccb74 100644 --- a/crates/daemon/keyforkd-client/src/tests.rs +++ b/crates/daemon/keyforkd-client/src/tests.rs @@ -9,58 +9,58 @@ use std::{os::unix::net::UnixStream, str::FromStr}; fn secp256k1_test_suite() { use k256::SecretKey; - let tests = test_data() - .unwrap() - .remove("secp256k1") - .unwrap(); + let tests = test_data().unwrap().remove("secp256k1").unwrap(); for seed_test in tests { let seed = seed_test.seed; - run_test(&seed, move |socket_path| -> Result<(), Box> { - for test in seed_test.tests { - let socket = UnixStream::connect(socket_path).unwrap(); - let mut client = Client::new(socket); - let chain = DerivationPath::from_str(test.chain).unwrap(); - let chain_len = chain.len(); - if chain_len < 2 { - continue; - } - if chain.iter().take(2).any(|index| !index.is_hardened()) { - continue; - } - // Consistency check: ensure the server and the client can each derive the same - // key using an XPrv, for all but the last XPrv, which is verified after this - for i in 2..chain_len { - // FIXME: Keyfork will only allow one request per session + run_test( + &seed, + move |socket_path| -> Result<(), Box> { + for test in seed_test.tests { let socket = UnixStream::connect(socket_path).unwrap(); let mut client = Client::new(socket); - let path = DerivationPath::from_str(test.chain).unwrap(); - let left_path = path.inner()[..i] - .iter() - .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone())); - let right_path = path.inner()[i..] - .iter() - .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone())); - let xprv = dbg!(client.request_xprv::(&left_path)).unwrap(); - let derived_xprv = xprv.derive_path(&right_path).unwrap(); - let socket = UnixStream::connect(socket_path).unwrap(); - let mut client = Client::new(socket); - let keyforkd_xprv = client.request_xprv::(&path).unwrap(); - assert_eq!( - derived_xprv, keyforkd_xprv, - "{left_path} + {right_path} != {path}" + let chain = DerivationPath::from_str(test.chain).unwrap(); + let chain_len = chain.len(); + if chain_len < 2 { + continue; + } + if chain.iter().take(2).any(|index| !index.is_hardened()) { + continue; + } + // Consistency check: ensure the server and the client can each derive the same + // key using an XPrv, for all but the last XPrv, which is verified after this + for i in 2..chain_len { + // FIXME: Keyfork will only allow one request per session + let socket = UnixStream::connect(socket_path).unwrap(); + let mut client = Client::new(socket); + let path = DerivationPath::from_str(test.chain).unwrap(); + let left_path = path.inner()[..i] + .iter() + .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone())); + let right_path = path.inner()[i..] + .iter() + .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone())); + let xprv = dbg!(client.request_xprv::(&left_path)).unwrap(); + let derived_xprv = xprv.derive_path(&right_path).unwrap(); + let socket = UnixStream::connect(socket_path).unwrap(); + let mut client = Client::new(socket); + let keyforkd_xprv = client.request_xprv::(&path).unwrap(); + assert_eq!( + derived_xprv, keyforkd_xprv, + "{left_path} + {right_path} != {path}" + ); + } + let req = DerivationRequest::new( + DerivationAlgorithm::Secp256k1, + &DerivationPath::from_str(test.chain).unwrap(), ); + let response = + DerivationResponse::try_from(client.request(&req.into()).unwrap()).unwrap(); + assert_eq!(&response.data, test.private_key.as_slice()); } - let req = DerivationRequest::new( - DerivationAlgorithm::Secp256k1, - &DerivationPath::from_str(test.chain).unwrap(), - ); - let response = - DerivationResponse::try_from(client.request(&req.into()).unwrap()).unwrap(); - assert_eq!(&response.data, test.private_key.as_slice()); - } - Ok(()) - }) + Ok(()) + }, + ) .unwrap(); } } diff --git a/crates/daemon/keyforkd/src/middleware.rs b/crates/daemon/keyforkd/src/middleware.rs index 6cfa585..c86e2d7 100644 --- a/crates/daemon/keyforkd/src/middleware.rs +++ b/crates/daemon/keyforkd/src/middleware.rs @@ -162,6 +162,9 @@ mod tests { .call(content.clone()) .await .unwrap(); - assert_eq!(result, serialize(&Result::::Ok(test)).unwrap()); + assert_eq!( + result, + serialize(&Result::::Ok(test)).unwrap() + ); } } diff --git a/crates/daemon/keyforkd/src/service.rs b/crates/daemon/keyforkd/src/service.rs index d638471..1e3205f 100644 --- a/crates/daemon/keyforkd/src/service.rs +++ b/crates/daemon/keyforkd/src/service.rs @@ -39,7 +39,10 @@ impl Keyforkd { /// Create a new instance of Keyfork from a given seed. pub fn new(seed: Vec) -> Self { if seed.len() < 16 { - warn!("Entropy size is lower than 128 bits: {} bits.", seed.len() * 8); + warn!( + "Entropy size is lower than 128 bits: {} bits.", + seed.len() * 8 + ); } Self { seed: Arc::new(seed), @@ -77,11 +80,11 @@ impl Service for Keyforkd { .iter() .take(2) .enumerate() - .find(|(_, index)| { - !index.is_hardened() - }) + .find(|(_, index)| !index.is_hardened()) { - return Err(DerivationError::InvalidDerivationPath(i, unhardened_index.inner()).into()) + return Err( + DerivationError::InvalidDerivationPath(i, unhardened_index.inner()).into(), + ); } #[cfg(feature = "tracing")] @@ -111,10 +114,7 @@ mod tests { #[tokio::test] async fn properly_derives_secp256k1() { - let tests = test_data() - .unwrap() - .remove("secp256k1") - .unwrap(); + let tests = test_data().unwrap().remove("secp256k1").unwrap(); for per_seed in tests { let seed = &per_seed.seed; diff --git a/crates/daemon/keyforkd/src/test_util.rs b/crates/daemon/keyforkd/src/test_util.rs index c2af309..cebaaf2 100644 --- a/crates/daemon/keyforkd/src/test_util.rs +++ b/crates/daemon/keyforkd/src/test_util.rs @@ -90,7 +90,10 @@ where let service = ServiceBuilder::new() .layer(middleware::BincodeLayer::new()) .service(Keyforkd::new(seed.to_vec())); - server.run(service).await.expect(bug!("Unable to start service")); + server + .run(service) + .await + .expect(bug!("Unable to start service")); } }); diff --git a/crates/derive/keyfork-derive-key/src/main.rs b/crates/derive/keyfork-derive-key/src/main.rs index 4a0438f..ad041d4 100644 --- a/crates/derive/keyfork-derive-key/src/main.rs +++ b/crates/derive/keyfork-derive-key/src/main.rs @@ -46,7 +46,10 @@ fn run() -> Result<(), Box> { let mut client = Client::discover_socket()?; let request = DerivationRequest::new(algo, &path); let response = client.request(&request.into())?; - println!("{}", smex::encode(DerivationResponse::try_from(response)?.data)); + println!( + "{}", + smex::encode(DerivationResponse::try_from(response)?.data) + ); Ok(()) } diff --git a/crates/derive/keyfork-derive-openpgp/src/main.rs b/crates/derive/keyfork-derive-openpgp/src/main.rs index 6b3d544..4bc61d2 100644 --- a/crates/derive/keyfork-derive-openpgp/src/main.rs +++ b/crates/derive/keyfork-derive-openpgp/src/main.rs @@ -2,8 +2,8 @@ use std::{env, process::ExitCode, str::FromStr}; -use keyfork_derive_util::DerivationPath; use keyfork_derive_path_data::paths; +use keyfork_derive_util::DerivationPath; use keyforkd_client::Client; use ed25519_dalek::SigningKey; @@ -82,7 +82,10 @@ fn validate( let index = paths::OPENPGP.inner().first().unwrap(); let path = DerivationPath::from_str(path)?; - assert!(path.len() >= 2, "Expected path of at least m/{index}/account_id'"); + assert!( + path.len() >= 2, + "Expected path of at least m/{index}/account_id'" + ); let given_index = path.iter().next().expect("checked .len() above"); assert_eq!( diff --git a/crates/derive/keyfork-derive-util/src/extended_key/private_key.rs b/crates/derive/keyfork-derive-util/src/extended_key/private_key.rs index 5fa3b65..1ca905f 100644 --- a/crates/derive/keyfork-derive-util/src/extended_key/private_key.rs +++ b/crates/derive/keyfork-derive-util/src/extended_key/private_key.rs @@ -189,7 +189,10 @@ where } } - assert!(has_any_nonzero, bug!("hmac function returned all-zero master key")); + assert!( + has_any_nonzero, + bug!("hmac function returned all-zero master key") + ); Self::from_parts( private_key @@ -223,13 +226,11 @@ where /// ``` pub fn from_parts(key: &[u8; 32], depth: u8, chain_code: [u8; 32]) -> Result { match K::from_bytes(key) { - Ok(key) => { - Ok(Self { - private_key: key, - depth, - chain_code, - }) - } + Ok(key) => Ok(Self { + private_key: key, + depth, + chain_code, + }), Err(_) => Err(Error::InvalidKey), } } diff --git a/crates/derive/keyfork-derive-util/src/lib.rs b/crates/derive/keyfork-derive-util/src/lib.rs index ce2c1a7..b55b64e 100644 --- a/crates/derive/keyfork-derive-util/src/lib.rs +++ b/crates/derive/keyfork-derive-util/src/lib.rs @@ -17,7 +17,10 @@ pub mod public_key; mod tests; #[doc(inline)] -pub use crate::extended_key::{private_key::{ExtendedPrivateKey, Error as XPrvError, VariableLengthSeed}, public_key::{ExtendedPublicKey, Error as XPubError}}; +pub use crate::extended_key::{ + private_key::{Error as XPrvError, ExtendedPrivateKey, VariableLengthSeed}, + public_key::{Error as XPubError, ExtendedPublicKey}, +}; pub use crate::{ index::{DerivationIndex, Error as IndexError}, diff --git a/crates/derive/keyfork-derive-util/src/public_key.rs b/crates/derive/keyfork-derive-util/src/public_key.rs index 192fe70..23ae69c 100644 --- a/crates/derive/keyfork-derive-util/src/public_key.rs +++ b/crates/derive/keyfork-derive-util/src/public_key.rs @@ -110,7 +110,7 @@ impl PublicKey for k256::PublicKey { fn derive_child(&self, other: PrivateKeyBytes) -> Result { use k256::elliptic_curve::ScalarPrimitive; - use k256::{Secp256k1, Scalar}; + use k256::{Scalar, Secp256k1}; // Construct a scalar from bytes let scalar = ScalarPrimitive::::from_bytes(&other.into()); diff --git a/crates/derive/keyfork-derive-util/src/tests.rs b/crates/derive/keyfork-derive-util/src/tests.rs index 89f6799..aa1a087 100644 --- a/crates/derive/keyfork-derive-util/src/tests.rs +++ b/crates/derive/keyfork-derive-util/src/tests.rs @@ -13,10 +13,7 @@ use keyfork_slip10_test_data::{test_data, Test}; fn secp256k1() { use k256::SecretKey; - let tests = test_data() - .unwrap() - .remove("secp256k1") - .unwrap(); + let tests = test_data().unwrap().remove("secp256k1").unwrap(); for per_seed in tests { let seed = &per_seed.seed; diff --git a/crates/keyfork-shard/src/bin/keyfork-shard-combine-openpgp.rs b/crates/keyfork-shard/src/bin/keyfork-shard-combine-openpgp.rs index fcf559c..fdf407b 100644 --- a/crates/keyfork-shard/src/bin/keyfork-shard-combine-openpgp.rs +++ b/crates/keyfork-shard/src/bin/keyfork-shard-combine-openpgp.rs @@ -35,7 +35,11 @@ fn run() -> Result<()> { let openpgp = OpenPGP; let prompt_handler = default_handler()?; - let bytes = openpgp.decrypt_all_shards_to_secret(key_discovery.as_deref(), messages_file, prompt_handler)?; + let bytes = openpgp.decrypt_all_shards_to_secret( + key_discovery.as_deref(), + messages_file, + prompt_handler, + )?; print!("{}", smex::encode(bytes)); Ok(()) diff --git a/crates/keyfork-shard/src/bin/keyfork-shard-decrypt-openpgp.rs b/crates/keyfork-shard/src/bin/keyfork-shard-decrypt-openpgp.rs index a06f2fe..d01d163 100644 --- a/crates/keyfork-shard/src/bin/keyfork-shard-decrypt-openpgp.rs +++ b/crates/keyfork-shard/src/bin/keyfork-shard-decrypt-openpgp.rs @@ -8,7 +8,7 @@ use std::{ }; use keyfork_prompt::default_handler; -use keyfork_shard::{Format, openpgp::OpenPGP}; +use keyfork_shard::{openpgp::OpenPGP, Format}; type Result> = std::result::Result; @@ -35,7 +35,11 @@ fn run() -> Result<()> { let openpgp = OpenPGP; let prompt_handler = default_handler()?; - openpgp.decrypt_one_shard_for_transport(key_discovery.as_deref(), messages_file, prompt_handler)?; + openpgp.decrypt_one_shard_for_transport( + key_discovery.as_deref(), + messages_file, + prompt_handler, + )?; Ok(()) } diff --git a/crates/keyfork-shard/src/bin/keyfork-shard-remote.rs b/crates/keyfork-shard/src/bin/keyfork-shard-remote.rs index b1ce407..c9b1aa9 100644 --- a/crates/keyfork-shard/src/bin/keyfork-shard-remote.rs +++ b/crates/keyfork-shard/src/bin/keyfork-shard-remote.rs @@ -1,9 +1,6 @@ //! Combine OpenPGP shards using remote transport and output the hex-encoded secret. -use std::{ - env, - process::ExitCode, -}; +use std::{env, process::ExitCode}; use keyfork_shard::remote_decrypt; diff --git a/crates/keyfork-shard/src/bin/keyfork-shard-split-openpgp.rs b/crates/keyfork-shard/src/bin/keyfork-shard-split-openpgp.rs index 82765de..db4b113 100644 --- a/crates/keyfork-shard/src/bin/keyfork-shard-split-openpgp.rs +++ b/crates/keyfork-shard/src/bin/keyfork-shard-split-openpgp.rs @@ -2,7 +2,7 @@ use std::{env, path::PathBuf, process::ExitCode, str::FromStr}; -use keyfork_shard::{Format, openpgp::OpenPGP}; +use keyfork_shard::{openpgp::OpenPGP, Format}; #[derive(Clone, Debug)] enum Error { @@ -52,7 +52,13 @@ fn run() -> Result<()> { let openpgp = OpenPGP; - openpgp.shard_and_encrypt(threshold, max, &input, key_discovery.as_path(), std::io::stdout())?; + openpgp.shard_and_encrypt( + threshold, + max, + &input, + key_discovery.as_path(), + std::io::stdout(), + )?; Ok(()) } diff --git a/crates/keyfork-shard/src/openpgp.rs b/crates/keyfork-shard/src/openpgp.rs index cd917fc..b43f654 100644 --- a/crates/keyfork-shard/src/openpgp.rs +++ b/crates/keyfork-shard/src/openpgp.rs @@ -6,11 +6,12 @@ use std::{ collections::HashMap, io::{Read, Write}, path::Path, + rc::Rc, str::FromStr, sync::Mutex, - rc::Rc, }; +use blahaj::Share; use keyfork_bug::bug; use keyfork_derive_openpgp::{ derive_util::{DerivationPath, VariableLengthSeed}, @@ -25,7 +26,7 @@ use openpgp::{ stream::{DecryptionHelper, DecryptorBuilder, VerificationHelper}, Parse, }, - policy::{NullPolicy, StandardPolicy, Policy}, + policy::{NullPolicy, Policy, StandardPolicy}, serialize::{ stream::{ArbitraryWriter, Encryptor2, LiteralWriter, Message, Recipient, Signer}, Marshal, @@ -34,7 +35,6 @@ use openpgp::{ KeyID, PacketPile, }; pub use sequoia_openpgp as openpgp; -use blahaj::Share; mod keyring; use keyring::Keyring; @@ -238,7 +238,7 @@ impl OpenPGP { let policy = StandardPolicy::new(); let valid_cert = cert.with_policy(&policy, None).map_err(Error::Sequoia)?; if get_encryption_keys(&valid_cert).next().is_none() { - return Err(Error::NoValidKeys(valid_cert.keyid())) + return Err(Error::NoValidKeys(valid_cert.keyid())); } } Ok(certs.into_values().collect()) diff --git a/crates/keyfork/src/clap_ext.rs b/crates/keyfork/src/clap_ext.rs index 664f0eb..c9ab671 100644 --- a/crates/keyfork/src/clap_ext.rs +++ b/crates/keyfork/src/clap_ext.rs @@ -43,7 +43,7 @@ impl FromStr for Options { fn from_str(s: &str) -> Result { if s.is_empty() { - return Ok(Default::default()) + return Ok(Default::default()); } let values = s .split(',') diff --git a/crates/keyfork/src/cli/derive.rs b/crates/keyfork/src/cli/derive.rs index 19eabad..e161dc2 100644 --- a/crates/keyfork/src/cli/derive.rs +++ b/crates/keyfork/src/cli/derive.rs @@ -1,4 +1,4 @@ -use super::{Keyfork, create}; +use super::{create, Keyfork}; use clap::{Args, Parser, Subcommand, ValueEnum}; use std::{fmt::Display, io::Write, path::PathBuf}; @@ -141,10 +141,9 @@ impl Display for Slug { #[allow(clippy::redundant_at_rest_pattern)] match (self.0.inner() & (0b1 << 31)).to_be_bytes().as_slice() { [0, 0, 0, 0] => Ok(()), - [0, 0, 0, bytes @ ..] | [0, 0, bytes @ ..] | [0, bytes @ ..] | [bytes @ ..] => f - .write_str( - std::str::from_utf8(bytes).expect("slug constructed from non-utf8"), - ), + [0, 0, 0, bytes @ ..] | [0, 0, bytes @ ..] | [0, bytes @ ..] | [bytes @ ..] => { + f.write_str(std::str::from_utf8(bytes).expect("slug constructed from non-utf8")) + } } } } diff --git a/crates/keyfork/src/cli/mnemonic.rs b/crates/keyfork/src/cli/mnemonic.rs index fe6b87e..c589ecf 100644 --- a/crates/keyfork/src/cli/mnemonic.rs +++ b/crates/keyfork/src/cli/mnemonic.rs @@ -1,8 +1,7 @@ use super::{ create, derive::{self, Deriver}, - provision, - Keyfork, + provision, Keyfork, }; use crate::{clap_ext::*, config, openpgp_card::factory_reset_current_card}; use card_backend_pcsc::PcscBackend; @@ -20,7 +19,7 @@ use keyfork_derive_openpgp::{ openpgp::{ self, armor::{Kind, Writer}, - packet::{UserID, signature::SignatureBuilder}, + packet::{signature::SignatureBuilder, UserID}, policy::StandardPolicy, serialize::{ stream::{Encryptor2, LiteralWriter, Message, Recipient}, @@ -544,7 +543,9 @@ fn derive_key(seed: [u8; 64], index: u8) -> Result std::io::Result { - eprintln!("Writing derived key to: {path}", path=path.display()); + eprintln!("Writing derived key to: {path}", path = path.display()); std::fs::File::create(path) } @@ -96,12 +96,7 @@ impl KeyforkCommands { KeyforkCommands::Completion { shell } => { let mut command = Keyfork::command(); let command_name = command.get_name().to_string(); - clap_complete::generate( - *shell, - &mut command, - command_name, - &mut std::io::stdout(), - ); + clap_complete::generate(*shell, &mut command, command_name, &mut std::io::stdout()); } } Ok(()) diff --git a/crates/keyfork/src/cli/provision/mod.rs b/crates/keyfork/src/cli/provision/mod.rs index f077226..13738a1 100644 --- a/crates/keyfork/src/cli/provision/mod.rs +++ b/crates/keyfork/src/cli/provision/mod.rs @@ -94,7 +94,10 @@ impl Provisioner { impl ValueEnum for Provisioner { fn value_variants<'a>() -> &'a [Self] { - &[Self::OpenPGPCard(openpgp::OpenPGPCard), Self::Shard(openpgp::Shard)] + &[ + Self::OpenPGPCard(openpgp::OpenPGPCard), + Self::Shard(openpgp::Shard), + ] } fn to_possible_value(&self) -> Option { diff --git a/crates/keyfork/src/cli/recover.rs b/crates/keyfork/src/cli/recover.rs index 3df6044..32e2fbc 100644 --- a/crates/keyfork/src/cli/recover.rs +++ b/crates/keyfork/src/cli/recover.rs @@ -1,10 +1,10 @@ use super::Keyfork; use clap::{Parser, Subcommand}; -use std::path::PathBuf; use nix::{ sys::wait::waitpid, unistd::{fork, ForkResult}, }; +use std::path::PathBuf; use keyfork_mnemonic::{English, Mnemonic}; use keyfork_prompt::{ @@ -86,7 +86,7 @@ pub struct Recover { command: RecoverSubcommands, /// Daemonize the server once started, restoring control back to the shell. - #[arg(long, global=true)] + #[arg(long, global = true)] daemon: bool, } @@ -102,12 +102,12 @@ impl Recover { // wait for the child to die, so we don't exit prematurely waitpid(Some(child), None)?; return Ok(()); - }, + } ForkResult::Child => { if let ForkResult::Parent { .. } = unsafe { fork() }? { return Ok(()); } - }, + } } } tokio::runtime::Builder::new_multi_thread() diff --git a/crates/keyfork/src/cli/shard.rs b/crates/keyfork/src/cli/shard.rs index 8a85d8f..51948b4 100644 --- a/crates/keyfork/src/cli/shard.rs +++ b/crates/keyfork/src/cli/shard.rs @@ -109,14 +109,15 @@ impl ShardExec for OpenPGP { output: &mut impl Write, ) -> Result<(), Box> { use keyfork_derive_openpgp::openpgp::{ + armor::{Kind, Writer}, serialize::Marshal, - armor::{Writer, Kind}, }; let openpgp = keyfork_shard::openpgp::OpenPGP; let prompt = default_handler()?; - let (threshold, certs) = openpgp.decrypt_metadata_from_file(key_discovery, input, prompt)?; + let (threshold, certs) = + openpgp.decrypt_metadata_from_file(key_discovery, input, prompt)?; let mut writer = Writer::new(output_pubkeys, Kind::PublicKey)?; for cert in certs { cert.serialize(&mut writer)?; @@ -187,7 +188,7 @@ pub enum ShardSubcommands { /// The path to discover private keys from. key_discovery: Option, - } + }, } impl ShardSubcommands { @@ -256,7 +257,11 @@ impl ShardSubcommands { None => panic!("{COULD_NOT_DETERMINE_FORMAT}"), } } - ShardSubcommands::Metadata { shardfile, output_pubkeys, key_discovery } => { + ShardSubcommands::Metadata { + shardfile, + output_pubkeys, + key_discovery, + } => { let shard_content = std::fs::read_to_string(shardfile)?; if shard_content.contains("BEGIN PGP MESSAGE") { let _ = format.insert(Format::OpenPGP(OpenPGP)); diff --git a/crates/keyfork/src/main.rs b/crates/keyfork/src/main.rs index 63847bc..e5e015c 100644 --- a/crates/keyfork/src/main.rs +++ b/crates/keyfork/src/main.rs @@ -1,5 +1,4 @@ #![doc = include_str!("../README.md")] - #![allow(clippy::module_name_repetitions)] use std::process::ExitCode; @@ -8,9 +7,9 @@ use clap::Parser; use keyfork_bin::{Bin, ClosureBin}; +pub mod clap_ext; mod cli; mod config; -pub mod clap_ext; mod openpgp_card; fn main() -> ExitCode { diff --git a/crates/qrcode/keyfork-qrcode/src/lib.rs b/crates/qrcode/keyfork-qrcode/src/lib.rs index a8d1b7d..c70e62e 100644 --- a/crates/qrcode/keyfork-qrcode/src/lib.rs +++ b/crates/qrcode/keyfork-qrcode/src/lib.rs @@ -171,7 +171,6 @@ fn dbg_elapsed(count: u64, instant: Instant) { let framerate = count as f64 / elapsed as f64; eprintln!("framerate: {count}/{elapsed} = {framerate}"); std::thread::sleep(std::time::Duration::from_secs(5)); - } #[derive(Debug)] diff --git a/crates/qrcode/keyfork-zbar-sys/build.rs b/crates/qrcode/keyfork-zbar-sys/build.rs index 9bbea87..828ea13 100644 --- a/crates/qrcode/keyfork-zbar-sys/build.rs +++ b/crates/qrcode/keyfork-zbar-sys/build.rs @@ -45,7 +45,7 @@ fn main() -> Result<()> { if let Err(e) = generate_bindings_file() { eprintln!("Building zbar-sys failed: {e}"); eprintln!("Ensure zbar headers, libclang, and pkg-config are installed"); - return Err(e) + return Err(e); } Ok(()) diff --git a/crates/qrcode/keyfork-zbar/src/image.rs b/crates/qrcode/keyfork-zbar/src/image.rs index f3cc55d..2a2b6bc 100644 --- a/crates/qrcode/keyfork-zbar/src/image.rs +++ b/crates/qrcode/keyfork-zbar/src/image.rs @@ -43,12 +43,7 @@ impl Image { /// Accepts raw data in the configured format. See: [`Image::set_format`] fn set_data(&mut self, data: Vec) { unsafe { - sys::zbar_image_set_data( - self.inner, - data.as_ptr().cast(), - data.len() as u64, - None, - ) + sys::zbar_image_set_data(self.inner, data.as_ptr().cast(), data.len() as u64, None) } // keep data in self to avoid use after free when data goes out of scope let _ = self.inner_data.insert(data); diff --git a/crates/qrcode/keyfork-zbar/src/image_scanner.rs b/crates/qrcode/keyfork-zbar/src/image_scanner.rs index 8504cad..1c4663a 100644 --- a/crates/qrcode/keyfork-zbar/src/image_scanner.rs +++ b/crates/qrcode/keyfork-zbar/src/image_scanner.rs @@ -58,10 +58,7 @@ impl ImageScanner { /// Link: [`sys::zbar_scan_image`] /// /// TODO: return an iterator over scanned values - pub fn scan_image( - &mut self, - image: &Image, - ) -> Vec { + pub fn scan_image(&mut self, image: &Image) -> Vec { unsafe { sys::zbar_scan_image(self.inner, image.inner) }; let mut result = vec![]; let mut symbol = unsafe { sys::zbar_image_first_symbol(image.inner) }; diff --git a/crates/qrcode/keyfork-zbar/src/lib.rs b/crates/qrcode/keyfork-zbar/src/lib.rs index e89b4db..0458629 100644 --- a/crates/qrcode/keyfork-zbar/src/lib.rs +++ b/crates/qrcode/keyfork-zbar/src/lib.rs @@ -11,6 +11,6 @@ pub use sys::zbar_config_e as Config; pub use sys::zbar_modifier_e as Modifier; pub use sys::zbar_orientation_e as Orientation; -pub mod image_scanner; pub mod image; +pub mod image_scanner; pub mod symbol; diff --git a/crates/util/keyfork-bin/src/lib.rs b/crates/util/keyfork-bin/src/lib.rs index 53cce50..765eded 100644 --- a/crates/util/keyfork-bin/src/lib.rs +++ b/crates/util/keyfork-bin/src/lib.rs @@ -68,7 +68,7 @@ pub trait Bin { #[allow(clippy::missing_errors_doc)] fn validate_args(&self, args: impl Iterator) -> ProcessResult; - /// Run the binary + /// Run the binary #[allow(clippy::missing_errors_doc)] fn run(&self, args: Self::Args) -> ProcessResult; @@ -102,10 +102,13 @@ pub trait Bin { /// A Bin that doesn't take any arguments. pub struct ClosureBin ProcessResult> { - closure: F + closure: F, } -impl ClosureBin where F: Fn() -> ProcessResult { +impl ClosureBin +where + F: Fn() -> ProcessResult, +{ /// Create a new Bin from a closure. /// /// # Examples @@ -120,13 +123,14 @@ impl ClosureBin where F: Fn() -> ProcessResult { /// bin.main(); /// ``` pub fn new(closure: F) -> Self { - Self { - closure - } + Self { closure } } } -impl Bin for ClosureBin where F: Fn() -> ProcessResult { +impl Bin for ClosureBin +where + F: Fn() -> ProcessResult, +{ type Args = (); fn validate_args(&self, _args: impl Iterator) -> ProcessResult { diff --git a/crates/util/keyfork-mnemonic/src/bin/keyfork-mnemonic-from-seed.rs b/crates/util/keyfork-mnemonic/src/bin/keyfork-mnemonic-from-seed.rs index 67d6aef..2a5825c 100644 --- a/crates/util/keyfork-mnemonic/src/bin/keyfork-mnemonic-from-seed.rs +++ b/crates/util/keyfork-mnemonic/src/bin/keyfork-mnemonic-from-seed.rs @@ -8,7 +8,7 @@ fn main() -> Result<(), Box> { input.read_line(&mut line)?; let decoded = smex::decode(line.trim())?; - let mnemonic = Mnemonic::from_raw_bytes(&decoded) ; + let mnemonic = Mnemonic::from_raw_bytes(&decoded); println!("{mnemonic}"); diff --git a/crates/util/keyfork-mnemonic/src/lib.rs b/crates/util/keyfork-mnemonic/src/lib.rs index 112524a..077688c 100644 --- a/crates/util/keyfork-mnemonic/src/lib.rs +++ b/crates/util/keyfork-mnemonic/src/lib.rs @@ -114,7 +114,9 @@ impl Wordlist for English { let mut words = wordlist_file.lines().skip(1).map(|x| x.trim().to_string()); English { words: std::array::from_fn(|_| { - words.next().expect(bug!("wordlist {} should have 2048 words")) + words + .next() + .expect(bug!("wordlist {} should have 2048 words")) }), } }) @@ -283,7 +285,7 @@ where return Err(MnemonicGenerationError::InvalidByteLength(bit_count)); } - Ok( Self::from_raw_bytes(bytes) ) + Ok(Self::from_raw_bytes(bytes)) } /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data may be of a size diff --git a/crates/util/keyfork-prompt/src/terminal.rs b/crates/util/keyfork-prompt/src/terminal.rs index cc1229d..648f383 100644 --- a/crates/util/keyfork-prompt/src/terminal.rs +++ b/crates/util/keyfork-prompt/src/terminal.rs @@ -148,7 +148,9 @@ where .queue(cursor::MoveTo(0, 0)) .expect(bug!("can't move to origin")); } - self.write.flush().expect(bug!("can't execute terminal reset commands")); + self.write + .flush() + .expect(bug!("can't execute terminal reset commands")); } } @@ -349,12 +351,14 @@ where KeyCode::Left | KeyCode::Up => { active_choice = active_choice.saturating_sub(1); } - KeyCode::Right | KeyCode::Down => match choices.len().saturating_sub(active_choice) { - 0 | 1 => {} - _ => { - active_choice += 1; + KeyCode::Right | KeyCode::Down => { + match choices.len().saturating_sub(active_choice) { + 0 | 1 => {} + _ => { + active_choice += 1; + } } - }, + } KeyCode::Enter => { return Ok(active_choice); } diff --git a/crates/util/keyfork-prompt/src/validators.rs b/crates/util/keyfork-prompt/src/validators.rs index d5a516f..589ab47 100644 --- a/crates/util/keyfork-prompt/src/validators.rs +++ b/crates/util/keyfork-prompt/src/validators.rs @@ -87,9 +87,7 @@ impl Validator for SecurePinValidator { if !range.contains(&ch) { return Err(Box::new(PinError::InvalidCharacters(ch, index))); } - if [-1, 1].contains(&(ch as i32 - last_char)) - && !ignore_sequential_characters - { + if [-1, 1].contains(&(ch as i32 - last_char)) && !ignore_sequential_characters { score += 1; } last_char = ch as i32; @@ -102,7 +100,7 @@ impl Validator for SecurePinValidator { score += s.chars().count() - chars.len(); } if score * 2 > s.chars().count() { - return Err(Box::new(PinError::InsecurePIN)) + return Err(Box::new(PinError::InsecurePIN)); } Ok(s) })