add hex contentview

Author: mhils

mitmproxy-rs/src/contentview.rs

@@ -0,0 +1,32 @@
+use pyo3::prelude::*;
+use anyhow::{Result};
+use mitmproxy::contentviews::Contentview;
+
+#[pyclass]
+pub struct PyContentview(&'static dyn Contentview);
+
+impl PyContentview {
+    pub fn new<'py>(py: Python<'py>, contentview: &'static dyn Contentview) -> PyResult<Bound<'py, Self>> {
+        PyContentview(contentview).into_pyobject(py)
+    }
+}
+
+#[pymethods]
+impl PyContentview {
+
+    #[getter]
+    pub fn name(&self) -> &str {
+        self.0.name()
+    }
+
+    pub fn deserialize<'py>(
+        &self,
+        data: Vec<u8>
+    ) -> Result<String> {
+        self.0.deserialize(data)
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("<{} Contentview>", self.0.name()))
+    }
+}

mitmproxy-rs/src/lib.rs

@@ -12,6 +12,7 @@ mod stream;
 pub mod task;
 mod udp_client;
 mod util;
+mod contentview;
 
 static LOGGER_INITIALIZED: Lazy<RwLock<bool>> = Lazy::new(|| RwLock::new(false));
 
@@ -81,6 +82,21 @@ mod mitmproxy_rs {
         use crate::util::{genkey, pubkey};
     }
 
+    #[pymodule]
+    mod contentviews {
+        use crate::contentview::PyContentview;
+        use super::*;
+        use mitmproxy::contentviews::*;
+
+        #[pymodule_init]
+        fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+            m.add(
+                "hex",
+                PyContentview::new(m.py(), &HexStream())?
+            )
+        }
+    }
+
     #[pymodule_export]
     use crate::stream::Stream;
 

src/contentviews/mod.rs

@@ -0,0 +1,78 @@
+use std::num::ParseIntError;
+use anyhow::{Result};
+use pretty_hex::{HexConfig, PrettyHex};
+
+#[derive(Debug)]
+pub enum SerializeError {
+    InvalidFormat(String),
+}
+
+pub trait Contentview: Send + Sync {
+    fn name(&self) -> &str;
+    fn deserialize(&self, data: Vec<u8>) -> Result<String>;
+}
+
+pub trait SerializableContentview: Contentview {
+    fn serialize(&self, data: String) -> Result<Vec<u8>, SerializeError>;
+}
+
+#[derive(Default)]
+pub struct HexStream();
+
+impl Contentview for HexStream {
+    fn name(&self) -> &str {
+        "HexStream"
+    }
+
+    fn deserialize(&self, data: Vec<u8>) -> Result<String> {
+        Ok(data.hex_conf(HexConfig {
+            title: false,
+            ascii: false,
+            width: 0,
+            group: 0,
+            chunk: 0,
+            max_bytes: usize::MAX,
+            display_offset: 0,
+        }).to_string())
+    }
+}
+
+impl SerializableContentview for HexStream {
+    fn serialize(&self, data: String) -> Result<Vec<u8>, SerializeError> {
+        (0..data.len())
+            .step_by(2)
+            .map(|i| u8::from_str_radix(&data[i..i + 2], 16))
+            .collect::<Result<Vec<u8>, ParseIntError>>()
+            .map_err(
+                |e| SerializeError::InvalidFormat(format!("Failed to parse hex string: {}", e)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hexstream_deserialize() {
+        let hex_stream = HexStream::default();
+        let data = b"foo".to_vec();
+        let result = hex_stream.deserialize(data).unwrap();
+        assert_eq!(result, "666f6f");
+    }
+
+    #[test]
+    fn test_hexstream_deserialize_empty() {
+        let hex_stream = HexStream::default();
+        let data = vec![];
+        let result = hex_stream.deserialize(data).unwrap();
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn test_hexstream_serialize() {
+        let hex_stream = HexStream::default();
+        let data = "666f6f".to_string();
+        let result = hex_stream.serialize(data).unwrap();
+        assert_eq!(result, b"foo");
+    }
+}

src/lib.rs

@@ -1,6 +1,7 @@
 pub use network::MAX_PACKET_SIZE;
 
 pub mod certificates;
+pub mod contentviews;
 pub mod dns;
 pub mod intercept_conf;
 pub mod ipc;