Skip to main content

karyon_p2p/
tls_config.rs

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
34// NOTE: This code needs a comprehensive audit.
35
36static PROTOCOL_VERSIONS: &[&SupportedProtocolVersion] = &[&rustls::version::TLS13];
37static CIPHER_SUITES: &[SupportedCipherSuite] = &[TLS13_CHACHA20_POLY1305_SHA256];
38/// QUIC also needs AES-128-GCM: quinn uses it to protect the initial packets.
39/// ChaCha20 stays first so it is still preferred for the session.
40#[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
46/// OID for the karyon peer-id custom extension.
47// TODO: not standards-conformant. Replace with a registered one.
48const 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
53/// Returns a TLS client configuration.
54pub 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/// Returns a TLS client configuration for QUIC.
62#[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
70/// Returns a TLS server configuration.
71pub fn tls_server_config(key_pair: &KeyPair) -> Result<rustls::ServerConfig> {
72    server_config(key_pair, CIPHER_SUITES)
73}
74
75/// Returns a TLS server configuration for QUIC.
76#[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
126/// Generates a certificate and returns both the certificate and the private key.
127fn 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    // Add a custom extension to the certificate:
132    //   - Sign the certificate's public key with the provided key pair's private key
133    //   - Append both the computed signature and the key pair's public key to the extension
134    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    // XXX: Non-critical because rustls rejects unknown critical extensions
138    // before our custom verifiers can run. The extension is still validated
139    // by verify_cert() which requires it to be present and checks the signature.
140    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
149/// Derive the peer id from a peer's certificate chain post-handshake.
150/// Reuses `verify_cert` so the validation rules stay in one place.
151/// Returns `None` if the chain is empty or the cert lacks our extension.
152pub(crate) fn peer_id_from_certs(certs: &[CertificateDer<'_>]) -> Option<PeerID> {
153    let end_entity = certs.first()?;
154    verify_cert(end_entity).ok()
155}
156
157/// Verifies the given certification.
158fn verify_cert(end_entity: &CertificateDer<'_>) -> std::result::Result<PeerID, rustls::Error> {
159    // Parse the certificate.
160    let cert = parse_cert(end_entity)?;
161
162    // Find our custom extension by OID, not by position.
163    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    // Extract the peer id (public key) and the signature from the extension.
171    let (public_key, signature): (Vec<u8>, Vec<u8>) =
172        yasna::decode_der(ext.value).map_err(|_| BAD_ENCODING_ERR)?;
173
174    // Use the peer id (public key) to verify the extracted signature.
175    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 the certificate signature.
182    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
191/// Parses the given x509 certificate.
192fn 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
204/// Verifies the signature of the given certificate.
205fn 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        // Verify that the peer id in the certificate's extension matches the
244        // one the client intends to connect to.
245        // Both should be equal for establishing a fully secure connection.
246        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}