i2p_vanity 0.3.0

A simple I2P vanity address generator
Documentation
use i2p_vanity::verify::{VanityError, vanity_gen};

use std::fs::File;
use std::io::prelude::*;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, mpsc};
use std::thread;
use std::time::Duration;

use readable::{
    num::{Float, Unsigned},
    up::Htop,
};

use clap::Parser;
use figment::{
    Figment,
    providers::{Format, Serialized, Toml},
};
use serde_derive::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize, Parser)]
#[command(
    version,
    about,
    long_about = "A simple vanity address generator for I2P.\
                  The regex pattern is not validated and you have full control.\
                  Be aware of impossible ones!"
)]
struct CliArgs {
    /// A regex pattern. Only A-Z and 2-7 are allowed in I2P's base32
    #[arg(short, long)]
    #[serde(skip_serializing_if = "Option::is_none")]
    regex_pattern: Option<String>,

    /// Thread count. Defaults to `std::thread::available_parallelism()`
    #[arg(short, long)]
    #[serde(skip_serializing_if = "Option::is_none")]
    thread_count: Option<u32>,

    /// Number of keys to generate. Defaults to 0 (infinite generation)
    #[arg(short, long)]
    #[serde(skip_serializing_if = "Option::is_none")]
    numbers_needed: Option<u64>,

    /// Output folder for generated keys. Defaults to current working directory
    #[arg(short, long)]
    #[serde(skip_serializing_if = "Option::is_none")]
    location: Option<String>,

    /// Path to the config file. Defaults to `config.toml`
    #[arg(short, long)]
    #[serde(skip_serializing_if = "Option::is_none")]
    config: Option<PathBuf>,
}

#[derive(Debug, Deserialize)]
struct AppConfig {
    #[serde(default)]
    regex_pattern: String,
    #[serde(default = "default_thread_count")]
    thread_count: u32,
    #[serde(default = "default_number_needed")]
    numbers_needed: u64,
    #[serde(default = "default_location")]
    location: String,
}

fn default_number_needed() -> u64 {
    0
}

fn default_thread_count() -> u32 {
    std::thread::available_parallelism()
        .map(|n| n.get() as u32)
        .unwrap_or(1)
}

fn default_location() -> String {
    std::env::current_dir()
        .unwrap()
        .to_string_lossy()
        .into_owned()
}

fn main() {
    // Parse config.
    // Cli args will override toml ones.
    let args = CliArgs::parse();

    // Defaults to config.toml
    let config_path = args
        .config
        .as_deref()
        .unwrap_or_else(|| Path::new("config.toml"));

    let figment = Figment::new()
        .merge(Toml::file(config_path))
        .merge(Serialized::defaults(CliArgs::parse()));

    let app_config: AppConfig = figment.extract().unwrap_or_else(|err| {
        eprintln!("Failed to load configuration: {err}");
        std::process::exit(1);
    });

    if app_config.regex_pattern.is_empty() {
        eprintln!("A regex pattern is needed. Use --help to see how to use this program.");
        std::process::exit(1);
    }

    let regex_pattern = app_config.regex_pattern.to_uppercase();
    let thread_number = app_config.thread_count;
    let target_generate_count = app_config.numbers_needed;
    let location = std::fs::canonicalize(app_config.location).unwrap();
    eprintln!("Regex pattern: {regex_pattern}");
    eprintln!("Thread count: {thread_number}");

    let target_generate_string = target_generate_count.to_string();
    eprintln!(
        "Key gen count: {}",
        if target_generate_count == 0 {
            "infinite"
        } else {
            &target_generate_string
        }
    );

    std::mem::drop(target_generate_string);

    eprintln!("Key output location: {location:?}");

    let die = Arc::new(AtomicBool::new(false));
    let iter = Arc::new(AtomicU64::new(0));
    let generated_count = Arc::new(AtomicU64::new(0));
    let (tx, rx) = mpsc::channel();

    // Setup Ctrl+C handler
    ctrlc::set_handler({
        let die = die.clone();
        move || {
            die.store(true, Ordering::SeqCst);
        }
    })
    .expect("Error setting Ctrl-C handler");

    // Spawn worker threads
    let mut handles = Vec::new();
    for i in 0..thread_number {
        let l = location.clone();
        let r = regex_pattern.clone();
        let die_clone = die.clone();
        let iter_clone = iter.clone();
        let generated_count_clone = generated_count.clone();
        let tx_clone = tx.clone();
        let h = thread::spawn(move || {
            generate(
                i,
                &l,
                &r,
                die_clone,
                iter_clone,
                generated_count_clone,
                tx_clone,
            )
        });
        handles.push(h);
    }

    // Spawn writer thread
    let writer_handle = thread::spawn(move || {
        while let Ok((addr, data)) = rx.recv() {
            let path = Path::new(&addr);
            let display = path.display();
            let mut file = match File::create(path) {
                Err(e) => panic!("Couldn't create {display}: {e}"),
                Ok(f) => f,
            };
            if let Err(e) = file.write_all(&data) {
                panic!("Couldn't write to {display}: {e}");
            }
            eprintln!("\nSuccessfully wrote to {display}");
        }
    });

    // Monitor speed and handle exit
    let start = std::time::Instant::now();
    loop {
        thread::sleep(Duration::from_secs(1));
        if die.load(Ordering::Relaxed) {
            break;
        }
        let current = iter.load(Ordering::Relaxed);
        let found = generated_count.load(Ordering::Relaxed);
        let elapsed = start.elapsed().as_secs_f64();
        let speed = current as f64 / elapsed;
        eprint!(
            "\rTries: {:} | Speed: {:.2} keys/s | Found: {} | Elapsed: {}",
            Unsigned::from(current),
            Float::from(speed),
            Unsigned::from(found),
            Htop::from(&start.elapsed())
        );

        if target_generate_count != 0 && found >= target_generate_count {
            die.store(true, Ordering::SeqCst);
        }
        use std::io::stderr;
        stderr().flush().unwrap_or(());
    }
    // Join worker threads
    for h in handles {
        h.join().unwrap();
    }

    // Close the channel and join writer thread
    drop(tx);
    writer_handle.join().unwrap();
}

fn generate(
    _id: u32,
    location: &Path,
    regex_pattern: &str,
    die: Arc<AtomicBool>,
    iter: Arc<AtomicU64>,
    generated_count: Arc<AtomicU64>,
    sender: mpsc::Sender<(PathBuf, Vec<u8>)>,
) {
    loop {
        let result = vanity_gen(regex_pattern, die.clone(), iter.clone());
        match result {
            Ok((addr, data)) => {
                let filename = format!("{}.dat", addr.to_lowercase());
                let mut location = location.to_path_buf();
                location.push(filename);

                sender.send((location, data)).unwrap();
                iter.fetch_add(1, Ordering::Relaxed);
                generated_count.fetch_add(1, Ordering::Relaxed);
            }
            Err(e) => match e {
                VanityError::Stop => break,
                VanityError::Retry => continue,
            },
        }
    }
}