appsec/src/bin/client.rs

use crypto_box::{
    aead::{Aead, AeadCore, OsRng},
    PublicKey, SalsaBox, SecretKey,
};
use std::io::Write;
use std::net::TcpStream;

fn main() {
    let port: u32 = 7878; // Port Server
                          //let stream = TcpStream::connect("172.30.16.1:8080");
                          //let stream = TcpStream::connect("27.0.0.1:8080");
    match TcpStream::connect(format!("localhost:{}", port)) {
        Ok(mut stream) => {
            println!("Successfully connected to server");

            let bob_init_pub_key = PublicKey::from([
                0xe8, 0x98, 0xc, 0x86, 0xe0, 0x32, 0xf1, 0xeb, 0x29, 0x75, 0x5, 0x2e, 0x8d, 0x65,
                0xbd, 0xdd, 0x15, 0xc3, 0xb5, 0x96, 0x41, 0x17, 0x4e, 0xc9, 0x67, 0x8a, 0x53, 0x78,
                0x9d, 0x92, 0xc7, 0x54,
            ]);
            let (salsa_box, pub_key) = generate_box(bob_init_pub_key.clone());

            loop {
                let mut buffer = String::new();
                match std::io::stdin().read_line(&mut buffer) {
                    Ok(n) => {
                        if n == 0 {
                            break; // Beenden bei EOF
                        }
                        //
                        // Encryption
                        //

                        // Get a random nonce to encrypt the message under
                        let nonce = SalsaBox::generate_nonce(&mut OsRng);

                        // Message to encrypt
                        let plaintext = buffer.trim().as_bytes();

                        // Encrypt the message using the box
                        let ciphertext = salsa_box.encrypt(&nonce, &plaintext[..]).expect("Fehler");

                        println!("Sending {0} as {1:?}", buffer.trim(), plaintext);
                        stream.write(buffer.as_bytes()).unwrap();

                        //
                        // Decryption
                        //

                        // Decrypt the message, using the same randomly generated nonce
                        let decrypted_plaintext =
                            salsa_box.decrypt(&nonce, &ciphertext[..]).expect("Fehler");
                        let dec_plain_plaintext =
                            std::str::from_utf8(&*decrypted_plaintext).expect("Nö");
                        assert_eq!(&plaintext[..], &decrypted_plaintext[..]);

                        println!(
                            "Sent {0:?} as cypher: {1:?}, decrypted: {2:?}, {3}",
                            plaintext, ciphertext, decrypted_plaintext, dec_plain_plaintext
                        );
                    }
                    Err(error) => {
                        println!("error: {error}");
                        break;
                    }
                }
            }
        }
        Err(e) => {
            println!("Failed to connect: {}", e);
        }
    }
    println!("Terminated.");
}

fn generate_box(partner_public_key: PublicKey) -> (SalsaBox, PublicKey) {
    // Generate a random secret key.
    // NOTE: The secret key bytes can be accessed by calling `secret_key.as_bytes()`
    let own_secret_key = SecretKey::generate(&mut OsRng);

    // Get the public key for the secret key we just generated
    let own_public_key = own_secret_key.public_key().clone();

    // Create a `SalsaBox` by performing Diffie-Hellman key agreement between
    // the two keys.
    let salsa_box = SalsaBox::new(&partner_public_key, &own_secret_key);
    (salsa_box, own_public_key)
}