product-os-proxy 0.0.17

Product OS : Proxy builds on the work of hudsucker, taking it to the next level with a man-in-the-middle proxy server that can tunnel traffic through a VPN utilising Product OS : VPN.
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

use std::sync::Arc;
pub use product_os_request::ProductOSResponse;
pub use product_os_server::{BeforeResult, ProductOSMiddleware, ProductOSMiddlewareAsync, RequestData};
pub use product_os_server::{Request, Response};

use async_trait::async_trait;
use hyper_tungstenite::tungstenite::Message;
use product_os_http_body::BodyBytes as Body;

use crate::mitm;


#[derive(Clone)]
pub struct ProxyMiddleware {
    middleware_handler: Arc<dyn ProductOSMiddlewareAsync>
}

impl ProxyMiddleware {
    pub fn new(middleware_handler: Arc<dyn ProductOSMiddlewareAsync>) -> Self {
        Self {
            middleware_handler
        }
    }

    pub fn default() -> Self {
        Self {
            middleware_handler: Arc::new(DefaultAsyncMiddleware::new())
        }
    }
}

#[async_trait]
impl mitm::HttpHandler for ProxyMiddleware {
    async fn handle_request(
        &mut self,
        _ctx: &mitm::HttpContext,
        request: Request<Body>,
    ) -> mitm::RequestOrResponse {
        match self.middleware_handler.before(request).await {
            BeforeResult::Result(req) => {
                mitm::RequestOrResponse::Request(req)
            }
            BeforeResult::Bypass(res) => {
                mitm::RequestOrResponse::Response(res)
            }
        }
    }

    async fn handle_response(
        &mut self,
        _ctx: &mitm::HttpContext,
        request: Request<Body>,
        response: Response<Body>
    ) -> Response<Body> {
        let request_data = RequestData {
            method: product_os_request::Method::from_http_method(&request.method()),
            headers: request.headers().clone(),
            uri: request.uri().clone()
        };

        self.middleware_handler.after(response, request_data).await
    }

    #[cfg(feature = "vpn")]
    async fn handle_product_os_response(
        &mut self,
        _ctx: &mitm::HttpContext,
        request: Request<Body>,
        response: ProductOSResponse<Body>
    ) -> Response<Body> {
        let request_data = RequestData {
            method: product_os_request::Method::from_http_method(&request.method()),
            headers: request.headers().clone(),
            uri: request.uri().clone()
        };

        self.middleware_handler.after_product_os_response(response, request_data).await
    }
}

#[async_trait]
impl mitm::WebSocketHandler for ProxyMiddleware {
    async fn handle_message(&mut self, _ctx: &mitm::WebSocketContext, message: Message) -> Option<Message> {
        Some(message)
    }
}



pub struct DefaultAsyncMiddleware {}

impl DefaultAsyncMiddleware {
    pub fn new() -> Self {
        Self {}
    }
}

impl ProductOSMiddleware for DefaultAsyncMiddleware {}

#[async_trait]
impl ProductOSMiddlewareAsync for DefaultAsyncMiddleware {
    async fn before(&self, request: Request<Body>) -> BeforeResult {
        todo!()
    }

    async fn after(&self, response: Response<Body>, request_data: RequestData) -> Response<Body> {
        todo!()
    }

    async fn success(&self, response: Response<Body>, request_data: RequestData) -> Response<Body> {
        todo!()
    }

    async fn failure(&self, response: Response<Body>, request_data: RequestData) -> Response<Body> {
        todo!()
    }

    async fn error(&self) -> Response<Body> {
        todo!()
    }

    async fn before_product_os_response(&self, request: Request<Body>) -> BeforeResult {
        todo!()
    }

    async fn after_product_os_response(&self, response: ProductOSResponse<Body>, request_data: RequestData) -> Response<Body> {
        todo!()
    }
}