pub mod verify {
use super::keygen;
use data_encoding::BASE32_NOPAD;
use getrandom;
use once_cell_regex::regex;
use sha2::{Digest, Sha256};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
pub enum VanityError {
Stop,
Retry,
}
pub fn vanity_gen(
regex_pattern: &str,
die: Arc<AtomicBool>,
iter: Arc<AtomicU64>,
) -> Result<(String, Vec<u8>), VanityError> {
verify(
split_things_up(keygen::generate_key()),
regex_pattern,
die,
iter,
)
}
fn split_things_up(content: Vec<u8>) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cert_len = (&content[385..387][0] * 16 * 16 + content[385..387][1]) as usize;
let mut random_padding: [u8; 80] = [0; 80];
getrandom::fill(&mut random_padding).unwrap();
let mut random_padding: Vec<u8> = Vec::from(random_padding);
let public_data = &content[..387 + cert_len];
let mut head: Vec<u8> = Vec::from(&public_data[..256]);
head.append(&mut random_padding);
let data_tail: Vec<u8> = Vec::from(&content[387 + cert_len..]);
let tail: Vec<u8> = Vec::from(&public_data[352..]);
(head, tail, data_tail)
}
fn verify(
data: (Vec<u8>, Vec<u8>, Vec<u8>),
regex_pattern: &str,
die: Arc<AtomicBool>,
iter: Arc<AtomicU64>,
) -> Result<(String, Vec<u8>), VanityError> {
let re = regex!(regex_pattern);
let (head, tail, data_tail) = data;
let mut head_hasher = Sha256::new();
head_hasher.update(&head);
let mut random_padding: [u8; 16] = [0; 16];
getrandom::fill(&mut random_padding).unwrap();
let mut padding_u128 = u128::from_ne_bytes(random_padding);
let (b32addr, padding) = loop {
if die.load(Ordering::Relaxed) {
return Err(VanityError::Stop);
}
let padding = padding_u128.to_le_bytes();
let mut main_hasher = head_hasher.clone();
main_hasher.update(padding);
main_hasher.update(&tail);
let result = main_hasher.finalize();
let b32addr = BASE32_NOPAD.encode(&result);
if re.is_match(&b32addr) {
break (b32addr, padding.to_vec());
}
padding_u128 = padding_u128.checked_add(1).ok_or(VanityError::Retry)?;
iter.fetch_add(1, Ordering::Relaxed);
};
let result: Vec<u8> = head
.iter()
.copied()
.chain(
padding
.iter()
.copied()
.chain(tail.iter().copied().chain(data_tail.iter().copied())),
)
.collect();
Ok((b32addr, result))
}
}
pub mod keygen {
pub fn generate_parts() -> ([u8; 256], [u8; 32], [u8; 256], [u8; 32]) {
let (priv_egl, pub_egl) = key_gen_elgamal::generate();
let (priv_25519, pub_25519) = key_gen_25519::generate();
(pub_egl, pub_25519, priv_egl, priv_25519)
}
pub fn generate_key() -> Vec<u8> {
use getrandom;
let (priv_egl, pub_egl) = key_gen_elgamal::generate();
let (priv_25519, pub_25519) = key_gen_25519::generate();
let mut padding: [u8; 96] = [0; 96];
getrandom::fill(&mut padding).unwrap();
let cert_info: [u8; 7] = [5, 0, 4, 0, 7, 0, 0];
let key: Vec<u8> = pub_egl
.iter()
.copied()
.chain(
padding.iter().copied().chain(
pub_25519.iter().copied().chain(
cert_info
.iter()
.copied()
.chain(priv_egl.iter().copied().chain(priv_25519.iter().copied())),
),
),
)
.collect();
key
}
mod key_gen_elgamal {
use std::sync::LazyLock;
use num_bigint::{BigUint, RandBigInt};
use num_traits::{
Num,
identities::{One, Zero},
};
use rand::rngs::OsRng;
use std::ops::Sub;
const RFC3526_2048BIT_MODP_GROUP: &str = "FFFFFFFF_FFFFFFFF_C90FDAA2_2168C234_C4C6628B_80DC1CD1\
29024E08_8A67CC74_020BBEA6_3B139B22_514A0879_8E3404DD\
EF9519B3_CD3A431B_302B0A6D_F25F1437_4FE1356D_6D51C245\
E485B576_625E7EC6_F44C42E9_A637ED6B_0BFF5CB6_F406B7ED\
EE386BFB_5A899FA5_AE9F2411_7C4B1FE6_49286651_ECE45B3D\
C2007CB8_A163BF05_98DA4836_1C55D39A_69163FA8_FD24CF5F\
83655D23_DCA3AD96_1C62F356_208552BB_9ED52907_7096966D\
670C354E_4ABC9804_F1746C08_CA18217C_32905E46_2E36CE3B\
E39E772C_180E8603_9B2783A2_EC07A28F_B5C55DF0_6F4C52C9\
DE2BCBF6_95581718_3995497C_EA956AE5_15D22618_98FA0510\
15728E5A_8AACAA68_FFFFFFFF_FFFFFFFF";
pub static ELGAMAL_G: LazyLock::<BigUint> =LazyLock::new(|| BigUint::parse_bytes(b"2", 10).unwrap());
pub static ELGAMAL_P: LazyLock::<BigUint> =
LazyLock::new(|| BigUint::from_str_radix(RFC3526_2048BIT_MODP_GROUP, 16).unwrap());
pub static ELGAMAL_PM1: LazyLock::<BigUint> = LazyLock::new(|| (&(*ELGAMAL_P)).sub(BigUint::one()));
pub static ELGAMAL_PM2: LazyLock::<BigUint> =LazyLock::new(|| (&(*ELGAMAL_PM1)).sub(BigUint::one()));
fn gen_gamma_k() -> (BigUint, BigUint) {
let mut rng = OsRng {};
let k = loop {
let k = rng.gen_biguint(2048);
if !k.is_zero() && k <= *ELGAMAL_PM2 {
break k;
}
};
let gamma = ELGAMAL_G.modpow(&k, &ELGAMAL_P);
(k, gamma)
}
pub fn generate() -> ([u8; 256], [u8; 256]) {
let (a, alpha_a) = gen_gamma_k();
let priv_key = {
let buf = rectify(&a, 256);
let mut x = [0u8; 256];
x.copy_from_slice(&buf[..]);
x
};
let pub_key = {
let buf = rectify(&alpha_a, 256);
let mut x = [0u8; 256];
x.copy_from_slice(&buf[..]);
x
};
(priv_key, pub_key)
}
fn rectify(bi: &BigUint, len: usize) -> Vec<u8> {
let mut b = bi.to_bytes_be();
match b.len() {
sz if sz == len => b,
sz if sz > len => panic!("key too big ({sz}) max is {len}"),
0 => {
vec![0u8; len]
}
_ => {
let mut ret = vec![0u8; len];
ret.truncate(len - b.len());
ret.append(&mut b);
ret
}
}
}
}
mod key_gen_25519 {
use ed25519_dalek::SigningKey;
use rand::rngs::OsRng;
pub fn generate() -> ([u8; 32], [u8; 32]) {
let mut csprng = OsRng {};
let ed25519_keypair = SigningKey::generate(&mut csprng);
let key_bytes = ed25519_keypair.to_keypair_bytes();
let mut private_key = [0u8; 32];
let mut public_key = [0u8; 32];
private_key.copy_from_slice(&key_bytes[..32]);
public_key.copy_from_slice(&key_bytes[32..]);
(private_key, public_key)
}
}
}