103 lines
2.8 KiB
Rust
103 lines
2.8 KiB
Rust
use std::{
|
|
fs::OpenOptions,
|
|
io::Write,
|
|
pin::Pin,
|
|
thread::{spawn, JoinHandle},
|
|
time::Duration,
|
|
};
|
|
|
|
mod cpu;
|
|
pub type Key = [u8; 32];
|
|
|
|
struct ProgressCounter(pub *mut u64);
|
|
unsafe impl Send for ProgressCounter {}
|
|
unsafe impl Sync for ProgressCounter {}
|
|
impl ProgressCounter {
|
|
fn incr(&mut self, n: u64) {
|
|
unsafe {
|
|
*self.0 += n;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn work(mut progress: ProgressCounter) -> JoinHandle<()> {
|
|
spawn(move || {
|
|
let mut rng = {
|
|
use rand::SeedableRng;
|
|
rand_xoshiro::Xoshiro256StarStar::from_rng(rand::thread_rng()).unwrap()
|
|
};
|
|
|
|
const ITERS: u64 = 256;
|
|
|
|
loop {
|
|
for _ in 0..ITERS {
|
|
let key = cpu::generate_privkey(&mut rng);
|
|
let pub_key = cpu::get_pubkey(&key);
|
|
|
|
// b64(pub_key).starts_with("char") && b64(pub_key)[4] in ["+", "/"]
|
|
if pub_key[0] == 0x72
|
|
&& pub_key[1] == 0x16
|
|
&& pub_key[2] == 0xab
|
|
&& pub_key[3] >= 0xf8
|
|
{
|
|
let key_str = base64::encode(key);
|
|
let pub_key_str = base64::encode(pub_key);
|
|
println!("{} -> {}", key_str, pub_key_str);
|
|
|
|
{
|
|
let mut file = OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open("keys.log")
|
|
.unwrap();
|
|
|
|
let _ = writeln!(file, "{} -> {}", key_str, pub_key_str);
|
|
}
|
|
}
|
|
}
|
|
|
|
progress.incr(ITERS);
|
|
}
|
|
})
|
|
}
|
|
|
|
const NUM_THREADS: usize = 24;
|
|
|
|
struct Progress(Pin<Box<[u64; NUM_THREADS]>>);
|
|
impl Progress {
|
|
fn new() -> Self {
|
|
Progress(Box::pin([0; NUM_THREADS]))
|
|
}
|
|
|
|
unsafe fn the_pointer(&mut self) -> *mut u64 {
|
|
self.0.as_mut_ptr()
|
|
}
|
|
|
|
fn total(&self) -> u64 {
|
|
self.0.iter().sum()
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let mut progress = Progress::new();
|
|
let _handles: Vec<_> = (0..NUM_THREADS)
|
|
.map(|id| {
|
|
let ptr = unsafe { progress.the_pointer().add(id) };
|
|
let progress = ProgressCounter(ptr);
|
|
work(progress)
|
|
})
|
|
.collect();
|
|
|
|
let mut last_total_progress = 0;
|
|
let mut sleep_secs = 1.0;
|
|
loop {
|
|
let total_progress = progress.total();
|
|
let delta = total_progress - last_total_progress;
|
|
last_total_progress = total_progress;
|
|
|
|
println!("Guesses/sec ≈ {:.0}", delta as f64 / sleep_secs);
|
|
std::thread::sleep(Duration::from_secs_f64(sleep_secs));
|
|
sleep_secs *= 1.05;
|
|
}
|
|
}
|