Add tests for direct_scan_server

Update OS version
Verify Troll Patrol's inferences but still count wrong inferences
2025-05-23 17:20:58 -04:00 · 2025-05-23 14:09:09 -04:00 · 2025-05-23 13:28:39 -04:00
5 changed files with 426 additions and 4 deletions
--- a/4
+++ b/4
@ -1,4 +1,4 @@
-FROM ubuntu:24.04
+FROM ubuntu:25.04

 # Default directory
 WORKDIR /home/user
@ -53,7 +53,7 @@ RUN cp /home/user/build/config.toml .cargo/
 WORKDIR /home/user/build
 RUN git clone https://git-crysp.uwaterloo.ca/vvecna/troll-patrol.git
 WORKDIR /home/user/build/troll-patrol
-RUN git checkout 7acba0a6f00c6ffdb429b4993ee109a8e125b466
+RUN git checkout ff3aa2d71812fe5fb974856c021c98d812d2f880
 RUN mkdir -p .cargo
 RUN cp /home/user/build/config.toml .cargo/

--- a/configs/troll_patrol_config.json.template
+++ b/configs/troll_patrol_config.json.template
@ -6,6 +6,7 @@
        "Lox": "http://127.0.0.1:8002"
    },
    "extra_infos_base_url": "http://127.0.0.1:8004/",
+    "verify_blockages_url": "http://127.0.0.1:8006/verify_blocked_bridges",
    "confidence": 0.95,
    "max_threshold": HARSHNESS,
    "scaling_factor": 0.25,
