Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

how to use AES256 ECB mode in Rust ?

  1. User

    how to use AES256 ECB mode in Rust ?

  2. Assistant

    To use AES256 in ECB (Electronic Code Book) mode in Rust, you will need a cryptographic library that provides AES encryption features. One popular crate for cryptography in Rust is rust-crypto, but this crate is no longer maintained. A more up-to-date and actively maintained crate you can use is aes from the RustCrypto project, together with the block-modes crate to implement the ECB mode.

    Here are the steps to use AES256 in ECB mode using the aes and block-modes crates:

    1. First, you should add the aes and block-modes crates to your Cargo.toml file:
    [dependencies]
    aes = "0.7"
    block-modes = "0.8"
    
    1. You can then use the AES256 with ECB mode as shown in the example below. Note that ECB mode is not recommended for use in security-critical applications due to its lack of security for messages longer than one block, which can lead to patterns being easily detectable in ciphertext:
    use aes::Aes256;
    use block_modes::{BlockMode, Ecb};
    use block_modes::block_padding::Pkcs7;
    
    // You may need to use a different crate name depending on when you add this to your dependencies
    use block_modes::block_padding::Pkcs7;
    
    // Create an alias for ECB mode with PKCS7 padding
    type Aes256Ecb = Ecb<Aes256, Pkcs7>;
    
    fn main() {
        // Your secret key and plaintext must be of the appropriate size.
        // For AES-256, the key size must be 32 bytes.
        let key = b"an example very very secret key."; // 32 bytes
        let plaintext = b"plaintext block 1plaintext block 2";
        
        // Create the block cipher instance using ECB mode and the given key
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
    
        // Encrypt the plaintext
        let ciphertext = cipher.encrypt_vec(plaintext);
    
        println!("Ciphertext: {:?}", ciphertext);
    
        // To decrypt, you will create another instance, typically in a different part of your application (or after transporting the ciphertext)
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        
        // Decrypt the ciphertext
        let decrypted_plaintext = cipher.decrypt_vec(&ciphertext).unwrap();
    
        println!("Decrypted plaintext: {:?}", std::str::from_utf8(&decrypted_plaintext).unwrap());
    }
    

    Be aware that you should never use a fixed or hard-coded key in a production environment. Always securely generate and manage keys. Furthermore, ECB mode should not be used for encrypting more than one block of data with the same key due to its vulnerability to pattern attacks, lack of diffusion, and issues with identical plaintext blocks producing identical ciphertext blocks. In practice, it's better to use a more secure block cipher mode like CBC (Cipher Block Chaining) or GCM (Galois/Counter Mode) which provide better security properties.

  3. User

    Nice. it works! Now consider this Python code. I need to convert it into equivalent code in Rust in same fashion -> from random import randint from Crypto.Util.number import getPrime, long_to_bytes as l2b from Crypto.Cipher import AES from Crypto.Util.Padding import pad, unpad from hashlib import sha256

    plaintext = b"Flag: HTB{fake_fl4g_4_test1ng}" aes_key = "" enc_secret = ""

    class AESGen: def init(self, size): key1 = randint(1 << size, 1 << (size+1)) key2 = randint(1 << size, 1 << (size+1)) self.k = key1 * key2

        print(key1)
        print(key2)
        print(f"k: {self.k}")
        assert 40 <= self.k.bit_length() <= 42
        self.KEY = sha256(str(self.k).encode()).digest()
        print(f"SHA256 KEY: {self.KEY}")
    
    def encrypt(self, m):
        cipher = AES.new(self.KEY, AES.MODE_ECB)
        enc_secret = cipher.encrypt(pad(m, 16))
        return enc_secret
    
    def decrypt(self, enc_m):
        cipher = AES.new(self.KEY, AES.MODE_ECB)
        dec_secret = unpad(cipher.decrypt(enc_m), 16)
        return dec_secret
    

    def main(): aes = AESGen(20) # enc_aes_key = l2b(rsa.encrypt(aes.k)) enc_secret = aes.encrypt(plaintext) enc_secret_hex = enc_secret.hex() print(f"Encrypted Secret = {enc_secret_hex}")

    try:
        # try to decrypt with the derived key
        decrypted = aes.decrypt(bytes.fromhex(enc_secret_hex))
    
        # Check if the decrypted message contains ‘HTB{’
        if b'HTB{' in decrypted:
            print(f"Decryption successful!")
            print(f"Decrypted FLAG: {decrypted}")
    except ValueError as e:
        print("Padding is incorrect, continue trying")
    

    if name == 'main': main()

  4. Assistant

    To convert the provided Python code to Rust, we'll need to perform several steps. The Python code is performing encryption using AES in ECB mode after generating a key derived from two random numbers.

    The equivalent Rust code will need to:

    1. Generate large random numbers like in the Python code.
    2. Multiply them to obtain the encryption key.
    3. Hash the key using SHA-256.
    4. Perform AES encryption and decryption in ECB mode.
    5. Pad and unpad the plaintext as needed.

    Below is the Rust version of the Python code:

    use aes::Aes256;
    use block_modes::{BlockMode, Ecb};
    use block_modes::block_padding::Pkcs7;
    use rand::Rng;
    use sha2::{Sha256, Digest};
    use std::convert::TryInto;
    
    type Aes256Ecb = Ecb<Aes256, Pkcs7>;
    
    fn main() {
        let mut rng = rand::thread_rng();
    
        let key1: u64 = rng.gen_range(1 << 20..1 << 21);
        let key2: u64 = rng.gen_range(1 << 20..1 << 21);
        let k = key1 * key2;
    
        println!("{}", key1);
        println!("{}", key2);
        println!("k: {}", k);
    
        let mut hasher = Sha256::new();
        hasher.update(k.to_string().as_bytes());
        let hashed_key = hasher.finalize();
    
        println!("SHA256 KEY: {:?}", hashed_key);
        let key: &[u8; 32] = hashed_key.as_slice().try_into().expect("slice with incorrect length");
    
        let plaintext = b"Flag: HTB{fake_fl4g_4_test1ng}";
    
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        let ciphertext = cipher.encrypt_vec(plaintext);
        println!("Encrypted Secret = {:?}", hex::encode(&ciphertext));
    
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        match cipher.decrypt_vec(&ciphertext) {
            Ok(decrypted) => {
                if decrypted.contains(&b"HTB{"[..]) {
                    println!("Decryption successful!");
                    println!("Decrypted FLAG: {:?}", String::from_utf8_lossy(&decrypted));
                }
            },
            Err(e) => println!("Decryption failed: {}", e),
        }
    }
    
    

    The Rust code above completes the equivalent operations to those in the Python code. However, please note the following points:

    • Use rand for randomness, which you need to include in Cargo.toml.
    • Use sha2 for the SHA-256 hashing algorithm, also needs to be included in Cargo.toml.
    • Unlike Python, which can handle arbitrarily large integers, in Rust, we are using u64, which should be sufficient for this example.
    • In Python, getPrime is available but not used in the given code. I've omitted it in the translation.
    • Padding and unpadding are handled by the block_modes crate.

    Make sure to add the necessary crates to your Cargo.toml as follows:

    [dependencies]
    aes = "0.7"
    block-modes = "0.8"
    rand = "0.8"
    sha2 = "0.9"
    hex = "0.4"
    

    Finally, remember to import necessary modules from rand and sha2 crates and any other missing functionality if you get compilation errors.

  5. User

    --> src/main.rs:37:35 | 37 | if decrypted.contains(&b"HTB{"[..]) { | -------- ^^^^^^^^^^^^ expected &u8, found &[u8] | | | arguments to this method are incorrect | = note: expected reference &u8 found reference &[u8]

  6. Assistant

    Apologies for the oversight. The contains method of a Vec<u8> expects a reference to a single byte as an argument (i.e., &u8), not a byte slice (&[u8]). Instead of using contains, you can use the windows method with any to search for a subslice. Here's the corrected code:

    use aes::Aes256;
    use block_modes::{BlockMode, Ecb};
    use block_modes::block_padding::Pkcs7;
    use rand::Rng;
    use sha2::{Sha256, Digest};
    use std::convert::TryInto;
    
    type Aes256Ecb = Ecb<Aes256, Pkcs7>;
    
    fn main() {
        let mut rng = rand::thread_rng();
    
        let key1: u64 = rng.gen_range(1 << 20..1 << 21);
        let key2: u64 = rng.gen_range(1 << 20..1 << 21);
        let k = key1 * key2;
    
        println!("{}", key1);
        println!("{}", key2);
        println!("k: {}", k);
    
        // Hash the key using SHA-256
        let mut hasher = Sha256::new();
        hasher.update(k.to_string().as_bytes());
        let hashed_key = hasher.finalize();
    
        println!("SHA256 KEY: {:?}", hashed_key);
        let key: &[u8; 32] = hashed_key.as_slice().try_into().expect("slice with incorrect length");
    
        // Encrypt the plaintext
        let plaintext = b"Flag: HTB{fake_fl4g_4_test1ng}";
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        let ciphertext = cipher.encrypt_vec(plaintext);
        
        println!("Encrypted Secret = {:?}", hex::encode(&ciphertext));
    
        // Decrypt the ciphertext
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        match cipher.decrypt_vec(&ciphertext) {
            Ok(decrypted) => {
                if decrypted.windows(b"HTB{".len()).any(|window| window == b"HTB{") {
                    println!("Decryption successful!");
                    println!("Decrypted FLAG: {:?}", String::from_utf8_lossy(&decrypted));
                } else {
                    println!("Decryption successful, but the flag pattern was not found!");
                }
            },
            Err(e) => println!("Decryption failed: {}", e),
        }
    }
    

    In this corrected code, we use the windows method to iterate over contiguous windows of the decrypted plaintext and then use any to check if any of those windows match the b"HTB{" byte pattern. This way, we search for a subslice within the Vec<u8>.

    Remember to also include the hex dependency in your Cargo.toml file, as shown in the previous message, to enable encoding the cipher text to hexadecimal representation.

  7. User

    Good ! Now i need to split decryption and encryption functions separetelly and call them when needed by same logic please

  8. Assistant

    Certainly! We can refactor the code into separate functions for encryption and decryption, and then use them in the main function. Below is the Rust code with the encryption and decryption logic split into encrypt_aes_ecb and decrypt_aes_ecb functions, respectively:

    use aes::Aes256;
    use block_modes::{BlockMode, Ecb};
    use block_modes::block_padding::Pkcs7;
    use rand::Rng;
    use sha2::{Sha256, Digest};
    use std::convert::TryInto;
    
    type Aes256Ecb = Ecb<Aes256, Pkcs7>;
    
    fn encrypt_aes_ecb(key: &[u8; 32], data: &[u8]) -> Vec<u8> {
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        cipher.encrypt_vec(data)
    }
    
    fn decrypt_aes_ecb(key: &[u8; 32], encrypted_data: &[u8]) -> Result<Vec<u8>, block_modes::BlockModeError> {
        let cipher = Aes256Ecb::new_from_slices(key, Default::default()).unwrap();
        cipher.decrypt_vec(encrypted_data)
    }
    
    fn main() {
        let mut rng = rand::thread_rng();
    
        let key1: u64 = rng.gen_range(1 << 20..1 << 21);
        let key2: u64 = rng.gen_range(1 << 20..1 << 21);
        let k = key1 * key2;
    
        println!("{}", key1);
        println!("{}", key2);
        println!("k: {}", k);
    
        let mut hasher = Sha256::new();
        hasher.update(k.to_string().as_bytes());
        let hashed_key = hasher.finalize();
        let key: &[u8; 32] = hashed_key.as_slice().try_into().expect("slice with incorrect length");
    
        println!("SHA256 KEY: {:?}", hashed_key);
    
        let plaintext = b"Flag: HTB{fake_fl4g_4_test1ng}";
        let ciphertext = encrypt_aes_ecb(key, plaintext);
    
        println!("Encrypted Secret = {:?}", hex::encode(&ciphertext));
    
        match decrypt_aes_ecb(key, &ciphertext) {
            Ok(decrypted) => {
                if decrypted.windows(b"HTB{".len()).any(|window| window == b"HTB{") {
                    println!("Decryption successful!");
                    println!("Decrypted FLAG: {:?}", String::from_utf8_lossy(&decrypted));
                } else {
                    println!("Decryption successful, but the flag pattern was not found!");
                }
            },
            Err(e) => println!("Decryption failed: {}", e),
        }
    }
    

    In this code, we have the following:

    • encrypt_aes_ecb: Function that takes a key and plaintext data, encrypts the data using AES-256 in ECB mode, and returns the ciphertext as a vector of bytes (Vec<u8>).
    • decrypt_aes_ecb: Function that takes a key and ciphertext, decrypts the ciphertext using AES-256 in ECB mode, and returns a result that could either be a Vec<u8> containing the decrypted plaintext or an error.

    Both encrypt_aes_ecb and decrypt_aes_ecb use Aes256Ecb::new_from_slices to create a cipher instance with the provided key. They then call encrypt_vec or decrypt_vec correspondingly to perform encryption and decryption.

    Now, in the main function, we generate the random keys, compute the SHA-256 hash, and call the encrypt_aes_ecb function to perform encryption. We then call the decrypt_aes_ecb function with the received ciphertext and handle the result, checking for the presence of the "HTB{" pattern in the decrypted data.

  9. User

    Super ! Now in the same fashion i need to convert this Python code into Rust please -> from Crypto.Cipher import AES from Crypto.Util.Padding import unpad from hashlib import sha256 import itertools import time import os import json

    Provided data

    n = 72741423208033405403492275698762968936514657314823442485453559870105200118330405900858299998747406127848670334407387228444029070060538220448699667905891284937839901536444798774307744865631349770845980738192442639071823803272283670943732769371979418893953521892212745135191661138195973757608889180051128601323 e = 65537 enc_aes_key = bytes.fromhex("4da0230d2b8b46e3a7065f32c46df019739cc002a208cc37767a82c3e94edfc3440fa4b24a32274e35d5ddceaa33505c4f2a57281c3a5d6d4db3a0dbdbb30dbf373241319ce4a7fdd1780b6bafc86e37d283c9f9787c567434e2fc29c988fb05fd411fe4453ea40eb45fc41a423839b485e238dd2530fba284e9b07a0bba6546") enc_secret = bytes.fromhex("ce8f36aa844ab00319bcd4f86460a10d77492c060b2c2a91615f4cd1f2d0702e76b68f1ec0f11d15704ba52c5dacc60018d5ed87368464acd030ce6230efdbff7b18cba72ccaa9455a6fe6021b908dd1")

    Function to save the state to a file

    def save_state(i, j, filename='state.json'): with open(filename, 'w') as f: json.dump({'i': i, 'j': j}, f)

    Function to load the state from a file

    def load_state(filename='state.json'): if os.path.exists(filename): with open(filename, 'r') as f: state = json.load(f) return state['i'], state['j'] return None, None

    Brute force 20-bit numbers

    start_range = 1 << 19

    end_range = 1 << 20

    start_range = 1 << 20 # This is 2^20, the smallest 20-bit number end_range = 1 << 21 # This is 2^21, the smallest 21-bit number (not part of the range itself) pause_interval = 15 * 60 # 15 minutes pause_duration = 30 # 5 seconds

    Check if there’s a saved state to resume from

    resume_i, resume_j = load_state()

    start_time = time.time() # Record the start time

    Adjust start values if resuming from a saved state

    i_start = resume_i if resume_i else start_range j_start = resume_j if resume_j else start_range

    try: # … (The brute-forcing loop) # Brute force 20-bit numbers #for i, j in itertools.product(range(start_range, end_range), repeat=2): for i, j in itertools.product(range(i_start, end_range), repeat=2): # If resuming, skip to the correct ‘j’ value if i == i_start and resume_j is not None: j_start = resume_j resume_j = None # Reset resume_j so this only happens once

        k = i * j
    
        # Check if it’s time to pause
        current_time = time.time()
        if current_time - start_time >= pause_interval:
            print("Pausing for a bit to chill the CPU…")
            save_state(i, j)  # Save the current state
            time.sleep(pause_duration)  # Pause for 5 seconds
            start_time = current_time  # Reset the start time
    
        # Check if product has between 40 and 42 bits
        if 40 <= k.bit_length() <= 42:
            key = sha256(str(k).encode()).digest()
            cipher = AES.new(key, AES.MODE_ECB)
            try:
                # try to decrypt with the derived key
                decrypted = unpad(cipher.decrypt(enc_secret), 16)
    
                print(f"Key1: {i}, Key2: {j} --> KEY product {k} !")
                print(f"Dec secret: {decrypted} ")
    
                # Check if the decrypted message contains ‘HTB{’
                if b'HTB{' in decrypted:
                    print(f"Decryption successful! AES key was found: k={k}")
                    print(f"Decrypted FLAG: {decrypted}")
                    break
            except ValueError as e:
                # Padding is incorrect, continue trying
                continue
    

    except KeyboardInterrupt: # When manual interruption occurs, save the current state save_state(i, j) print("Brute-forcing paused. State saved.") #finally: # Clean up code that must execute on exit # (e.g., potentially removing state file if loop finished)

  10. Assistant

    Converting the Python code into Rust involves implementing the brute-forcing logic while handling state persistence and timed execution pauses. Below is the equivalent Rust code that achieves the same goals:

    use aes::Aes256;
    use block_modes::{BlockMode, Ecb};
    use block_modes::block_padding::Pkcs7;
    use sha2::{Sha256, Digest};
    use std::fs;
    use std::time::{Duration, Instant};
    use std::{thread, io};
    
    type Aes256Ecb = Ecb<Aes256, Pkcs7>;
    
    #[derive(Debug, serde::Serialize, serde::Deserialize)]
    struct State {
        i: u64,
        j: u64,
    }
    
    fn save_state(state: &State, filename: &str) -> io::Result<()> {
        let state_json = serde_json::to_string(&state)?;
        fs::write(filename, state_json)?;
        Ok(())
    }
    
    fn load_state(filename: &str) -> io::Result<Option<State>> {
        if let Ok(state_json) = fs::read_to_string(filename) {
            let state: State = serde_json::from_str(&state_json)?;
            Ok(Some(state))
        } else {
            Ok(None)
        }
    }
    
    fn main() -> io::Result<()> {
        // Provided data
        let enc_secret = hex::decode("...").unwrap();
    
        const PAUSE_INTERVAL: Duration = Duration::from_secs(15 * 60); // 15 minutes
        const PAUSE_DURATION: Duration = Duration::from_secs(30); // 30 seconds
    
        let start_range = 1 << 20; // 2^20
        let end_range = 1 << 21; // 2^21
        let mut i_start = start_range;
        let mut j_start = start_range;
    
        // Load the state if it exists
        let state_filename = "state.json";
        if let Ok(Some(state)) = load_state(state_filename) {
            i_start = state.i;
            j_start = state.j;
        }
    
        let start_time = Instant::now();
    
        'outer: for i in i_start..end_range {
            for j in j_start..end_range {
                let k = i * j;
                // Check if product has between 40 and 42 bits (not strictly required in Rust)
                if (k.leading_zeros() as u64) >= (64 - 42) && (k.leading_zeros() as u64) <= (64 - 40) {
                    let key_material = k.to_string();
                    let mut hasher = Sha256::new();
                    hasher.update(key_material.as_bytes());
                    let key = hasher.finalize();
    
                    let key_slice: &[u8; 32] = key.as_slice().try_into().unwrap();
                    let cipher = Aes256Ecb::new_from_slices(key_slice, Default::default()).unwrap();
                    
                    if let Ok(decrypted) = cipher.decrypt_vec(&enc_secret) {
                        println!("Key1: {}, Key2: {} --> KEY product {} !", i, j, k);
                        println!("Dec secret: {:?}", std::str::from_utf8(&decrypted).unwrap());
    
                        if decrypted.windows(b"HTB{".len()).any(|window| window == b"HTB{") {
                            println!("Decryption successful! AES key was found: k={}", k);
                            println!("Decrypted FLAG: {:?}", std::str::from_utf8(&decrypted).unwrap());
                            break 'outer;
                        }
                    }
                }
    
                if start_time.elapsed() >= PAUSE_INTERVAL {
                    println!("Pausing for a bit to chill the CPU…");
                    save_state(&State { i, j }, state_filename)?;
                    thread::sleep(PAUSE_DURATION);
                }
            }
            j_start = start_range;  // Reset j start for the next iteration of i
        }
    
        Ok(())
    }
    

    Please make sure you've added the aes, block-modes, sha2, hex, serde and serde_json crates to your Cargo.toml:

    [dependencies]
    aes = "0.7"
    block-modes = "0.8"
    sha2 = "0.9"
    hex = "0.4"
    serde = { version = "1.0", features = ["derive"] }
    serde_json = "1.0"
    

    I've omitted the part where it saves the state upon KeyboardInterrupt as Rust does not provide a built-in mechanism for capturing Ctrl+C signals without depending on external libraries. However, you could use the ctrlc crate to handle clean-up if required.

    Additionally, the input enc_secret is truncated with "..." for brevity; you'll need to paste the full hex-encoded encrypted secret there. Rust's type system and borrow checker manage memory safety, so you do not need to check the actual bit length of the product k manually, as Rust's u64 ensures that it will be a 64-bit number.

    The above code should perform similarly to the Python version, applying the same brute-forcing approach, including pauses for cooling and the ability to resume from a saved state.

  11. User

    how to make this code concurrent and run on multiple cores of the CPU ??

  12. Assistant

    To make the brute force algorithm run concurrently in Rust, we can use threads or asynchronous programming. A simple way to utilize multiple CPU cores is to use the rayon crate, which provides a data parallelism library with a work-stealing scheduler. It is straightforward to use and can distribute work across threads efficiently.

    First, add the rayon crate to your Cargo.toml:

    [dependencies]
    rayon = "1.5"
    

    The main change we'll make is to convert the nested loop into parallel iterators using rayon. We'll also need to handle shared state correctly since we'll now have multiple threads trying to read and write at the same time.

    Here's an example of how you might refactor the Rust code to take advantage of multiple CPU cores using rayon:

    // Include other necessary use statements as before
    use rayon::prelude::*;
    
    // Define the structure and functions to handle state as before
    
    fn test_key(i: u64, j: u64, enc_secret: &[u8]) -> Option<(u64, u64, Vec<u8>)> {
        let k = i * j;
        // Check if product has between 40 and 42 bits (not strictly required in Rust)
        if (k.leading_zeros() as u64) >= (64 - 42) && (k.leading_zeros() as u64) <= (64 - 40) {
            let key_material = k.to_string();
            let mut hasher = Sha256::new();
            hasher.update(key_material.as_bytes());
            let key = hasher.finalize();
    
            let key_slice: &[u8; 32] = key.as_slice().try_into().unwrap();
            let cipher = Aes256Ecb::new_from_slices(key_slice, Default::default()).unwrap();
            
            if let Ok(decrypted) = cipher.decrypt_vec(enc_secret) {
                if decrypted.windows(b"HTB{".len()).any(|window| window == b"HTB{") {
                    return Some((i, j, decrypted));
                }
            }
        }
        None
    }
    
    fn main() -> io::Result<()> {
        // Initialize variables and load the state as before
    
        // Make a copy of enc_secret for the closure to capture
        let enc_secret_copy = enc_secret.clone();
    
        // Perform the brute force search in parallel
        let result = (i_start..end_range).into_par_iter().flat_map(|i| {
            (j_start..end_range).into_par_iter().filter_map(move |j| {
                test_key(i, j, &enc_secret_copy)
            })
        }).find_first(|_| true);
    
        match result {
            Some((i, j, decrypted)) => {
                println!("Decryption successful! Key1: {}, Key2: {}", i, j);
                println!("Decrypted FLAG: {:?}", std::str::from_utf8(&decrypted).unwrap());
            },
            None => println!("No valid key found."),
        }
    
        // Saving state and handling pauses will be more complex with parallel execution.
        // You might need to manage the shared state with Mutex or atomic operations.
    
        Ok(())
    }
    

    Here's what we did:

    • Converted the range iterations to parallel iterators using rayon's into_par_iter.
    • Used flat_map to process combinations of i and j in parallel.
    • Introduced a function test_key that does the testing for each key combination.
    • Used find_first with a lambda that always returns true to stop the iteration once any thread finds a valid decryption (it's analogous to a break in a regular loop). The behavior of find_first is to return the first result found by any thread, not necessarily the first one in the search order, which works for our use case since we're looking for any valid key.

    Please note that parallelizing the brute force can make managing state more complex. If you need to save the state frequently, you would have to set up a shared and mutable state protected by a Mutex, RwLock, or atomic operations, and decide on an appropriate strategy for pausing and resuming the search. This can introduce synchronization overhead and may affect the potential speedup gained from parallelism. It is often worth considering saving state at intervals or in response to a signal like SIGINT, using tools like the ctrlc crate.

    This implementation ignores the complexities mentioned above and assumes that you will run the brute forcing to completion without the need to pause or save the state. To fully implement these features in a parallel context, further design decisions and synchronization safeguards are needed.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.