prax 0.1.1

a web penetration proxy hosted in neovim
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

use std::str::FromStr;

use hyper::{
    header::{HeaderName, HeaderValue},
    HeaderMap, StatusCode, Uri,
};

pub trait LinesImprint {
    type Error: std::error::Error;

    fn imprint(&mut self, lines: Vec<String>) -> Result<(), Self::Error>;
}

impl LinesImprint for hyper::Request<Vec<u8>> {
    type Error = crate::Error;

    fn imprint(&mut self, lines: Vec<String>) -> Result<(), Self::Error> {
        let Some(status) = lines.first() else {
            return Err(crate::Error::InterceptMalformed);
        };

        let (method, uri) = extract_status(self.uri(), status)?;

        let mut headermap = HeaderMap::new();
        let mut i = 1;
        for line in lines.iter().skip(1) {
            if line.is_empty() {
                break;
            }

            if let Some((name, value)) = line.split_once(": ") {
                let name = HeaderName::from_str(name)?;
                let value = HeaderValue::from_str(value)?;

                headermap.insert(name, value);
            }

            i += 1;
        }

        let mut body = Vec::new();

        for line in &lines[i..] {
            body.extend_from_slice(line.as_bytes());
            body.push(b'\n');
        }

        *self.method_mut() = method;
        *self.uri_mut() = uri;
        *self.headers_mut() = headermap;
        *self.body_mut() = body;

        Ok(())
    }
}

impl LinesImprint for hyper::Response<Vec<u8>> {
    type Error = crate::Error;

    fn imprint(&mut self, lines: Vec<String>) -> Result<(), Self::Error> {
        let Some(status) = lines.first() else {
            return Err(crate::Error::InterceptMalformed);
        };

        let code = StatusCode::from_str(status)?;

        let mut headermap = HeaderMap::new();
        let mut i = 1;
        for line in lines.iter().skip(1) {
            if line.is_empty() {
                break;
            }

            if let Some((name, value)) = line.split_once(':') {
                let name = HeaderName::from_str(name)?;
                let value = HeaderValue::from_str(value.trim())?;

                headermap.insert(name, value);
            }

            i += 1;
        }

        let mut body = Vec::new();

        for line in &lines[i..] {
            body.extend_from_slice(line.as_bytes());
            body.push(b'\n');
        }

        *self.status_mut() = code;
        *self.headers_mut() = headermap;
        *self.body_mut() = body;

        Ok(())
    }
}

fn extract_status(uri: &Uri, lines: &str) -> crate::Result<(hyper::Method, hyper::Uri)> {
    let Some((method, path)) = lines.split_once(' ') else {
        return Err(crate::Error::InterceptMalformed);
    };

    let method = hyper::Method::from_str(method)?;
    let mut builder = Uri::builder();

    if let Some(scheme) = uri.scheme() {
        builder = builder.scheme(scheme.clone())
    }

    if let Some(auth) = uri.authority() {
        builder = builder.authority(auth.clone())
    }

    let uri = builder.path_and_query(path).build()?;

    log::debug!("modiified {method:?} {uri:?}");

    Ok((method, uri))
}