witmproxy 0.0.2-alpha

A WASM-in-the-middle proxy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use std::sync::Arc;

use tokio::sync::RwLock;

use crate::ProxyServer;
use crate::test_utils::{
    Protocol, create_ca_and_config, create_client, create_hello_server, create_plugin_registry,
    register_noop_plugin,
};

struct TestCase {
    client_proto: Protocol,
    server_proto: Protocol,
    proxy_port: u16,
    target_port: u16,
}

async fn run_test(test: TestCase) {
    let _ = rustls::crypto::ring::default_provider().install_default();
    let (ca, mut config) = create_ca_and_config().await;
    let server_handle =
        create_hello_server("127.0.0.1", test.target_port, ca.clone(), test.server_proto).await;
    let (mut registry, _temp_dir) = create_plugin_registry().await.unwrap();
    register_noop_plugin(&mut registry).await.unwrap();

    // Set the specific proxy port for testing
    config.proxy.proxy_bind_addr = Some(format!("127.0.0.1:{}", test.proxy_port));

    let mut proxy =
        ProxyServer::new(ca.clone(), Some(Arc::new(RwLock::new(registry))), config).unwrap();
    proxy.start().await.unwrap();
    let actual_proxy_addr = proxy.listen_addr().unwrap();
    let client = create_client(
        ca,
        &format!("http://{}", actual_proxy_addr),
        test.client_proto,
    )
    .await;
    let resp = client
        .get(format!("https://127.0.0.1:{}", test.target_port))
        .send()
        .await
        .unwrap();
    let text = resp.text().await.unwrap();
    assert_eq!(text, "hello world");
    proxy.shutdown().await;
    server_handle.shutdown().await;
}

#[tokio::test]
async fn test_http1_to_http1() {
    run_test(TestCase {
        client_proto: Protocol::Http1,
        server_proto: Protocol::Http1,
        proxy_port: 2345,
        target_port: 1234,
    })
    .await;
}

#[tokio::test]
async fn test_http2_to_http1() {
    run_test(TestCase {
        client_proto: Protocol::Http2,
        server_proto: Protocol::Http1,
        proxy_port: 2346,
        target_port: 1235,
    })
    .await;
}

#[tokio::test]
async fn test_http2_to_http2() {
    run_test(TestCase {
        client_proto: Protocol::Http2,
        server_proto: Protocol::Http2,
        proxy_port: 2347,
        target_port: 1236,
    })
    .await;
}

#[tokio::test]
async fn test_http1_to_http2() {
    run_test(TestCase {
        client_proto: Protocol::Http1,
        server_proto: Protocol::Http2,
        proxy_port: 2348,
        target_port: 1237,
    })
    .await;
}