hMihaiDavid/weird.rs

## weird.rs
/*
[dependencies]
snow = "0.9.0"
clap = "4.0.27"
**/

use clap::{arg, Command};
use snow::{params::NoiseParams, Builder};
use std::{
    io::{self, Read, Write},
    net::{TcpListener, TcpStream},
};

// These keys have been pre-generated with Builder::generate_keypair with the
// script in the comment at the end of this file.

static STATIC_PRIVKEY_CLIENT: [u8; 32] = [
    52, 18, 25, 179, 157, 119, 221, 39, 189, 53, 115, 58, 182, 224, 141, 74, 87,
    145, 180, 253, 227, 25, 109, 202, 213, 65, 55, 143, 112, 185, 166, 27
];

static STATIC_PUBKEY_CLIENT: [u8; 32]= [
    160, 244, 254, 226, 58, 148, 38, 56, 41, 161, 244, 175, 23, 33, 50, 199,
    213, 141, 70, 204, 247, 190, 58, 165, 19, 137, 84, 41, 230, 101, 162,
    87
];

static STATIC_PRIVKEY_SERVER: [u8; 32] = [
    136, 238, 164, 3, 190, 116, 47, 145, 129, 76, 125, 37, 49, 4, 135, 41, 198,
    94, 198, 190, 70, 136, 146, 167, 202, 81, 109, 142, 119, 143, 170, 103
];

static STATIC_PUBKEY_SERVER: [u8; 32]= [
    171, 232, 231, 4, 67, 146, 198, 47, 139, 164, 103, 99, 4, 80, 169, 147, 238,
    243, 104, 25, 107, 250, 227, 87, 237, 108, 18, 85, 119, 91, 201, 62
];

fn main() {
    let matches = Command::new("simple")
        .arg(arg!(-s --server "Server mode"))
        .get_matches();

    if matches.get_flag("server") {
        println!("Running server...");
        run_server();
    } else {
        println!("Running client...");
        run_client();
    }
}

fn run_server() {
    let mut buf = vec![0u8; 65535];

    let noise_params: NoiseParams = "Noise_XX_25519_ChaChaPoly_BLAKE2s"
                                    .parse().unwrap();
    let noise_builder = Builder::new(noise_params);

    let mut noise = noise_builder
        .local_private_key(&STATIC_PRIVKEY_SERVER)
        //.remote_public_key(&STATIC_PUBKEY_CLIENT)
        .build_responder().unwrap();

    let (mut stream, _) = TcpListener::bind("127.0.0.1:9999").unwrap().accept().unwrap();
    println!("server accepted connection...");

    // <- e
    let msg = recv(&mut stream).unwrap();
    let payload_len = noise.read_message(&msg, &mut []).unwrap();
    println!("<- e (payload_len: {})", payload_len);

    // -> e, ee, s, es
    let len = noise.write_message(&[0u8; 0], &mut buf).unwrap();
    println!("-> e, ee, s, es (payload_len: 0)");
    send(&mut stream, &buf[..len]);

    // <- s, se
    let msg = recv(&mut stream).unwrap();
    let payload_len = noise.read_message(&msg, &mut buf).unwrap();
    println!("<- s, se (payload_len: {})", payload_len);

    let mut noise = noise.into_transport_mode().unwrap();
    println!("server session established...");

    let remote_pubkey_from_transport_state = noise.get_remote_static();
    println!("server: remote_pubkey_from_transport_state: {:?}", remote_pubkey_from_transport_state);

    while let Ok(msg) = recv(&mut stream) {
        let len = noise.read_message(&msg, &mut buf).unwrap();
        println!("client said: {}", String::from_utf8_lossy(&buf[..len]));
    }

    println!("======== SERVER QUITS ========");
}

fn run_client() {
    let mut buf = vec![0u8; 65535];

    let noise_params: NoiseParams = "Noise_XX_25519_ChaChaPoly_BLAKE2s"
                                    .parse().unwrap();
    let noise_builder = Builder::new(noise_params);

    let mut noise = noise_builder
        .local_private_key(&STATIC_PRIVKEY_CLIENT)
        //.remote_public_key(&STATIC_PUBKEY_SERVER)
        .build_initiator().unwrap();

    let mut stream = TcpStream::connect("127.0.0.1:9999").unwrap();
    println!("client connected...");

    // -> e
    let msg_len = noise.write_message(&[], &mut buf).unwrap();
    println!("-> e (payload_len: 0)");
    send(&mut stream, &buf[..msg_len]);

    // <- e, ee, s, es

    let msg = recv(&mut stream).unwrap();
    let payload_len = noise.read_message(&msg, &mut buf).unwrap();
    println!("<- e, ee, s, es (payload_len: {})", payload_len);

    // -> s, se
    let len = noise.write_message(&[], &mut buf).unwrap();
    println!("->s, se (payload_len: 0)");
    send(&mut stream, &buf[..len]);

    let mut noise = noise.into_transport_mode().unwrap();
    println!("client session established...");

    let remote_pubkey_from_transport_state = noise.get_remote_static();
    println!("client: remote_pubkey_from_transport_state: {:?}", remote_pubkey_from_transport_state);

    for _ in 0..10 {
        let data = b"some data AAAAAAAAAAA";
        println!("-> data ({})", data.len());
        let len = noise.write_message(data, &mut buf).unwrap();
        send(&mut stream, &buf[..len]);
    }
    println!("======== CLIENT QUITS ========");
}

