1use std::sync::Arc;
2
3#[cfg(feature = "smol")]
4use futures_rustls::rustls;
5
6#[cfg(feature = "tokio")]
7use tokio_rustls::rustls;
8
9use rustls::{
10 CertificateError, DigitallySignedStruct, DistinguishedName,
11 Error::InvalidCertificate,
12 SignatureScheme, SupportedCipherSuite, SupportedProtocolVersion,
13 client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
14 crypto::{
15 CryptoProvider, SupportedKxGroup,
16 aws_lc_rs::{self, cipher_suite::TLS13_CHACHA20_POLY1305_SHA256, kx_group},
17 },
18 server::danger::{ClientCertVerified, ClientCertVerifier},
19};
20
21use rustls_pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime};
22
23use log::error;
24use rcgen::PublicKeyData;
25use x509_parser::{asn1_rs::Oid, certificate::X509Certificate, parse_x509_certificate};
26
27use karyon_core::crypto::{KeyPair, KeyPairType, PublicKey};
28
29use crate::{PeerID, Result};
30
31#[cfg(feature = "quic")]
32use rustls::crypto::aws_lc_rs::cipher_suite::TLS13_AES_128_GCM_SHA256;
33
34static PROTOCOL_VERSIONS: &[&SupportedProtocolVersion] = &[&rustls::version::TLS13];
37static CIPHER_SUITES: &[SupportedCipherSuite] = &[TLS13_CHACHA20_POLY1305_SHA256];
38#[cfg(feature = "quic")]
41static QUIC_CIPHER_SUITES: &[SupportedCipherSuite] =
42 &[TLS13_CHACHA20_POLY1305_SHA256, TLS13_AES_128_GCM_SHA256];
43static KX_GROUPS: &[&dyn SupportedKxGroup] = &[kx_group::X25519];
44static SIGNATURE_SCHEMES: &[SignatureScheme] = &[SignatureScheme::ED25519];
45
46const PEER_ID_EXT_OID: &[u64] = &[0, 0, 0, 0];
49
50const BAD_SIGNATURE_ERR: rustls::Error = InvalidCertificate(CertificateError::BadSignature);
51const BAD_ENCODING_ERR: rustls::Error = InvalidCertificate(CertificateError::BadEncoding);
52
53pub fn tls_client_config(
55 key_pair: &KeyPair,
56 peer_id: Option<PeerID>,
57) -> Result<rustls::ClientConfig> {
58 client_config(key_pair, peer_id, CIPHER_SUITES)
59}
60
61#[cfg(feature = "quic")]
63pub fn quic_client_config(
64 key_pair: &KeyPair,
65 peer_id: Option<PeerID>,
66) -> Result<rustls::ClientConfig> {
67 client_config(key_pair, peer_id, QUIC_CIPHER_SUITES)
68}
69
70pub fn tls_server_config(key_pair: &KeyPair) -> Result<rustls::ServerConfig> {
72 server_config(key_pair, CIPHER_SUITES)
73}
74
75#[cfg(feature = "quic")]
77pub fn quic_server_config(key_pair: &KeyPair) -> Result<rustls::ServerConfig> {
78 server_config(key_pair, QUIC_CIPHER_SUITES)
79}
80
81fn client_config(
82 key_pair: &KeyPair,
83 peer_id: Option<PeerID>,
84 cipher_suites: &[SupportedCipherSuite],
85) -> Result<rustls::ClientConfig> {
86 let (cert, private_key) = generate_cert(key_pair)?;
87 let server_verifier = SrvrCertVerifier { peer_id };
88
89 let client_config = rustls::ClientConfig::builder_with_provider(
90 CryptoProvider {
91 kx_groups: KX_GROUPS.to_vec(),
92 cipher_suites: cipher_suites.to_vec(),
93 ..aws_lc_rs::default_provider()
94 }
95 .into(),
96 )
97 .with_protocol_versions(PROTOCOL_VERSIONS)?
98 .dangerous()
99 .with_custom_certificate_verifier(Arc::new(server_verifier))
100 .with_client_auth_cert(vec![cert], private_key)?;
101
102 Ok(client_config)
103}
104
105fn server_config(
106 key_pair: &KeyPair,
107 cipher_suites: &[SupportedCipherSuite],
108) -> Result<rustls::ServerConfig> {
109 let (cert, private_key) = generate_cert(key_pair)?;
110 let client_verifier = CliCertVerifier {};
111 let server_config = rustls::ServerConfig::builder_with_provider(
112 CryptoProvider {
113 kx_groups: KX_GROUPS.to_vec(),
114 cipher_suites: cipher_suites.to_vec(),
115 ..aws_lc_rs::default_provider()
116 }
117 .into(),
118 )
119 .with_protocol_versions(PROTOCOL_VERSIONS)?
120 .with_client_cert_verifier(Arc::new(client_verifier))
121 .with_single_cert(vec![cert], private_key)?;
122
123 Ok(server_config)
124}
125
126fn generate_cert<'a>(key_pair: &KeyPair) -> Result<(CertificateDer<'a>, PrivateKeyDer<'a>)> {
128 let cert_key_pair = rcgen::KeyPair::generate_for(&rcgen::PKCS_ED25519)?;
129 let private_key = PrivateKeyDer::Pkcs8(cert_key_pair.serialize_der().into());
130
131 let signature = key_pair.sign(&cert_key_pair.subject_public_key_info());
135 let ext_content = yasna::encode_der(&(key_pair.public().as_bytes().to_vec(), signature));
136 let mut ext = rcgen::CustomExtension::from_oid_content(PEER_ID_EXT_OID, ext_content);
137 ext.set_criticality(false);
141
142 let mut params = rcgen::CertificateParams::new(vec![])?;
143 params.custom_extensions.push(ext);
144
145 let cert = CertificateDer::from(params.self_signed(&cert_key_pair)?);
146 Ok((cert, private_key))
147}
148
149pub(crate) fn peer_id_from_certs(certs: &[CertificateDer<'_>]) -> Option<PeerID> {
153 let end_entity = certs.first()?;
154 verify_cert(end_entity).ok()
155}
156
157fn verify_cert(end_entity: &CertificateDer<'_>) -> std::result::Result<PeerID, rustls::Error> {
159 let cert = parse_cert(end_entity)?;
161
162 let want_oid = Oid::from(PEER_ID_EXT_OID).map_err(|_| BAD_ENCODING_ERR)?;
164 let ext = cert
165 .extensions()
166 .iter()
167 .find(|e| e.oid == want_oid)
168 .ok_or(BAD_ENCODING_ERR)?;
169
170 let (public_key, signature): (Vec<u8>, Vec<u8>) =
172 yasna::decode_der(ext.value).map_err(|_| BAD_ENCODING_ERR)?;
173
174 let public_key =
176 PublicKey::from_bytes(&KeyPairType::Ed25519, &public_key).map_err(|_| BAD_ENCODING_ERR)?;
177 public_key
178 .verify(cert.public_key().raw, &signature)
179 .map_err(|_| BAD_SIGNATURE_ERR)?;
180
181 verify_cert_signature(
183 &cert,
184 cert.tbs_certificate.as_ref(),
185 cert.signature_value.as_ref(),
186 )?;
187
188 PeerID::try_from(public_key).map_err(|_| BAD_ENCODING_ERR)
189}
190
191fn parse_cert<'a>(
193 end_entity: &'a CertificateDer<'a>,
194) -> std::result::Result<X509Certificate<'a>, rustls::Error> {
195 let (_, cert) = parse_x509_certificate(end_entity.as_ref()).map_err(|_| BAD_ENCODING_ERR)?;
196
197 if !cert.validity().is_valid() {
198 return Err(InvalidCertificate(CertificateError::NotValidYet));
199 }
200
201 Ok(cert)
202}
203
204fn verify_cert_signature(
206 cert: &X509Certificate,
207 message: &[u8],
208 signature: &[u8],
209) -> std::result::Result<(), rustls::Error> {
210 let public_key = PublicKey::from_bytes(
211 &KeyPairType::Ed25519,
212 cert.tbs_certificate.subject_pki.subject_public_key.as_ref(),
213 )
214 .map_err(|_| BAD_ENCODING_ERR)?;
215
216 public_key
217 .verify(message, signature)
218 .map_err(|_| BAD_SIGNATURE_ERR)
219}
220
221#[derive(Debug)]
222struct SrvrCertVerifier {
223 peer_id: Option<PeerID>,
224}
225
226impl ServerCertVerifier for SrvrCertVerifier {
227 fn verify_server_cert(
228 &self,
229 end_entity: &CertificateDer<'_>,
230 _intermediates: &[CertificateDer<'_>],
231 _server_name: &ServerName,
232 _ocsp_response: &[u8],
233 _now: UnixTime,
234 ) -> std::result::Result<ServerCertVerified, rustls::Error> {
235 let peer_id = match verify_cert(end_entity) {
236 Ok(pid) => pid,
237 Err(err) => {
238 error!("Failed to verify cert: {err}");
239 return Err(err);
240 }
241 };
242
243 if let Some(pid) = &self.peer_id
247 && pid != &peer_id
248 {
249 return Err(InvalidCertificate(
250 CertificateError::ApplicationVerificationFailure,
251 ));
252 }
253
254 Ok(ServerCertVerified::assertion())
255 }
256
257 fn verify_tls12_signature(
258 &self,
259 _message: &[u8],
260 _cert: &CertificateDer<'_>,
261 _dss: &DigitallySignedStruct,
262 ) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
263 unreachable!("ONLY SUPPORT tls 13 VERSION")
264 }
265
266 fn verify_tls13_signature(
267 &self,
268 message: &[u8],
269 cert: &CertificateDer<'_>,
270 dss: &DigitallySignedStruct,
271 ) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
272 let cert = parse_cert(cert)?;
273 verify_cert_signature(&cert, message, dss.signature())?;
274 Ok(HandshakeSignatureValid::assertion())
275 }
276
277 fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
278 SIGNATURE_SCHEMES.to_vec()
279 }
280}
281
282#[derive(Debug)]
283struct CliCertVerifier {}
284impl ClientCertVerifier for CliCertVerifier {
285 fn verify_client_cert(
286 &self,
287 end_entity: &CertificateDer<'_>,
288 _intermediates: &[CertificateDer<'_>],
289 _now: UnixTime,
290 ) -> std::result::Result<ClientCertVerified, rustls::Error> {
291 if let Err(err) = verify_cert(end_entity) {
292 error!("Failed to verify cert: {err}");
293 return Err(err);
294 };
295 Ok(ClientCertVerified::assertion())
296 }
297
298 fn root_hint_subjects(&self) -> &[DistinguishedName] {
299 &[]
300 }
301
302 fn verify_tls12_signature(
303 &self,
304 _message: &[u8],
305 _cert: &CertificateDer<'_>,
306 _dss: &DigitallySignedStruct,
307 ) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
308 unreachable!("ONLY SUPPORT tls 13 VERSION")
309 }
310
311 fn verify_tls13_signature(
312 &self,
313 message: &[u8],
314 cert: &CertificateDer<'_>,
315 dss: &DigitallySignedStruct,
316 ) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
317 let cert = parse_cert(cert)?;
318 verify_cert_signature(&cert, message, dss.signature())?;
319 Ok(HandshakeSignatureValid::assertion())
320 }
321
322 fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
323 SIGNATURE_SCHEMES.to_vec()
324 }
325}
326
327#[cfg(test)]
328mod tests {
329 use super::*;
330
331 #[test]
332 fn verify_generated_certificate() {
333 let key_pair = KeyPair::generate(&KeyPairType::Ed25519);
334 let (cert, _) = generate_cert(&key_pair).unwrap();
335
336 let result = verify_cert(&cert);
337 assert!(result.is_ok());
338 let peer_id = result.unwrap();
339 assert_eq!(peer_id, PeerID::try_from(key_pair.public()).unwrap());
340 assert_eq!(peer_id.0, key_pair.public().as_bytes());
341 }
342}