Checkpoint

rosenpass/tests/integration_test.rs

@@ -39,7 +39,7 @@ fn find_udp_socket() -> u16 {
 
 // check that we can exchange keys
 #[test]
-fn check_exchange() {
+fn check_exchange_under_normal() {
     let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange");
     fs::create_dir_all(&tmpdir).unwrap();
 
@@ -117,3 +117,105 @@ fn check_exchange() {
     // cleanup
     fs::remove_dir_all(&tmpdir).unwrap();
 }
+
+// check that we can exchange keys
+#[test]
+fn check_exchange_under_dos() {
+    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange-dos");
+    fs::create_dir_all(&tmpdir).unwrap();
+
+    let secret_key_paths = [tmpdir.join("secret-key-0"), tmpdir.join("secret-key-1")];
+    let public_key_paths = [tmpdir.join("public-key-0"), tmpdir.join("public-key-1")];
+    let shared_key_paths = [tmpdir.join("shared-key-0"), tmpdir.join("shared-key-1")];
+
+    // generate key pairs
+    for (secret_key_path, pub_key_path) in secret_key_paths.iter().zip(public_key_paths.iter()) {
+        let output = test_bin::get_test_bin(BIN)
+            .args(["gen-keys", "--secret-key"])
+            .arg(secret_key_path)
+            .arg("--public-key")
+            .arg(pub_key_path)
+            .output()
+            .expect("Failed to start {BIN}");
+
+        assert_eq!(String::from_utf8_lossy(&output.stdout), "");
+        assert!(secret_key_path.is_file());
+        assert!(pub_key_path.is_file());
+    }
+
+    // start first process, the server
+    let port = find_udp_socket();
+    let listen_addr = format!("localhost:{port}");
+    let mut server = test_bin::get_test_bin(BIN)
+        .args(["exchange", "secret-key"])
+        .arg(&secret_key_paths[0])
+        .arg("public-key")
+        .arg(&public_key_paths[0])
+        .args(["listen", &listen_addr, "verbose", "peer", "public-key"])
+        .arg(&public_key_paths[1])
+        .arg("outfile")
+        .arg(&shared_key_paths[0])
+        //.stdout(Stdio::null())
+        //.stderr(Stdio::null())
+        .spawn()
+        .expect("Failed to start {BIN}");
+
+    std::thread::sleep(Duration::from_millis(500));
+
+    //DoS Sender
+    //Create a UDP socket
+    let socket = UdpSocket::bind("127.0.0.1:0").expect("couldn't bind to address");
+    //Spawn a thread to send DoS packets
+    let server_addr = listen_addr.clone();
+
+    //Create thread safe atomic bool to stop the DoS attack
+    let stop_dos = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let stop_dos_handle = stop_dos.clone();
+    
+    let dos_attack = std::thread::spawn(move || {
+        while stop_dos.load(std::sync::atomic::Ordering::Relaxed) == false {
+            let buf = [0; 10];
+            socket
+                .send_to(&buf, &server_addr)
+                .expect("couldn't send data");
+        }
+    });
+
+    // start second process, the client
+    let mut client = test_bin::get_test_bin(BIN)
+        .args(["exchange", "secret-key"])
+        .arg(&secret_key_paths[1])
+        .arg("public-key")
+        .arg(&public_key_paths[1])
+        .args(["verbose", "peer", "public-key"])
+        .arg(&public_key_paths[0])
+        .args(["endpoint", &listen_addr])
+        .arg("outfile")
+        .arg(&shared_key_paths[1])
+        //.stdout(Stdio::null())
+        //.stderr(Stdio::null())
+        .spawn()
+        .expect("Failed to start {BIN}");
+
+    // give them some time to do the key exchange
+    std::thread::sleep(Duration::from_secs(2));
+
+    // time's up, kill the childs
+    server.kill().unwrap();
+    client.kill().unwrap();
+    stop_dos_handle.store(true, std::sync::atomic::Ordering::Relaxed);
+    dos_attack.join().unwrap();
+
+    // read the shared keys they created
+    let shared_keys: Vec<_> = shared_key_paths
+        .iter()
+        .map(|p| fs::read_to_string(p).unwrap())
+        .collect();
+
+    // check that they created two equal keys
+    assert_eq!(shared_keys.len(), 2);
+    assert_eq!(shared_keys[0], shared_keys[1]);
+
+    // cleanup
+    fs::remove_dir_all(&tmpdir).unwrap();
+}