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 {
#[arg(short, long)]
#[serde(skip_serializing_if = "Option::is_none")]
regex_pattern: Option<String>,
#[arg(short, long)]
#[serde(skip_serializing_if = "Option::is_none")]
thread_count: Option<u32>,
#[arg(short, long)]
#[serde(skip_serializing_if = "Option::is_none")]
numbers_needed: Option<u64>,
#[arg(short, long)]
#[serde(skip_serializing_if = "Option::is_none")]
location: Option<String>,
#[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() {
let args = CliArgs::parse();
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();
ctrlc::set_handler({
let die = die.clone();
move || {
die.store(true, Ordering::SeqCst);
}
})
.expect("Error setting Ctrl-C handler");
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);
}
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}");
}
});
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(());
}
for h in handles {
h.join().unwrap();
}
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,
},
}
}
}