chore: release version 0.4.1

- set meaningful value names for options
- add backticks around CLI options in user-facing messages

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fingerprunk"
-version = "0.3.0"
+version = "0.4.1"
 authors = ["Niklas Elsbrock <mail@nelsbrock.de>"]
 edition = "2024"
 description = "CLI tool for brute-forcing OpenPGP keys with cool fingerprints"
@@ -13,8 +13,7 @@ categories = ["command-line-utilities"]
 anyhow = "1.0.102"
 clap = { version = "4.6.1", features = ["derive"] }
 ctrlc = "3.5.2"
-fancy-regex = "0.18.0"
+fancy-regex = "0.19.2"
 num-integer = "0.1.46"
-num_cpus = "1.17.0"
 rpassword = "7.5.2"
-sequoia-openpgp = "2.2.0"
+sequoia-openpgp = "2.3.0"

src/lib.rs

@@ -3,7 +3,7 @@
 use std::{
     fmt::{self, Write},
     io,
-    num::NonZeroU64,
+    num::NonZero,
     sync::{
         atomic::{AtomicBool, AtomicU64, Ordering},
         mpsc,
@@ -38,9 +38,10 @@ enum Message {
 pub struct Config {
     pub regex: Regex,
     pub status_enabled: bool,
-    pub stop_after: Option<NonZeroU64>,
+    pub count: Option<NonZero<u64>>,
     pub password: Option<Password>,
     pub userids: Vec<UserID>,
+    pub workers: NonZero<usize>,
 }
 
 #[derive(Debug)]
@@ -83,24 +84,20 @@ impl Fingerprunk {
         }
 
         thread::scope(|scope| {
-            let ref_self = &self;
-
             let status_displayer = if self.config.status_enabled {
                 Some(
                     thread::Builder::new()
                         .name("status_displayer".to_string())
-                        .spawn_scoped(scope, move || ref_self.status_displayer_thread())?,
+                        .spawn_scoped(scope, || self.status_displayer_thread())?,
                 )
             } else {
                 None
             };
 
-            for num in 0..num_cpus::get() {
+            for num in 0..self.config.workers.get() {
-                let sender = sender.clone();
-
                 thread::Builder::new()
                     .name(format!("worker-{num:03}"))
-                    .spawn_scoped(scope, move || ref_self.worker_thread(sender))?;
+                    .spawn_scoped(scope, || self.worker_thread(&sender))?;
             }
 
             let mut stdout = io::stdout().lock();
@@ -109,12 +106,12 @@ impl Fingerprunk {
             for message in receiver {
                 match message {
                     Message::Key(key) => {
-                        let cert = self.key_to_cert(&key)?;
+                        let cert = self.key_to_cert(key)?;
-                        self.serialize_cert(cert, &mut stdout)?;
+                        self.serialize_cert(&cert, &mut stdout)?;
 
                         // Increase "found" counter and stop if enough matches have been found
                         let prev = self.counter_found.fetch_add(1, Ordering::Relaxed);
-                        if self.config.stop_after.is_some_and(|s| prev + 1 == s.get()) {
+                        if self.config.count.is_some_and(|s| prev + 1 == s.get()) {
                             break;
                         }
                     }
@@ -134,7 +131,7 @@ impl Fingerprunk {
         })
     }
 
-    fn worker_thread(&self, sender: mpsc::SyncSender<Message>) {
+    fn worker_thread(&self, sender: &mpsc::SyncSender<Message>) {
         let mut fingerprint_hex = String::with_capacity(20 * 2);
 
         while !self.stop.load(Ordering::Relaxed) {
@@ -160,7 +157,7 @@ impl Fingerprunk {
             .expect("should check regex without error")
     }
 
-    fn key_to_cert(&self, key: &SecretKey) -> anyhow::Result<Cert> {
+    fn key_to_cert(&self, mut key: SecretKey) -> anyhow::Result<Cert> {
         let creation_time = SystemTime::now();
 
         let mut signer = key
@@ -174,7 +171,6 @@ impl Fingerprunk {
 
         // Create certificate
         let mut cert = Cert::try_from(Packet::SecretKey({
-            let mut key = key.clone();
             if let Some(ref password) = self.config.password {
                 let (k, mut secret) = key.take_secret();
                 secret.encrypt_in_place(&k, password)?;
@@ -204,7 +200,7 @@ impl Fingerprunk {
         Ok(cert)
     }
 
-    fn serialize_cert(&self, cert: Cert, to: impl io::Write) -> anyhow::Result<()> {
+    fn serialize_cert(&self, cert: &Cert, to: impl io::Write) -> anyhow::Result<()> {
         let mut comments = cert.armor_headers();
         comments.push(format!(
             "Generated with Fingerprunk. Regex: {}",

src/main.rs

@@ -1,9 +1,9 @@
 use std::{
     io::{self, IsTerminal},
-    num::NonZeroU64,
+    num::NonZero,
 };
 
-use anyhow::{Context as AnyhowContext, anyhow};
+use anyhow::{Context, anyhow};
 use clap::{ArgAction, Parser, ValueEnum};
 use fancy_regex::Regex;
 use fingerprunk::Fingerprunk;
@@ -14,8 +14,8 @@ use sequoia_openpgp::packet::UserID;
 struct Args {
     /// Filter key fingerprints by using a regular expression.
     ///
-    /// This regex is matched against the hexadecimal representation of the fingerprint, without
+    /// This regex is matched against the upper-case hexadecimal representation of the fingerprint,
-    /// spaces or other additional symbols.
+    /// without spaces or other additional symbols.
     ///
     /// This is implemented using the fancy-regex library: <https://crates.io/crates/fancy-regex>.
     /// You can test and debug your regex here: <https://fancy-regex.github.io/fancy-regex/>.
@@ -27,12 +27,12 @@ struct Args {
     /// By default, status information is only shown if stderr is bound to a terminal and stdout is
     /// *not* bound to a terminal. The latter in particular prevents found keys (which are printed
     /// to stdin) from being "overwritten" by status information printed to stderr.
-    #[arg(long, value_enum, default_value_t)]
+    #[arg(long, value_enum, value_name = "WHEN", default_value_t)]
     status: StatusEnabled,
 
     /// Stop once the specified number of matching keys has been found.
-    #[arg(long)]
+    #[arg(short = 'n', long, value_name = "NUM")]
-    stop_after: Option<NonZeroU64>,
+    count: Option<NonZero<u64>>,
 
     /// Prompt for a password and use it to encrypt matching keys.
     ///
@@ -50,6 +50,13 @@ struct Args {
     /// Disables the warning about importing keys without user IDs into GnuPG.
     #[arg(long, conflicts_with = "userid", action = ArgAction::SetTrue)]
     no_userid: bool,
+
+    /// Use the specified amount of worker threads.
+    ///
+    /// If not specified, the amount of worker threads will be set to the amount of the machine's
+    /// available parallelism.
+    #[arg(long, value_name = "NUM")]
+    workers: Option<NonZero<usize>>,
 }
 
 #[derive(ValueEnum, Clone, Copy, Debug, Default)]
@@ -73,24 +80,33 @@ impl StatusEnabled {
 fn main() -> anyhow::Result<()> {
     let args = Args::parse();
 
+    let workers = match args.workers {
+        Some(workers) => workers,
+        None => std::thread::available_parallelism().context(
+            "unable to determine available parallelism, \
+            use `--workers <NUM>` to specify amount of worker threads",
+        )?,
+    };
+
     if !args.no_userid && args.userid.is_empty() {
         eprintln!(
             "WARNING: No user ID was provided.\n\
             You may experience problems importing generated keys into GnuPG.\n\
-            Use the --userid option to add a user ID.\n"
+            Use `--userid <USERID>` to add a user ID.\n"
-        )
+        );
     }
 
     let password = if args.password {
         let password = rpassword::prompt_password(
             "Enter password for encrypting found keys (leave empty for no encryption): ",
         )
-        .with_context(|| "Failed to prompt password")?;
+        .context("Failed to prompt password")?;
+
         if password.is_empty() {
             None
         } else {
             let password_retype = rpassword::prompt_password("Retype password: ")
-                .with_context(|| "Failed to prompt password retype")?;
+                .context("Failed to prompt password retype")?;
             if password_retype == password {
                 Some(password.into())
             } else {
@@ -104,12 +120,11 @@ fn main() -> anyhow::Result<()> {
     let config = fingerprunk::Config {
         regex: args.regex,
         status_enabled: args.status.evaluate(),
-        stop_after: args.stop_after,
+        count: args.count,
         password,
         userids: args.userid,
+        workers,
     };
 
-    Fingerprunk::new_from_config(config).run()?;
+    Fingerprunk::new_from_config(config).run()
-
-    Ok(())
 }