i2p_vanity 0.3.0

A simple I2P vanity address generator
Documentation
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>) {
        // TODO: Better design...
        // Get cert length
        let cert_len = (&content[385..387][0] * 16 * 16 + content[385..387][1]) as usize;
        // Generate random padding
        // TODO: Padding length control.
        let mut random_padding: [u8; 80] = [0; 80];
        getrandom::fill(&mut random_padding).unwrap();
        let mut random_padding: Vec<u8> = Vec::from(random_padding);
        // Split things up into head, tail, etc.
        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);

        // TODO: Random starting value rather than 0?
        // Done, see below.
        // let mut padding_u128 = 0u128;

        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());
            }
            // If it is at U128::MAX, retry!
            // TODO: wrapping_add could be faster? It is impossible to calc all of them within meaningful time anyway.
            padding_u128 = padding_u128.checked_add(1).ok_or(VanityError::Retry)?;
            iter.fetch_add(1, Ordering::Relaxed);
        };
        // Combine 3 parts (head, padding and tail) together to produce the key.
        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
    }

    // Implementation of I2P’s ElGamal public-key encryption scheme over the 2048-bit MODP DH group.
    // Stolen from str4e!
    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 {};

            // Select a random integer k, 1 <= k <= p - 2
            let k = loop {
                let k = rng.gen_biguint(2048);
                if !k.is_zero() && k <= *ELGAMAL_PM2 {
                    break k;
                }
            };

            // γ = α^k mod p
            let gamma = ELGAMAL_G.modpow(&k, &ELGAMAL_P);

            (k, gamma)
        }

        pub fn generate() -> ([u8; 256], [u8; 256]) {
            // Select a random integer a, 1 <= a <= p - 2
            // Public key is α^a mod p
            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 => {
                    // warn!("Warning: dh_pub is zero!");
                    vec![0u8; len]
                }
                _ => {
                    // Smaller than needed
                    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)
        }
    }
}