rama 0.3.0

modular service framework
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

#![expect(
    clippy::expect_used,
    reason = "example/test/bench: panic-on-error and print-for-output are the standard patterns for demos and harnesses"
)]

use std::time::Duration;

use crate::examples::example_tests::utils::ExampleRunner;

use super::utils;

use rama::{
    Layer,
    http::{
        BodyExtractExt, layer::error_handling::ErrorHandlerLayer, server::HttpServer,
        service::web::Router,
    },
    layer::ArcLayer,
    net::{
        Protocol,
        address::{ProxyAddress, SocketAddress},
        user::{Basic, ProxyCredential},
    },
    rt::Executor,
    tcp::server::TcpListener,
    telemetry::tracing,
    tls::boring::server::TlsAcceptorService,
    tls::server::{SelfSignedData, TlsServerConfig},
    utils::str::non_empty_str,
};

#[tokio::test]
#[ignore]
async fn test_socks5_connect_proxy_mitm_proxy() {
    utils::init_tracing();

    let runner = utils::ExampleRunner::interactive(
        "socks5_connect_proxy_mitm_proxy",
        Some("socks5,boring,dns"),
    );

    // wait for example to run... this is dirty
    tokio::time::sleep(Duration::from_secs(10)).await;

    let http_socket_addr = spawn_http_server().await;
    let https_socket_addr = spawn_https_server().await;

    test_http_client_over_socks5_proxy_connect_with_mitm_cap(
        http_socket_addr,
        https_socket_addr,
        runner,
    )
    .await;
}

async fn test_http_client_over_socks5_proxy_connect_with_mitm_cap(
    http_socket_addr: SocketAddress,
    https_socket_addr: SocketAddress,
    runner: ExampleRunner,
) {
    let proxy_socket_addr = SocketAddress::local_ipv4(62022);

    tracing::info!(
        "local servers up and running (proxy = {}; http = {}; https = {})",
        proxy_socket_addr,
        http_socket_addr,
        https_socket_addr,
    );

    let proxy_address = ProxyAddress {
        protocol: Some(Protocol::SOCKS5),
        address: proxy_socket_addr.into(),
        credential: Some(ProxyCredential::Basic(Basic::new(
            non_empty_str!("john"),
            non_empty_str!("secret"),
        ))),
    };

    let test_uris = [
        format!("http://{http_socket_addr}/ping"),
        format!("https://{https_socket_addr}/ping"),
    ];

    for uri in test_uris {
        tracing::info!(
            url.full = %uri,
            "try to establish proxied connection over SOCKS5 MITM Proxy",
        );

        tracing::info!(
            url.full = %uri,
            "try to make GET http(s) request and try to receive response text",
        );

        let resp = runner
            .get(uri)
            .extension(proxy_address.clone())
            .send()
            .await
            .expect("make http(s) request via socks5 proxy")
            .try_into_string()
            .await
            .expect("get response text");

        assert_eq!("pong", resp);
        tracing::info!("ping-pong succeeded");
    }

    tracing::info!("bye now!");
}

async fn spawn_http_server() -> SocketAddress {
    let tcp_service =
        TcpListener::bind_address(SocketAddress::default_ipv4(63009), Executor::default())
            .await
            .expect("bind HTTP server on open port");

    let bind_addr = tcp_service
        .local_addr()
        .expect("get bind address of http server")
        .into();

    let app = Router::new().with_get("/ping", "pong");
    let server = HttpServer::auto(Executor::default())
        .service((ArcLayer::new(), ErrorHandlerLayer::new()).into_layer(app));

    tokio::spawn(tcp_service.serve(server));

    bind_addr
}

async fn spawn_https_server() -> SocketAddress {
    let tcp_service =
        TcpListener::bind_address(SocketAddress::default_ipv4(63010), Executor::default())
            .await
            .expect("bind HTTP server on open port");

    let bind_addr = tcp_service
        .local_addr()
        .expect("get bind address of http server")
        .into();

    let app = Router::new().with_get("/ping", "pong");
    let http_server = HttpServer::auto(Executor::default())
        .service((ArcLayer::new(), ErrorHandlerLayer::new()).into_layer(app));

    let config = TlsServerConfig::new()
        .try_with_self_signed(SelfSignedData {
            organisation_name: Some("Socks5 Https Test Server".to_owned()),
            ..Default::default()
        })
        .expect("self-signed")
        .with_alpn_http_auto();
    let https_server = TlsAcceptorService::new(config, http_server, false);

    tokio::spawn(tcp_service.serve(https_server));

    bind_addr
}