--- a/src/direct_scan_server.rs
+++ b/src/direct_scan_server.rs
@ -0,0 +1,387 @@
+// Simulates direct scans by keeping a list of bridges blocked by the censor
+
+use hyper::{
+    body::{self, Bytes},
+    header::HeaderValue,
+    server::conn::AddrStream,
+    service::{make_service_fn, service_fn},
+    Body, Method, Request, Response, Server, StatusCode,
+};
+use serde_json::json;
+use std::{
+    collections::{HashMap, HashSet},
+    convert::Infallible,
+    net::SocketAddr,
+    time::Duration,
+};
+use tokio::{
+    spawn,
+    sync::{mpsc, oneshot},
+    time::sleep,
+};
+
+async fn serve_direct_scan_api(
+    // We have to serialize our HashMap keys as Strings instead of [u8; 20]s,
+    // so it's easier to just use Strings throughout.
+    blocked_bridges: &mut HashSet<String>,
+    guessed_bridges: &mut HashMap<String, HashSet<String>>,
+    req: Request<Body>,
+) -> Result<Response<Body>, Infallible> {
+    match req.method() {
+        &Method::OPTIONS => Ok(Response::builder()
+            .header("Access-Control-Allow-Origin", HeaderValue::from_static("*"))
+            .header("Access-Control-Allow-Headers", "accept, content-type")
+            .header("Access-Control-Allow-Methods", "POST")
+            .status(200)
+            .body(Body::from("Allow POST"))
+            .unwrap()),
+        _ => match req.uri().path() {
+            "/add_blocked_bridges" => Ok::<_, Infallible>({
+                let bytes = body::to_bytes(req.into_body()).await.unwrap();
+                add_blocked_bridges(blocked_bridges, bytes)
+            }),
+            "/verify_blocked_bridges" => Ok::<_, Infallible>({
+                let bytes = body::to_bytes(req.into_body()).await.unwrap();
+                verify_blocked_bridges(blocked_bridges, guessed_bridges, bytes)
+            }),
+            // Get the bridges Troll Patrol guessed were blocked today
+            "/get_guessed_bridges" => Ok::<_, Infallible>({
+                prepare_header(serde_json::to_string(&guessed_bridges).unwrap())
+            }),
+            // Reset guessed bridges at the beginning of the day
+            "/reset_guessed_bridges" => Ok::<_, Infallible>({
+                *guessed_bridges = HashMap::<String, HashSet<String>>::new();
+                prepare_header("OK".to_string())
+            }),
+            _ => Ok::<_, Infallible>({
+                Response::builder()
+                    .status(StatusCode::NOT_FOUND)
+                    .body(Body::from("Not found"))
+                    .unwrap()
+            }),
+        },
+    }
+}
+
+pub async fn server() {
+    let (context_tx, context_rx) = mpsc::channel(32);
+    let request_tx = context_tx.clone();
+
+    spawn(async move { create_context_manager(context_rx).await });
+
+    let addr = SocketAddr::from(([127, 0, 0, 1], 8006));
+    let make_svc = make_service_fn(move |_conn: &AddrStream| {
+        let request_tx = request_tx.clone();
+        let service = service_fn(move |req| {
+            let request_tx = request_tx.clone();
+            let (response_tx, response_rx) = oneshot::channel();
+            let cmd = Command::Request {
+                req,
+                sender: response_tx,
+            };
+            async move {
+                request_tx.send(cmd).await.unwrap();
+                response_rx.await.unwrap()
+            }
+        });
+        async move { Ok::<_, Infallible>(service) }
+    });
+    let server = Server::bind(&addr).serve(make_svc);
+    println!("Listening on localhost:8006");
+    if let Err(e) = server.await {
+        eprintln!("server error: {}", e);
+    }
+}
+
+async fn create_context_manager(context_rx: mpsc::Receiver<Command>) {
+    tokio::select! {
+        create_context = context_manager(context_rx) => create_context,
+    }
+}
+
+async fn context_manager(mut context_rx: mpsc::Receiver<Command>) {
+    let mut blocked_bridges = HashSet::<String>::new();
+    let mut guessed_bridges = HashMap::<String, HashSet<String>>::new();
+
+    while let Some(cmd) = context_rx.recv().await {
+        use Command::*;
+        match cmd {
+            Request { req, sender } => {
+                let response =
+                    serve_direct_scan_api(&mut blocked_bridges, &mut guessed_bridges, req).await;
+                if let Err(e) = sender.send(response) {
+                    eprintln!("Server Response Error: {:?}", e);
+                }
+                sleep(Duration::from_millis(1)).await;
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+enum Command {
+    Request {
+        req: Request<Body>,
+        sender: oneshot::Sender<Result<Response<Body>, Infallible>>,
+    },
+}
+
+fn add_blocked_bridges(blocked_bridges: &mut HashSet<String>, request: Bytes) -> Response<Body> {
+    let new_blocked_bridges: HashSet<String> = match serde_json::from_slice(&request) {
+        Ok(req) => req,
+        Err(e) => {
+            let response = json!({"error": e.to_string()});
+            let val = serde_json::to_string(&response).unwrap();
+            return prepare_header(val);
+        }
+    };
+
+    blocked_bridges.extend(new_blocked_bridges);
+
+    prepare_header("OK".to_string())
+}
+
+fn verify_blocked_bridges(
+    blocked_bridges: &mut HashSet<String>,
+    guessed_bridges: &mut HashMap<String, HashSet<String>>,
+    request: Bytes,
+) -> Response<Body> {
+    let mut verified_blocked_bridges = HashMap::<String, HashSet<String>>::new();
+    let possibly_blocked_bridges: HashMap<String, HashSet<String>> =
+        match serde_json::from_slice(&request) {
+            Ok(req) => req,
+            Err(e) => {
+                let response = json!({"error": e.to_string()});
+                let val = serde_json::to_string(&response).unwrap();
+                return prepare_header(val);
+            }
+        };
+
+    *guessed_bridges = possibly_blocked_bridges.clone();
+
+    for (fpr, countries) in possibly_blocked_bridges {
+        if blocked_bridges.contains(&fpr) {
+            verified_blocked_bridges.insert(fpr, countries);
+        }
+    }
+
+    prepare_header(serde_json::to_string(&verified_blocked_bridges).unwrap())
+}
+
+// Prepare HTTP Response for successful Server Request
+fn prepare_header(response: String) -> Response<Body> {
+    let mut resp = Response::new(Body::from(response));
+    resp.headers_mut()
+        .insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
+    resp
+}
+
+#[tokio::test]
+async fn test_direct_scan_server() {
+    use lox_cli::networking::*;
+
+    // Start web server
+    spawn(async move {
+        server().await;
+    });
+
+    // Give server time to start
+    sleep(Duration::new(1, 0)).await;
+
+    let scan_net = HyperNet {
+        hostname: "http://localhost:8006".to_string(),
+    };
+
+    // Initially there should be no guessed bridges
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.is_empty());
+
+    // Let's guess a bridge
+    let mut guesses = HashMap::<String, HashSet<String>>::new();
+    let mut guess_0 = HashSet::<String>::new();
+    guess_0.insert("ru".to_string());
+    guesses.insert(
+        "0000000000000000000000000000000000000000".to_string(),
+        guess_0,
+    );
+    let verify_bridges_resp = scan_net
+        .request(
+            "/verify_blocked_bridges".to_string(),
+            serde_json::to_string(&guesses).unwrap().into(),
+        )
+        .await
+        .unwrap();
+    let correct_guesses: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&verify_bridges_resp).unwrap();
+    assert!(correct_guesses.is_empty());
+
+    // We should have a new guessed bridge now
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.len() == 1);
+    assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
+    assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
+
+    // Reset the guessed bridges (new day)
+    let _ = scan_net
+        .request("/reset_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+
+    // We should have no guessed bridges
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.is_empty());
+
+    // Add two blocked bridges
+    let mut blocked_bridges = HashSet::<String>::new();
+    blocked_bridges.insert("0000000000000000000000000000000000000000".to_string());
+    blocked_bridges.insert("1111111111111111111111111111111111111111".to_string());
+    let _ = scan_net
+        .request(
+            "/add_blocked_bridges".to_string(),
+            serde_json::to_string(&blocked_bridges).unwrap().into(),
+        )
+        .await
+        .unwrap();
+
+    // Guess one of the bridges
+    let mut guesses = HashMap::<String, HashSet<String>>::new();
+    let mut guess_1 = HashSet::<String>::new();
+    guess_1.insert("ru".to_string());
+    guesses.insert(
+        "1111111111111111111111111111111111111111".to_string(),
+        guess_1,
+    );
+    let verify_bridges_resp = scan_net
+        .request(
+            "/verify_blocked_bridges".to_string(),
+            serde_json::to_string(&guesses).unwrap().into(),
+        )
+        .await
+        .unwrap();
+    let correct_guesses: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&verify_bridges_resp).unwrap();
+    assert!(correct_guesses.len() == 1);
+    assert!(!correct_guesses.contains_key("0000000000000000000000000000000000000000"));
+    assert!(correct_guesses.contains_key("1111111111111111111111111111111111111111"));
+
+    // We should have one guessed bridge
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.len() == 1);
+    assert!(!guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
+    assert!(guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
+
+    // Guess both bridges
+    let mut guesses = HashMap::<String, HashSet<String>>::new();
+    let mut guess_0 = HashSet::<String>::new();
+    guess_0.insert("ru".to_string());
+    guesses.insert(
+        "0000000000000000000000000000000000000000".to_string(),
+        guess_0,
+    );
+    let mut guess_1 = HashSet::<String>::new();
+    guess_1.insert("ru".to_string());
+    guesses.insert(
+        "1111111111111111111111111111111111111111".to_string(),
+        guess_1,
+    );
+    let verify_bridges_resp = scan_net
+        .request(
+            "/verify_blocked_bridges".to_string(),
+            serde_json::to_string(&guesses).unwrap().into(),
+        )
+        .await
+        .unwrap();
+    let correct_guesses: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&verify_bridges_resp).unwrap();
+    assert!(correct_guesses.len() == 2);
+    assert!(correct_guesses.contains_key("0000000000000000000000000000000000000000"));
+    assert!(correct_guesses.contains_key("1111111111111111111111111111111111111111"));
+
+    // We should have two guessed bridges
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.len() == 2);
+    assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
+    assert!(guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
+
+    // Try guessing a third bridge
+    let mut guesses = HashMap::<String, HashSet<String>>::new();
+    let mut guess_0 = HashSet::<String>::new();
+    guess_0.insert("ru".to_string());
+    guesses.insert(
+        "0000000000000000000000000000000000000000".to_string(),
+        guess_0,
+    );
+    let mut guess_2 = HashSet::<String>::new();
+    guess_2.insert("ru".to_string());
+    guesses.insert(
+        "2222222222222222222222222222222222222222".to_string(),
+        guess_2,
+    );
+    let verify_bridges_resp = scan_net
+        .request(
+            "/verify_blocked_bridges".to_string(),
+            serde_json::to_string(&guesses).unwrap().into(),
+        )
+        .await
+        .unwrap();
+    let correct_guesses: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&verify_bridges_resp).unwrap();
+    assert!(correct_guesses.len() == 1);
+    assert!(correct_guesses.contains_key("0000000000000000000000000000000000000000"));
+    assert!(!correct_guesses.contains_key("1111111111111111111111111111111111111111"));
+    assert!(!correct_guesses.contains_key("2222222222222222222222222222222222222222"));
+
+    // We should have three guessed bridges
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.len() == 2);
+    assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
+    assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
+    assert!(guessed_bridges.contains_key("2222222222222222222222222222222222222222"));
+
+    // Reset guesses again
+    let _ = scan_net
+        .request("/reset_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+
+    // We should have no guessed bridges
+    let guessed_bridges_resp = scan_net
+        .request("/get_guessed_bridges".to_string(), vec![])
+        .await
+        .unwrap();
+    let guessed_bridges: HashMap<String, HashSet<String>> =
+        serde_json::from_slice(&guessed_bridges_resp).unwrap();
+    assert!(guessed_bridges.is_empty());
+    assert!(!guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
+    assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@ -1,5 +1,6 @@
 pub mod bridge;
 pub mod censor;
 pub mod config;
+pub mod direct_scan_server;
 pub mod extra_infos_server;
 pub mod user;
--- a/src/main.rs
+++ b/src/main.rs
@ -7,7 +7,7 @@ use lox_simulation::{
    bridge::Bridge,
    censor::{self, Censor},
    config::Config as SConfig,
-    extra_infos_server,
+    direct_scan_server, extra_infos_server,
    user::User,
 };

@ -88,6 +88,9 @@ pub async fn main() {
    let extra_infos_net = HyperNet {
        hostname: "http://localhost:8004".to_string(),
    };
+    let scan_net = HyperNet {
+        hostname: "http://localhost:8006".to_string(),
+    };

    let la_pubkeys = get_lox_auth_keys(&la_net).await.unwrap();

@ -134,6 +137,12 @@ pub async fn main() {
    });
    sleep(Duration::from_millis(1)).await;

+    // Set up blockage verification server
+    spawn(async move {
+        direct_scan_server::server().await;
+    });
+    sleep(Duration::from_millis(1)).await;
+
    // Only consider bridges that have been distributed to users
    let mut false_neg = 0;
    let mut false_pos = 0;
@ -164,6 +173,11 @@ pub async fn main() {
        // Save some function calls by storing this
        let date = get_date();

+        // Reset Troll Patrol's guesses
+        let _ = scan_net
+            .request("/reset_guessed_bridges".to_string(), vec![])
+            .await;
+
        // Count of users who could use at least one bridge today
        let mut count_users_can_connect = 0;
        let mut count_users_cannot_connect = 0;
@ -335,6 +349,18 @@ pub async fn main() {
        }

        if censor.is_active() {
+            // Update blockage verification server with list of known bridges
+            let mut known_bridges = HashSet::<String>::new();
+            for bridge in &censor.known_bridges {
+                known_bridges.insert(array_bytes::bytes2hex("", bridge));
+            }
+            let _ = scan_net
+                .request(
+                    "/add_blocked_bridges".to_string(),
+                    serde_json::to_string(&known_bridges).unwrap().into(),
+                )
+                .await;
+
            censor.end_of_day_tasks(&sconfig, &mut bridges).await;
        }

@ -362,7 +388,14 @@ pub async fn main() {
        }

        // TROLL PATROL TASKS
-        let new_blockages_resp = tp_net_test.request("/update".to_string(), vec![]).await;
+
+        // This gets verified guesses, which we ignore here
+        let _new_blockages_resp = tp_net_test.request("/update".to_string(), vec![]).await;
+
+        // Get Troll Patrol's unverified guesses
+        let new_blockages_resp = scan_net
+            .request("/get_guessed_bridges".to_string(), vec![])
+            .await;
        let new_blockages = match new_blockages_resp {
            Ok(resp) => match serde_json::from_slice(&resp) {
                Ok(new_blockages) => new_blockages,
Author	SHA1	Message	Date
Vecna	d4f6380d77	Add tests for direct_scan_server	2025-05-23 17:20:58 -04:00
Vecna	76cd49208b	Update OS version	2025-05-23 14:09:09 -04:00
Vecna	0c74c62e3e	Verify Troll Patrol's inferences but still count wrong inferences	2025-05-23 13:28:39 -04:00