security_claims/
ffi.rs

1#![allow(dead_code)]
2#![allow(non_camel_case_types)]
3#![allow(non_upper_case_globals)]
4#![allow(clippy::all)]
5
6use std::ffi::c_void;
7use std::fmt;
8
9pub type TLSLike = *const c_void;
10
11pub const CLAIM_INTERFACE_H: &str =
12    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/claim-interface.h"));
13
14include!(concat!(env!("OUT_DIR"), "/claim-interface.rs"));
15
16impl fmt::Display for Claim {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        write!(
19            f,
20            "\
21            typ: {},\
22            write: {},\
23            version: {},\
24            server: {},\
25            session_id: {},\
26            server_random: {},\
27            client_random: {},\
28            cert: {},\
29            peer_cert: {},\
30            peer_tmp_skey_type: {},\
31            peer_tmp_skey_security_bits: {},\
32            tmp_skey_type: {},\
33            tmp_skey_group_id: {},\
34            signature_algorithm: {},\
35            peer_signature_algorithm: {},\
36            early_secret: {},\
37            handshake_secret: {},\
38            master_secret: {},\
39            resumption_master_secret: {},\
40            client_finished_secret: {},\
41            server_finished_secret: {},\
42            server_finished_hash: {},\
43            handshake_traffic_hash: {},\
44            client_app_traffic_secret: {},\
45            server_app_traffic_secret: {},\
46            exporter_master_secret: {},\
47            early_exporter_master_secret: {},\
48            master_secret_12: {},\
49            available_ciphers: {},\
50            chosen_cipher: {},\
51            transcript: {},\
52            ",
53            self.typ,
54            self.write,
55            self.version,
56            self.server,
57            self.session_id,
58            self.server_random,
59            self.client_random,
60            self.cert,
61            self.peer_cert,
62            self.peer_tmp_skey_type,
63            self.peer_tmp_skey_security_bits,
64            self.tmp_skey_type,
65            self.tmp_skey_group_id,
66            self.signature_algorithm,
67            self.peer_signature_algorithm,
68            self.early_secret,
69            self.handshake_secret,
70            self.master_secret,
71            self.resumption_master_secret,
72            self.client_finished_secret,
73            self.server_finished_secret,
74            self.server_finished_hash,
75            self.handshake_traffic_hash,
76            self.client_app_traffic_secret,
77            self.server_app_traffic_secret,
78            self.exporter_master_secret,
79            self.early_exporter_master_secret,
80            self.master_secret_12,
81            self.available_ciphers,
82            self.chosen_cipher,
83            self.transcript,
84        )
85    }
86}
87
88impl fmt::Display for ClaimVersion {
89    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
90        write!(f, "{:?}", self.data)
91    }
92}
93
94impl fmt::Display for ClaimTranscript {
95    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
96        write!(f, "{}", hex::encode(self.data))
97    }
98}
99
100impl fmt::Display for ClaimCipher {
101    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102        write!(f, "{}", hex::encode(self.data.to_be_bytes()))
103    }
104}
105
106impl fmt::Display for ClaimSessionId {
107    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
108        write!(f, "{}", hex::encode(&self.data[0..self.length as usize]),)
109    }
110}
111
112impl fmt::Display for ClaimRandom {
113    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
114        write!(f, "{}", hex::encode(self.data))
115    }
116}
117
118impl fmt::Display for ClaimCertData {
119    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
120        write!(
121            f,
122            "{:?}({}b)",
123            self.key_type,
124            if self.key_length == 0 {
125                "?".to_string()
126            } else {
127                self.key_length.to_string()
128            }
129        )
130    }
131}
132
133impl fmt::Display for ClaimCiphers {
134    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
135        write!(
136            f,
137            "{}",
138            self.ciphers[0..self.length as usize]
139                .iter()
140                .map(|c| hex::encode(c.data.to_be_bytes()))
141                .collect::<Vec<String>>()
142                .join(", ")
143        )
144    }
145}
146
147impl fmt::Display for ClaimType {
148    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
149        write!(f, "{:?}", self)
150    }
151}
152
153impl fmt::Display for ClaimKeyType {
154    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
155        write!(f, "{:?}", self)
156    }
157}
158
159impl fmt::Display for ClaimSecret {
160    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
161        let secret = self.secret;
162        // print if any byte is set
163        if secret.iter().any(|v| *v != 0) {
164            write!(f, "{}", hex::encode(secret))?;
165        }
166
167        Ok(())
168    }
169}