// Copy pasta from snow crate example

/// Hyper-basic stream transport receiver. 16-bit BE size followed by payload.
fn recv(stream: &mut TcpStream) -> io::Result<Vec<u8>> {
    let mut msg_len_buf = [0u8; 2];
    stream.read_exact(&mut msg_len_buf)?;
    let msg_len = ((msg_len_buf[0] as usize) << 8) + (msg_len_buf[1] as usize);
    let mut msg = vec![0u8; msg_len];
    stream.read_exact(&mut msg[..])?;
    println!("recv 2+{} {:?}", msg.len(), msg);
    Ok(msg)
}

/// Hyper-basic stream transport sender. 16-bit BE size followed by payload.
fn send(stream: &mut TcpStream, buf: &[u8]) {
    println!("send 2+{} {:?}", buf.len(), buf);
    let msg_len_buf = [(buf.len() >> 8) as u8, (buf.len() & 0xff) as u8];
    stream.write_all(&msg_len_buf).unwrap();
    stream.write_all(buf).unwrap();
}

// Little script to generate keypairs:
/*

use snow::{params::NoiseParams, Builder, Keypair};
use std::fmt;

struct WrapKeypair(Keypair);

impl fmt::Debug for WrapKeypair {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "public: {:?} private: {:?}", self.0.public, self.0.private)
    }
}

fn main() {
    let noise_params: NoiseParams = "Noise_XXpsk3_25519_ChaChaPoly_BLAKE2s"
                                    .parse().unwrap();
    let noise_builder = Builder::new(noise_params);

    let keypair = noise_builder.generate_keypair().unwrap();
    println!("{:?}", WrapKeypair(keypair));
}

*/
	/*
	[dependencies]
	snow = "0.9.0"
	clap = "4.0.27"
	**/

	use clap::{arg, Command};
	use snow::{params::NoiseParams, Builder};
	use std::{
	io::{self, Read, Write},
	net::{TcpListener, TcpStream},
	};

	// These keys have been pre-generated with Builder::generate_keypair with the
	// script in the comment at the end of this file.

	static STATIC_PRIVKEY_CLIENT: [u8; 32] = [
	52, 18, 25, 179, 157, 119, 221, 39, 189, 53, 115, 58, 182, 224, 141, 74, 87,
	145, 180, 253, 227, 25, 109, 202, 213, 65, 55, 143, 112, 185, 166, 27
	];

	static STATIC_PUBKEY_CLIENT: [u8; 32]= [
	160, 244, 254, 226, 58, 148, 38, 56, 41, 161, 244, 175, 23, 33, 50, 199,
	213, 141, 70, 204, 247, 190, 58, 165, 19, 137, 84, 41, 230, 101, 162,
	87
	];

	static STATIC_PRIVKEY_SERVER: [u8; 32] = [
	136, 238, 164, 3, 190, 116, 47, 145, 129, 76, 125, 37, 49, 4, 135, 41, 198,
	94, 198, 190, 70, 136, 146, 167, 202, 81, 109, 142, 119, 143, 170, 103
	];

	static STATIC_PUBKEY_SERVER: [u8; 32]= [
	171, 232, 231, 4, 67, 146, 198, 47, 139, 164, 103, 99, 4, 80, 169, 147, 238,
	243, 104, 25, 107, 250, 227, 87, 237, 108, 18, 85, 119, 91, 201, 62
	];

	fn main() {
	let matches = Command::new("simple")
	.arg(arg!(-s --server "Server mode"))
	.get_matches();

	if matches.get_flag("server") {
	println!("Running server...");
	run_server();
	} else {
	println!("Running client...");
	run_client();
	}
	}

	fn run_server() {
	let mut buf = vec![0u8; 65535];

	let noise_params: NoiseParams = "Noise_XX_25519_ChaChaPoly_BLAKE2s"
	.parse().unwrap();
	let noise_builder = Builder::new(noise_params);

	let mut noise = noise_builder
	.local_private_key(&STATIC_PRIVKEY_SERVER)
	//.remote_public_key(&STATIC_PUBKEY_CLIENT)
	.build_responder().unwrap();

	let (mut stream, _) = TcpListener::bind("127.0.0.1:9999").unwrap().accept().unwrap();
	println!("server accepted connection...");

	// <- e
	let msg = recv(&mut stream).unwrap();
	let payload_len = noise.read_message(&msg, &mut []).unwrap();
	println!("<- e (payload_len: {})", payload_len);

	// -> e, ee, s, es
	let len = noise.write_message(&[0u8; 0], &mut buf).unwrap();
	println!("-> e, ee, s, es (payload_len: 0)");
	send(&mut stream, &buf[..len]);

	// <- s, se
	let msg = recv(&mut stream).unwrap();
	let payload_len = noise.read_message(&msg, &mut buf).unwrap();
	println!("<- s, se (payload_len: {})", payload_len);

	let mut noise = noise.into_transport_mode().unwrap();
	println!("server session established...");

	let remote_pubkey_from_transport_state = noise.get_remote_static();
	println!("server: remote_pubkey_from_transport_state: {:?}", remote_pubkey_from_transport_state);

	while let Ok(msg) = recv(&mut stream) {
	let len = noise.read_message(&msg, &mut buf).unwrap();
	println!("client said: {}", String::from_utf8_lossy(&buf[..len]));
	}

	println!("======== SERVER QUITS ========");
	}

	fn run_client() {
	let mut buf = vec![0u8; 65535];

	let noise_params: NoiseParams = "Noise_XX_25519_ChaChaPoly_BLAKE2s"
	.parse().unwrap();
	let noise_builder = Builder::new(noise_params);

	let mut noise = noise_builder
	.local_private_key(&STATIC_PRIVKEY_CLIENT)
	//.remote_public_key(&STATIC_PUBKEY_SERVER)
	.build_initiator().unwrap();

	let mut stream = TcpStream::connect("127.0.0.1:9999").unwrap();
	println!("client connected...");

	// -> e
	let msg_len = noise.write_message(&[], &mut buf).unwrap();
	println!("-> e (payload_len: 0)");
	send(&mut stream, &buf[..msg_len]);

	// <- e, ee, s, es

	let msg = recv(&mut stream).unwrap();
	let payload_len = noise.read_message(&msg, &mut buf).unwrap();
	println!("<- e, ee, s, es (payload_len: {})", payload_len);

	// -> s, se
	let len = noise.write_message(&[], &mut buf).unwrap();
	println!("->s, se (payload_len: 0)");
	send(&mut stream, &buf[..len]);

	let mut noise = noise.into_transport_mode().unwrap();
	println!("client session established...");

	let remote_pubkey_from_transport_state = noise.get_remote_static();
	println!("client: remote_pubkey_from_transport_state: {:?}", remote_pubkey_from_transport_state);

	for _ in 0..10 {
	let data = b"some data AAAAAAAAAAA";
	println!("-> data ({})", data.len());
	let len = noise.write_message(data, &mut buf).unwrap();
	send(&mut stream, &buf[..len]);
	}
	println!("======== CLIENT QUITS ========");
	}

	// Copy pasta from snow crate example

	/// Hyper-basic stream transport receiver. 16-bit BE size followed by payload.
	fn recv(stream: &mut TcpStream) -> io::Result<Vec<u8>> {
	let mut msg_len_buf = [0u8; 2];
	stream.read_exact(&mut msg_len_buf)?;
	let msg_len = ((msg_len_buf[0] as usize) << 8) + (msg_len_buf[1] as usize);
	let mut msg = vec![0u8; msg_len];
	stream.read_exact(&mut msg[..])?;
	println!("recv 2+{} {:?}", msg.len(), msg);
	Ok(msg)
	}

	/// Hyper-basic stream transport sender. 16-bit BE size followed by payload.
	fn send(stream: &mut TcpStream, buf: &[u8]) {
	println!("send 2+{} {:?}", buf.len(), buf);
	let msg_len_buf = [(buf.len() >> 8) as u8, (buf.len() & 0xff) as u8];
	stream.write_all(&msg_len_buf).unwrap();
	stream.write_all(buf).unwrap();
	}

	// Little script to generate keypairs:
	/*

	use snow::{params::NoiseParams, Builder, Keypair};
	use std::fmt;

	struct WrapKeypair(Keypair);

	impl fmt::Debug for WrapKeypair {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "public: {:?} private: {:?}", self.0.public, self.0.private)
	}
	}

	fn main() {
	let noise_params: NoiseParams = "Noise_XXpsk3_25519_ChaChaPoly_BLAKE2s"
	.parse().unwrap();
	let noise_builder = Builder::new(noise_params);

	let keypair = noise_builder.generate_keypair().unwrap();
	println!("{:?}", WrapKeypair(keypair));
	}

	*/