slinger-mitm 0.0.5

MITM proxy with transparent traffic interception using rustls backend for slinger
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

//! Error types for MITM proxy

use std::io;
use thiserror::Error;

/// Result type for MITM operations
pub type Result<T> = std::result::Result<T, Error>;

/// Error types for MITM proxy operations
#[derive(Error, Debug)]
pub enum Error {
  /// IO error
  #[error("IO error: {0}")]
  Io(io::Error),

  /// Certificate error
  #[error("Certificate error: {0}")]
  CertificateError(String),

  /// TLS error
  #[error("TLS error: {0}")]
  TlsError(String),

  /// HTTP parsing error
  #[error("HTTP error: {0}")]
  HttpError(http::Error),

  /// Slinger client error
  #[error("Slinger error: {0}")]
  SlingerError(slinger::Error),

  /// Proxy error
  #[error("Proxy error: {0}")]
  ProxyError(String),

  /// Invalid request
  #[error("Invalid request: {0}")]
  InvalidRequest(String),

  /// Connection error
  #[error("Connection error: {0}")]
  ConnectionError(String),

  /// Other errors
  #[error("{0}")]
  Other(String),
}

impl Error {
  /// Create a certificate error and log it
  pub fn certificate_error(msg: impl Into<String>) -> Self {
    let error = Error::CertificateError(msg.into());
    tracing::error!("Certificate error: {}", error);
    error
  }

  /// Create a TLS error and log it
  pub fn tls_error(msg: impl Into<String>) -> Self {
    let error = Error::TlsError(msg.into());
    tracing::error!("TLS error: {}", error);
    error
  }

  /// Create a proxy error and log it
  pub fn proxy_error(msg: impl Into<String>) -> Self {
    let error = Error::ProxyError(msg.into());
    tracing::error!("Proxy error: {}", error);
    error
  }

  /// Create an invalid request error and log it
  pub fn invalid_request(msg: impl Into<String>) -> Self {
    let error = Error::InvalidRequest(msg.into());
    tracing::error!("Invalid request: {}", error);
    error
  }

  /// Create a connection error and log it
  pub fn connection_error(msg: impl Into<String>) -> Self {
    let error = Error::ConnectionError(msg.into());
    tracing::error!("Connection error: {}", error);
    error
  }

  /// Create an other error and log it
  pub fn other(msg: impl Into<String>) -> Self {
    let error = Error::Other(msg.into());
    tracing::error!("Other error: {}", error);
    error
  }
}

impl From<io::Error> for Error {
  fn from(value: io::Error) -> Self {
    let error = Error::Io(value);
    tracing::error!("IO error: {}", error);
    error
  }
}

impl From<http::Error> for Error {
  fn from(value: http::Error) -> Self {
    let error = Error::HttpError(value);
    tracing::error!("HTTP error: {}", error);
    error
  }
}

impl From<slinger::Error> for Error {
  fn from(value: slinger::Error) -> Self {
    let error = Error::SlingerError(value);
    tracing::error!("Slinger error: {}", error);
    error
  }
}