tls_parser/
tls_debug.rs

1use alloc::format;
2use alloc::vec::Vec;
3use core::fmt;
4use core::str::from_utf8;
5use rusticata_macros::debug::HexSlice;
6
7use crate::tls_alert::*;
8use crate::tls_dh::*;
9use crate::tls_ec::*;
10use crate::tls_extensions::*;
11use crate::tls_handshake::*;
12use crate::tls_record::*;
13use crate::tls_sign_hash::*;
14
15// ------------------------- tls.rs ------------------------------
16impl<'a> fmt::Debug for TlsClientHelloContents<'a> {
17    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
18        fmt.debug_struct("TlsClientHelloContents")
19            .field("version", &self.version)
20            .field("random", &HexSlice(self.random))
21            .field("session_id", &self.session_id.map(HexSlice))
22            .field("ciphers", &self.ciphers)
23            .field("comp", &self.comp)
24            .field("ext", &self.ext.map(HexSlice))
25            .finish()
26    }
27}
28
29impl<'a> fmt::Debug for TlsServerHelloContents<'a> {
30    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
31        fmt.debug_struct("TlsServerHelloContents")
32            .field("version", &self.version)
33            .field("random", &HexSlice(self.random))
34            .field("session_id", &self.session_id.map(HexSlice))
35            .field("cipher", &self.cipher)
36            .field("compression", &self.compression)
37            .field("ext", &self.ext.map(HexSlice))
38            .finish()
39    }
40}
41
42impl<'a> fmt::Debug for TlsServerHelloV13Draft18Contents<'a> {
43    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44        fmt.debug_struct("TlsServerHelloV13Draft18Contents")
45            .field("version", &self.version)
46            .field("random", &HexSlice(self.random))
47            .field("cipher", &self.cipher)
48            .field("ext", &self.ext.map(HexSlice))
49            .finish()
50    }
51}
52
53impl<'a> fmt::Debug for TlsHelloRetryRequestContents<'a> {
54    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
55        fmt.debug_struct("TlsHelloRetryRequestContents")
56            .field("version", &self.version)
57            .field("ext", &self.ext.map(HexSlice))
58            .finish()
59    }
60}
61
62impl<'a> fmt::Debug for RawCertificate<'a> {
63    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
64        fmt.debug_struct("RawCertificate")
65            .field("data", &HexSlice(self.data))
66            .finish()
67    }
68}
69
70impl<'a> fmt::Debug for TlsServerKeyExchangeContents<'a> {
71    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
72        fmt.debug_struct("TlsServerKeyExchangeContents")
73            .field("parameters", &HexSlice(self.parameters))
74            .finish()
75    }
76}
77
78impl<'a> fmt::Debug for TlsClientKeyExchangeContents<'a> {
79    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
80        match *self {
81            TlsClientKeyExchangeContents::Dh(p) => fmt.write_fmt(format_args!("{:?}", HexSlice(p))),
82            TlsClientKeyExchangeContents::Ecdh(ref p) => fmt.write_fmt(format_args!("{:?}", p)),
83            TlsClientKeyExchangeContents::Unknown(p) => {
84                fmt.write_fmt(format_args!("{:?}", HexSlice(p)))
85            }
86        }
87    }
88}
89
90impl fmt::Debug for TlsRecordHeader {
91    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
92        fmt.debug_struct("TlsRecordHeader")
93            .field("type", &self.record_type)
94            .field("version", &self.version)
95            .field("len", &self.len)
96            .finish()
97    }
98}
99
100// ------------------------- tls_alert.rs ------------------------------
101impl fmt::Debug for TlsMessageAlert {
102    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
103        fmt.debug_struct("TlsMessageAlert")
104            .field("severity", &self.severity)
105            .field("code", &self.code)
106            .finish()
107    }
108}
109
110// ------------------------- tls_dh.rs ------------------------------
111impl<'a> fmt::Debug for ServerDHParams<'a> {
112    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
113        let gs = self.dh_g.len() * 8;
114        fmt.debug_struct("ServerDHParams")
115            .field("group size", &gs)
116            .field("dh_p", &HexSlice(self.dh_p))
117            .field("dh_g", &HexSlice(self.dh_g))
118            .field("dh_ys", &HexSlice(self.dh_ys))
119            .finish()
120    }
121}
122
123// ------------------------- tls_ec.rs ------------------------------
124impl<'a> fmt::Debug for ECParametersContent<'a> {
125    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
126        match *self {
127            ECParametersContent::ExplicitPrime(ref p) => {
128                fmt.write_fmt(format_args!("ExplicitPrime({:?})", p))
129            }
130            // ECParametersContent::ExplicitChar2(ref p) => {
131            //     fmt.write_fmt(format_args!("ExplicitChar2({:?})", HexSlice(p)))
132            // }
133            ECParametersContent::NamedGroup(p) => write!(fmt, "{}", p),
134        }
135    }
136}
137
138impl<'a> fmt::Debug for ECParameters<'a> {
139    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
140        fmt.debug_struct("ECParameters")
141            .field("curve_type", &format!("{}", self.curve_type))
142            .field("params_content", &self.params_content)
143            .finish()
144    }
145}
146
147// ------------------------- tls_extensions.rs ------------------------------
148impl<'a> fmt::Debug for TlsExtension<'a> {
149    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
150        match *self {
151            TlsExtension::SNI(ref v) => {
152                let v: Vec<_> = v
153                    .iter()
154                    .map(|&(ty, n)| {
155                        let s = from_utf8(n).unwrap_or("<error decoding utf8 string>");
156                        format!("type={},name={}", ty, s)
157                    })
158                    .collect();
159                write!(fmt, "TlsExtension::SNI({:?})", v)
160            }
161            TlsExtension::MaxFragmentLength(l) => {
162                write!(fmt, "TlsExtension::MaxFragmentLength({})", l)
163            }
164            TlsExtension::StatusRequest(data) => {
165                write!(fmt, "TlsExtension::StatusRequest({:?})", data)
166            }
167            TlsExtension::EllipticCurves(ref v) => {
168                let v2: Vec<_> = v.iter().map(|&curve| format!("{}", curve)).collect();
169                write!(fmt, "TlsExtension::EllipticCurves({:?})", v2)
170            }
171            TlsExtension::EcPointFormats(v) => write!(fmt, "TlsExtension::EcPointFormats({:?})", v),
172            TlsExtension::SignatureAlgorithms(ref v) => {
173                let v2: Vec<_> = v
174                    .iter()
175                    .map(|&alg| {
176                        let s = format!("{}", SignatureScheme(alg));
177                        if s.starts_with("SignatureScheme") {
178                            format!(
179                                "{}",
180                                SignatureAndHashAlgorithm {
181                                    hash: HashAlgorithm((alg >> 8) as u8),
182                                    sign: SignAlgorithm((alg & 0xff) as u8)
183                                }
184                            )
185                        } else {
186                            s
187                        }
188                    })
189                    .collect();
190                write!(fmt, "TlsExtension::SignatureAlgorithms({:?})", v2)
191            }
192            TlsExtension::SessionTicket(data) => {
193                write!(fmt, "TlsExtension::SessionTicket(data={:?})", data)
194            }
195            TlsExtension::RecordSizeLimit(data) => {
196                write!(fmt, "TlsExtension::RecordSizeLimit(data={})", data)
197            }
198            TlsExtension::KeyShareOld(data) => {
199                write!(fmt, "TlsExtension::KeyShareOld(data={:?})", HexSlice(data))
200            }
201            TlsExtension::KeyShare(data) => {
202                write!(fmt, "TlsExtension::KeyShare(data={:?})", HexSlice(data))
203            }
204            TlsExtension::PreSharedKey(data) => {
205                write!(fmt, "TlsExtension::PreSharedKey(data={:?})", HexSlice(data))
206            }
207            TlsExtension::EarlyData(o) => write!(fmt, "TlsExtension::EarlyData({:?})", o),
208            TlsExtension::SupportedVersions(ref v) => {
209                let v2: Vec<_> = v.iter().map(|c| format!("{}", c)).collect();
210                write!(fmt, "TlsExtension::SupportedVersions(v={:?})", v2)
211            }
212            TlsExtension::Cookie(data) => write!(fmt, "TlsExtension::Cookie(data={:?})", data),
213            TlsExtension::PskExchangeModes(ref v) => {
214                write!(fmt, "TlsExtension::PskExchangeModes({:?})", v)
215            }
216            TlsExtension::Heartbeat(mode) => write!(fmt, "TlsExtension::Heartbeat(mode={})", mode),
217            TlsExtension::ALPN(ref v) => {
218                let v: Vec<_> = v
219                    .iter()
220                    .map(|c| from_utf8(c).unwrap_or("<error decoding utf8 string>"))
221                    .collect();
222                write!(fmt, "TlsExtension::ALPN({:?})", v)
223            }
224            TlsExtension::SignedCertificateTimestamp(data) => write!(
225                fmt,
226                "TlsExtension::SignedCertificateTimestamp(data={:?})",
227                data
228            ),
229            TlsExtension::Padding(data) => write!(fmt, "TlsExtension::Padding(data={:?})", data),
230            TlsExtension::EncryptThenMac => write!(fmt, "TlsExtension::EncryptThenMac"),
231            TlsExtension::ExtendedMasterSecret => write!(fmt, "TlsExtension::ExtendedMasterSecret"),
232            TlsExtension::OidFilters(ref v) => {
233                let v: Vec<_> = v.iter().map(|c| format!("{:?}", c)).collect();
234                write!(fmt, "TlsExtension::OidFilters({:?})", v)
235            }
236            TlsExtension::PostHandshakeAuth => write!(fmt, "TlsExtension::PostHandshakeAuth"),
237            TlsExtension::NextProtocolNegotiation => {
238                write!(fmt, "TlsExtension::NextProtocolNegotiation")
239            }
240            TlsExtension::RenegotiationInfo(data) => {
241                write!(fmt, "TlsExtension::RenegotiationInfo(data={:?})", data)
242            }
243            TlsExtension::EncryptedServerName {
244                ciphersuite, group, ..
245            } => write!(
246                fmt,
247                "TlsExtension::EncryptedServerName{{cipher: {:?}, group: {:?} ..}}",
248                ciphersuite, group
249            ),
250            TlsExtension::Grease(t, data) => write!(
251                fmt,
252                "TlsExtension::Grease(0x{:x},data={:?})",
253                t,
254                HexSlice(data)
255            ),
256            TlsExtension::Unknown(t, data) => write!(
257                fmt,
258                "TlsExtension::Unknown(type=0x{:x},data={:?})",
259                t.0, data
260            ),
261        }
262    }
263}
264
265// ------------------------- tls_sign_hash.rs ------------------------------
266impl fmt::Display for SignatureAndHashAlgorithm {
267    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
268        write!(fmt, "HashSign({},{})", self.hash, self.sign)
269    }
270}
271
272impl fmt::Debug for SignatureAndHashAlgorithm {
273    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
274        write!(
275            fmt,
276            "SignatureAndHashAlgorithm({},{})",
277            self.hash, self.sign
278        )
279    }
280}
281
282impl<'a> fmt::Debug for DigitallySigned<'a> {
283    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
284        fmt.debug_struct("DigitallySigned")
285            .field("alg", &self.alg)
286            .field("data", &HexSlice(self.data))
287            .finish()
288    }
289}
tls_parser/tls_debug.rs

tls_parser/
tls_debug.rs
