tlspuffin/tls/
fn_utils.rs

1#![allow(clippy::ptr_arg)]
2#![allow(dead_code)]
3
4use puffin::algebra::error::FnError;
5use puffin::codec::{Codec, Reader};
6use puffin::protocol::{OpaqueProtocolMessageFlight, ProtocolMessageFlight};
7
8use crate::protocol::{MessageFlight, OpaqueMessageFlight};
9use crate::tls::key_exchange::{tls12_key_exchange, tls12_new_secrets};
10use crate::tls::key_schedule::*;
11use crate::tls::rustls::conn::Side;
12use crate::tls::rustls::hash_hs::HandshakeHash;
13use crate::tls::rustls::key::Certificate;
14use crate::tls::rustls::msgs::base::{Payload, PayloadU8};
15use crate::tls::rustls::msgs::enums::{CipherSuite, HandshakeType, NamedGroup, SignatureScheme};
16use crate::tls::rustls::msgs::handshake::{
17    CertificateEntries, CertificateEntry, ClientECDHParams, DigitallySignedStruct,
18    ECDHEServerKeyExchange, HandshakeMessagePayload, HandshakePayload, Random, ServerECDHParams,
19};
20use crate::tls::rustls::msgs::message::{Message, MessagePayload, OpaqueMessage, PlainMessage};
21use crate::tls::rustls::suites::SupportedCipherSuite;
22use crate::tls::rustls::tls12::{
23    self, TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
24    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
25};
26use crate::tls::rustls::tls13::key_schedule::KeyScheduleEarly;
27use crate::tls::rustls::tls13::{
28    TLS13_AES_128_GCM_SHA256, TLS13_AES_256_GCM_SHA384, TLS13_CHACHA20_POLY1305_SHA256,
29};
30use crate::tls::sign::rsa_sign;
31
32// ----
33// seed_client_attacker()
34// ----
35
36pub fn fn_new_transcript() -> Result<HandshakeHash, FnError> {
37    let suite = &crate::tls::rustls::tls13::TLS13_AES_128_GCM_SHA256;
38
39    let transcript = HandshakeHash::new(suite.hash_algorithm());
40    Ok(transcript)
41}
42
43pub fn fn_append_transcript(
44    transcript: &HandshakeHash,
45    message: &Message,
46) -> Result<HandshakeHash, FnError> {
47    let mut new_transcript: HandshakeHash = transcript.clone();
48    new_transcript.add_message(message);
49    Ok(new_transcript)
50}
51
52pub fn fn_new_hrr_transcript(original_client_hello: &Message) -> Result<HandshakeHash, FnError> {
53    let suite = &crate::tls::rustls::tls13::TLS13_AES_128_GCM_SHA256;
54
55    let mut transcript = HandshakeHash::new(suite.hash_algorithm());
56    transcript.add_message(original_client_hello);
57    transcript.rollup_for_hrr();
58    Ok(transcript)
59}
60
61/// Coalesce a `MessageFlight` into a single `OpaqueMessage`
62///
63/// This functions takes a flight of TLS messages and put them into a single TLS Record
64/// The type and version of the flight will use the type and version of the first messages included
65/// in the input flight.
66/// The resulting `OpaqueMessage` is not encrypted but is considered opaque as it doesn't contains
67/// only one message but multiple payloads with a common header.
68pub fn fn_coalesced_flight(flight: &MessageFlight) -> Result<OpaqueMessage, FnError> {
69    let mut payload = Payload::empty();
70
71    if flight.messages.is_empty() {
72        return Err(FnError::Malformed(
73            "Could not coalesce messages from empty flight".into(),
74        ));
75    }
76    let version = flight.messages[0].version;
77    let typ = flight.messages[0].payload.content_type();
78    for m in &flight.messages {
79        m.payload.encode(&mut payload.0);
80    }
81
82    Ok(OpaqueMessage {
83        version,
84        typ,
85        payload,
86    })
87}
88
89pub fn fn_new_flight() -> Result<MessageFlight, FnError> {
90    Ok(MessageFlight::new())
91}
92
93pub fn fn_append_flight(flight: &MessageFlight, msg: &Message) -> Result<MessageFlight, FnError> {
94    let mut new_flight = flight.clone();
95    new_flight.messages.push(msg.clone());
96    Ok(new_flight)
97}
98
99pub fn fn_new_opaque_flight() -> Result<OpaqueMessageFlight, FnError> {
100    Ok(OpaqueMessageFlight::new())
101}
102
103pub fn fn_append_opaque_flight(
104    flight: &OpaqueMessageFlight,
105    msg: &OpaqueMessage,
106) -> Result<OpaqueMessageFlight, FnError> {
107    let mut new_flight = flight.clone();
108    new_flight.messages.push(msg.clone());
109    Ok(new_flight)
110}
111
112pub fn suite_as_supported_suite(suite: &CipherSuite) -> Result<SupportedCipherSuite, FnError> {
113    match suite {
114        CipherSuite::TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 => {
115            Ok(TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256)
116        }
117        CipherSuite::TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 => {
118            Ok(TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384)
119        }
120        CipherSuite::TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 => {
121            Ok(TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256)
122        }
123        CipherSuite::TLS13_AES_128_GCM_SHA256 => Ok(TLS13_AES_128_GCM_SHA256),
124        CipherSuite::TLS13_AES_256_GCM_SHA384 => Ok(TLS13_AES_256_GCM_SHA384),
125        CipherSuite::TLS13_CHACHA20_POLY1305_SHA256 => Ok(TLS13_CHACHA20_POLY1305_SHA256),
126        _ => Err(FnError::Crypto("Unsupported ciphersuite".into())),
127    }
128}
129
130/// Decrypt encrypted handshake messages from a `MessageFlight` and return a Flight of decrypted
131/// messages.
132///
133/// This functions takes a `MessageFlight` and search for `ApplicationData` containing handshake
134/// related messages. The decrypted messages are put in an output `MessageFlight`. If some encrypted
135/// messages are coalesced messages, they will be split in different decrypted messages in the
136/// resulting `MessageFlight`
137pub fn fn_decrypt_handshake_flight(
138    flight: &MessageFlight,
139    server_hello_transcript: &HandshakeHash,
140    server_key_share: &Option<Vec<u8>>,
141    psk: &Option<Vec<u8>>,
142    group: &NamedGroup,
143    client: &bool,
144    sequence: &u64,
145    client_random: &Random,
146    suite: &CipherSuite,
147) -> Result<MessageFlight, FnError> {
148    let mut sequence_number = *sequence;
149
150    let mut decrypted_flight = MessageFlight::new();
151
152    for msg in &flight.messages {
153        if let MessagePayload::ApplicationData(_) = &msg.payload {
154            let decrypted_msg = fn_decrypt_multiple_handshake_messages(
155                msg,
156                server_hello_transcript,
157                server_key_share,
158                psk,
159                group,
160                client,
161                &sequence_number,
162                client_random,
163                suite,
164            )?;
165
166            decrypted_flight.messages.extend(decrypted_msg);
167            sequence_number += 1;
168        }
169    }
170
171    Ok(decrypted_flight)
172}
173
174/// Decrypt handshake messages by directly using the TLS handshake secret
175///
176/// This functions takes a `MessageFlight` and search for `ApplicationData` containing handshake
177/// related messages. The decrypted messages are put in an output `MessageFlight`. If some encrypted
178/// messages are coalesced messages, they will be split in different decrypted messages in the
179/// resulting `MessageFlight`
180pub fn fn_decrypt_handshake_flight_with_secret(
181    flight: &MessageFlight,
182    server_hello_transcript: &HandshakeHash,
183    client: &bool,
184    sequence: &u64,
185    client_random: &Random,
186    suite: &CipherSuite,
187    extracted_shared_secret: &Vec<u8>,
188) -> Result<MessageFlight, FnError> {
189    let mut sequence_number = *sequence;
190
191    let mut decrypted_flight = MessageFlight::new();
192
193    for msg in &flight.messages {
194        if let MessagePayload::ApplicationData(_) = &msg.payload {
195            let decrypted_msg = fn_decrypt_multiple_handshake_messages_with_secret(
196                msg,
197                server_hello_transcript,
198                client,
199                &sequence_number,
200                client_random,
201                suite,
202                extracted_shared_secret,
203            )?;
204
205            decrypted_flight.messages.extend(decrypted_msg);
206            sequence_number += 1;
207        }
208    }
209
210    Ok(decrypted_flight)
211}
212
213/// Decrypt an Application data message containing multiple handshake messages
214/// and return a vec of handshake messages
215pub fn fn_decrypt_multiple_handshake_messages(
216    application_data: &Message,
217    server_hello_transcript: &HandshakeHash,
218    server_key_share: &Option<Vec<u8>>,
219    psk: &Option<Vec<u8>>,
220    group: &NamedGroup,
221    client: &bool,
222    sequence: &u64,
223    client_random: &Random,
224    suite: &CipherSuite,
225) -> Result<Vec<Message>, FnError> {
226    let supported_suite = suite_as_supported_suite(suite)?;
227
228    let (key, _) = tls13_handshake_traffic_secret(
229        server_hello_transcript,
230        server_key_share,
231        psk,
232        !*client,
233        group,
234        client_random,
235        &supported_suite,
236    )?;
237
238    let decrypter = supported_suite
239        .tls13()
240        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
241        .derive_decrypter(&key);
242    let message = decrypter
243        .decrypt(
244            PlainMessage::from(application_data.clone()).into_unencrypted_opaque(),
245            *sequence,
246        )
247        .map_err(|_err| FnError::Crypto("Failed to decrypt it fn_decrypt_handshake".to_string()))?;
248
249    let payloads =
250        MessagePayload::multiple_new(message.typ, message.version, message.payload).unwrap();
251
252    let messages = payloads
253        .into_iter()
254        .map(|p| Message {
255            version: message.version,
256            payload: p,
257        })
258        .collect();
259
260    Ok(messages)
261}
262
263/// Decrypt an Application data message containing multiple handshake messages
264/// and return a vec of handshake messages
265pub fn fn_decrypt_multiple_handshake_messages_with_secret(
266    application_data: &Message,
267    server_hello_transcript: &HandshakeHash,
268    client: &bool,
269    sequence: &u64,
270    client_random: &Random,
271    suite: &CipherSuite,
272    extracted_shared_secret: &Vec<u8>,
273) -> Result<Vec<Message>, FnError> {
274    let supported_suite = suite_as_supported_suite(suite)?;
275
276    let (key, _) = tls13_handshake_traffic_secret_from_shared_secret(
277        server_hello_transcript,
278        client_random,
279        !*client,
280        &supported_suite,
281        extracted_shared_secret,
282    )?;
283
284    let decrypter = supported_suite
285        .tls13()
286        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
287        .derive_decrypter(&key);
288    let message = decrypter
289        .decrypt(
290            PlainMessage::from(application_data.clone()).into_unencrypted_opaque(),
291            *sequence,
292        )
293        .map_err(|_err| FnError::Crypto("Failed to decrypt it fn_decrypt_handshake".to_string()))?;
294
295    let payloads =
296        MessagePayload::multiple_new(message.typ, message.version, message.payload).unwrap();
297
298    let messages = payloads
299        .into_iter()
300        .map(|p| Message {
301            version: message.version,
302            payload: p,
303        })
304        .collect();
305
306    Ok(messages)
307}
308
309pub fn fn_find_server_certificate(flight: &MessageFlight) -> Result<Message, FnError> {
310    for msg in &flight.messages {
311        if let MessagePayload::Handshake(x) = &msg.payload {
312            if x.typ == HandshakeType::Certificate {
313                return Ok(msg.clone());
314            }
315        }
316    }
317    Err(FnError::Malformed("no server certificate".to_owned()))
318}
319
320pub fn fn_find_server_ticket(flight: &MessageFlight) -> Result<Message, FnError> {
321    for msg in &flight.messages {
322        if let MessagePayload::Handshake(x) = &msg.payload {
323            if x.typ == HandshakeType::NewSessionTicket {
324                return Ok(msg.clone());
325            }
326        }
327    }
328    Err(FnError::Malformed("no server tickets".to_owned()))
329}
330
331pub fn fn_find_server_certificate_request(flight: &MessageFlight) -> Result<Message, FnError> {
332    for msg in &flight.messages {
333        if let MessagePayload::Handshake(x) = &msg.payload {
334            if x.typ == HandshakeType::CertificateRequest {
335                return Ok(msg.clone());
336            }
337        }
338    }
339    Err(FnError::Malformed("no server tickets".to_owned()))
340}
341
342pub fn fn_find_encrypted_extensions(flight: &MessageFlight) -> Result<Message, FnError> {
343    for msg in &flight.messages {
344        if let MessagePayload::Handshake(x) = &msg.payload {
345            if x.typ == HandshakeType::EncryptedExtensions {
346                return Ok(msg.clone());
347            }
348        }
349    }
350    Err(FnError::Malformed("no encrypted extensions".to_owned()))
351}
352
353pub fn fn_find_server_certificate_verify(flight: &MessageFlight) -> Result<Message, FnError> {
354    for msg in &flight.messages {
355        if let MessagePayload::Handshake(x) = &msg.payload {
356            if x.typ == HandshakeType::CertificateVerify {
357                return Ok(msg.clone());
358            }
359        }
360    }
361    Err(FnError::Malformed("no certificate verify".to_owned()))
362}
363
364pub fn fn_find_server_finished(flight: &MessageFlight) -> Result<Message, FnError> {
365    for msg in &flight.messages {
366        if let MessagePayload::Handshake(x) = &msg.payload {
367            if x.typ == HandshakeType::Finished {
368                return Ok(msg.clone());
369            }
370        }
371    }
372    Err(FnError::Malformed("no finished".to_owned()))
373}
374
375pub fn fn_no_psk() -> Result<Option<Vec<u8>>, FnError> {
376    Ok(None)
377}
378
379pub fn fn_psk(some: &Vec<u8>) -> Result<Option<Vec<u8>>, FnError> {
380    Ok(Some(some.clone()))
381}
382
383/// Decrypt a whole flight of application messages and return a Vec of decrypted messages
384pub fn fn_decrypt_application_flight(
385    flight: &MessageFlight,
386    server_hello_transcript: &HandshakeHash,
387    server_finished_transcript: &HandshakeHash,
388    server_key_share: &Option<Vec<u8>>,
389    psk: &Option<Vec<u8>>,
390    group: &NamedGroup,
391    client: &bool,
392    sequence: &u64,
393    client_random: &Random,
394    suite: &CipherSuite,
395) -> Result<MessageFlight, FnError> {
396    let mut sequence_number = *sequence;
397
398    let mut decrypted_flight = MessageFlight::new();
399
400    for msg in &flight.messages {
401        if let MessagePayload::ApplicationData(_) = &msg.payload {
402            let decrypted_msg = fn_decrypt_application(
403                msg,
404                server_hello_transcript,
405                server_finished_transcript,
406                server_key_share,
407                psk,
408                group,
409                client,
410                &sequence_number,
411                client_random,
412                suite,
413            )?;
414
415            decrypted_flight.push(decrypted_msg);
416            sequence_number += 1;
417        }
418    }
419
420    Ok(decrypted_flight)
421}
422
423pub fn fn_decrypt_application(
424    application_data: &Message,
425    server_hello_transcript: &HandshakeHash,
426    server_finished_transcript: &HandshakeHash,
427    server_key_share: &Option<Vec<u8>>,
428    psk: &Option<Vec<u8>>,
429    group: &NamedGroup,
430    client: &bool,
431    sequence: &u64,
432    client_random: &Random,
433    suite: &CipherSuite,
434) -> Result<Message, FnError> {
435    let supported_suite = suite_as_supported_suite(suite)?;
436
437    let (key, _) = tls13_application_traffic_secret(
438        server_hello_transcript,
439        server_finished_transcript,
440        server_key_share,
441        psk,
442        group,
443        !*client,
444        client_random,
445        &supported_suite,
446    )?;
447    let decrypter = supported_suite
448        .tls13()
449        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
450        .derive_decrypter(&key);
451    let message = decrypter
452        .decrypt(
453            PlainMessage::from(application_data.clone()).into_unencrypted_opaque(),
454            *sequence,
455        )
456        .map_err(|_err| {
457            FnError::Crypto("Failed to decrypt it fn_decrypt_application".to_string())
458        })?;
459    Message::try_from(message)
460        .map_err(|_err| FnError::Crypto("Failed to create Message from decrypted data".to_string()))
461}
462
463/// Encrypt a single handshake `Message` and return an `OpaqueMessage`
464pub fn fn_encrypt_handshake(
465    some_message: &Message,
466    server_hello: &HandshakeHash,
467    server_key_share: &Option<Vec<u8>>,
468    psk: &Option<Vec<u8>>,
469    group: &NamedGroup,
470    client: &bool,
471    sequence: &u64,
472    client_random: &Random,
473    suite: &CipherSuite,
474) -> Result<OpaqueMessage, FnError> {
475    let supported_suite = suite_as_supported_suite(suite)?;
476
477    let (key, _) = tls13_handshake_traffic_secret(
478        server_hello,
479        server_key_share,
480        psk,
481        *client,
482        group,
483        client_random,
484        &supported_suite,
485    )?;
486    let encrypter = supported_suite
487        .tls13()
488        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
489        .derive_encrypter(&key);
490    let application_data = encrypter
491        .encrypt(PlainMessage::from(some_message.clone()).borrow(), *sequence)
492        .map_err(|_err| FnError::Crypto("Failed to encrypt it fn_encrypt_handshake".to_string()))?;
493    Ok(application_data)
494}
495
496/// Encrypt a handshake record that is already represented as an `OpaqueMessage`.
497///
498/// This differs from [`fn_encrypt_handshake`], which takes a parsed TLS `Message`
499/// and converts it into an encrypted `OpaqueMessage`.
500///
501/// Use this variant when you already have an opaque TLS handshake record (for
502/// example, a coalesced or pre-encoded handshake flight) and just need to apply
503/// the TLS 1.3 handshake encryption.
504pub fn fn_encrypt_handshake_opaque(
505    some_message: &OpaqueMessage,
506    server_hello: &HandshakeHash,
507    server_key_share: &Option<Vec<u8>>,
508    psk: &Option<Vec<u8>>,
509    group: &NamedGroup,
510    client: &bool,
511    sequence: &u64,
512    client_random: &Random,
513    suite: &CipherSuite,
514) -> Result<OpaqueMessage, FnError> {
515    let supported_suite = suite_as_supported_suite(suite)?;
516
517    let (key, _) = tls13_handshake_traffic_secret(
518        server_hello,
519        server_key_share,
520        psk,
521        *client,
522        group,
523        client_random,
524        &supported_suite,
525    )?;
526    let encrypter = supported_suite
527        .tls13()
528        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
529        .derive_encrypter(&key);
530    let application_data = encrypter
531        .encrypt(
532            some_message.clone().into_plain_message().borrow(),
533            *sequence,
534        )
535        .map_err(|_err| {
536            FnError::Crypto("Failed to encrypt it fn_encrypt_handshake_opaque".to_string())
537        })?;
538    Ok(application_data)
539}
540
541pub fn fn_encrypt_application(
542    some_message: &Message,
543    server_hello_transcript: &HandshakeHash,
544    server_finished_transcript: &HandshakeHash,
545    server_key_share: &Option<Vec<u8>>,
546    psk: &Option<Vec<u8>>,
547    group: &NamedGroup,
548    sequence: &u64,
549    client_random: &Random,
550    suite: &CipherSuite,
551) -> Result<OpaqueMessage, FnError> {
552    let supported_suite = suite_as_supported_suite(suite)?;
553
554    let (key, _) = tls13_application_traffic_secret(
555        server_hello_transcript,
556        server_finished_transcript,
557        server_key_share,
558        psk,
559        group,
560        true,
561        client_random,
562        &supported_suite,
563    )?;
564    let encrypter = supported_suite
565        .tls13()
566        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
567        .derive_encrypter(&key);
568    let application_data = encrypter
569        .encrypt(PlainMessage::from(some_message.clone()).borrow(), *sequence)
570        .map_err(|_err| {
571            FnError::Crypto("Failed to encrypt it fn_encrypt_application".to_string())
572        })?;
573    Ok(application_data)
574}
575
576pub fn fn_derive_psk(
577    server_hello: &HandshakeHash,
578    server_finished: &HandshakeHash,
579    client_finished: &HandshakeHash,
580    server_key_share: &Option<Vec<u8>>,
581    new_ticket_nonce: &Vec<u8>,
582    group: &NamedGroup,
583    client_random: &Random,
584    suite: &CipherSuite,
585) -> Result<Vec<u8>, FnError> {
586    let supported_suite = suite_as_supported_suite(suite)?;
587    let psk = tls13_derive_psk(
588        server_hello,
589        server_finished,
590        client_finished,
591        server_key_share,
592        new_ticket_nonce,
593        group,
594        client_random,
595        &supported_suite,
596    )?;
597
598    Ok(psk)
599}
600
601pub fn fn_derive_binder(
602    full_client_hello: &Message,
603    psk: &Vec<u8>,
604    suite: &CipherSuite,
605) -> Result<Vec<u8>, FnError> {
606    let client_hello_payload: HandshakeMessagePayload = match full_client_hello.payload.clone() {
607        MessagePayload::Handshake(payload) => Some(payload),
608        _ => None,
609    }
610    .ok_or_else(|| {
611        FnError::Malformed("Only can fill binder in HandshakeMessagePayload".to_owned())
612    })?;
613
614    let supported_suite = suite_as_supported_suite(suite)?;
615    let hkdf_alg = supported_suite
616        .tls13()
617        .ok_or_else(|| FnError::Crypto("No tls 1.3 suite".to_owned()))?
618        .hkdf_algorithm;
619    let suite_hash = supported_suite.hash_algorithm();
620
621    let transcript = HandshakeHash::new(suite_hash);
622
623    // RFC: The "pre_shared_key" extension MUST be the last extension in the ClientHello
624    // The binder is calculated over the clienthello, but doesn't include itself or its
625    // length, or the length of its container.
626    let binder_plaintext = client_hello_payload.get_encoding_for_binder_signing();
627    let handshake_hash = transcript.get_hash_given(&binder_plaintext);
628
629    // Run a fake key_schedule to simulate what the server will do if it chooses
630    // to resume.
631    let key_schedule = KeyScheduleEarly::new(hkdf_alg, psk);
632    let real_binder = key_schedule.resumption_psk_binder_key_and_sign_verify_data(&handshake_hash);
633
634    Ok(Vec::from(real_binder.as_ref()))
635}
636
637pub fn fn_fill_binder(full_client_hello: &Message, binder: &Vec<u8>) -> Result<Message, FnError> {
638    match full_client_hello.payload.clone() {
639        MessagePayload::Handshake(payload) => match payload.payload {
640            HandshakePayload::ClientHello(payload) => {
641                let mut new_payload = payload;
642                new_payload.set_psk_binder(binder.clone());
643                Some(Message {
644                    version: full_client_hello.version,
645                    payload: MessagePayload::Handshake(HandshakeMessagePayload {
646                        typ: HandshakeType::ClientHello,
647                        payload: HandshakePayload::ClientHello(new_payload),
648                    }),
649                })
650            }
651            _ => None,
652        },
653        _ => None,
654    }
655    .ok_or_else(|| {
656        FnError::Malformed("[fn_fill_binder] Could not find ticket in message".to_owned())
657    })
658}
659
660pub fn fn_get_ticket(new_ticket: &Message) -> Result<Vec<u8>, FnError> {
661    match new_ticket.payload.clone() {
662        MessagePayload::Handshake(payload) => match payload.payload {
663            HandshakePayload::NewSessionTicketTLS13(payload) => Some(payload.ticket.0),
664            _ => None,
665        },
666        _ => None,
667    }
668    .ok_or_else(|| {
669        FnError::Malformed("[fn_get_ticket] Could not find ticket in message".to_owned())
670    })
671}
672
673pub fn fn_get_ticket_age_add(new_ticket: &Message) -> Result<u64, FnError> {
674    match new_ticket.payload.clone() {
675        MessagePayload::Handshake(payload) => match payload.payload {
676            HandshakePayload::NewSessionTicketTLS13(payload) => Some(payload.age_add as u64),
677            _ => None,
678        },
679        _ => None,
680    }
681    .ok_or_else(|| FnError::Malformed("Could not find ticket in message".to_owned()))
682}
683
684pub fn fn_get_ticket_nonce(new_ticket: &Message) -> Result<Vec<u8>, FnError> {
685    match new_ticket.payload.clone() {
686        MessagePayload::Handshake(payload) => match payload.payload {
687            HandshakePayload::NewSessionTicketTLS13(payload) => Some(payload.nonce.0),
688            _ => None,
689        },
690        _ => None,
691    }
692    .ok_or_else(|| {
693        FnError::Malformed("[fn_get_ticket_nonce] Could not find ticket in message".to_owned())
694    })
695}
696
697// ----
698// seed_client_attacker12()
699// ----
700
701pub fn fn_new_transcript12() -> Result<HandshakeHash, FnError> {
702    let suite = &tls12::TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256;
703
704    let transcript = HandshakeHash::new(suite.hash_algorithm());
705    Ok(transcript)
706}
707
708pub fn fn_decode_server_ecdh_pubkey(data: &Vec<u8>) -> Result<Vec<u8>, FnError> {
709    let mut rd = Reader::init(data.as_slice());
710    let params = ServerECDHParams::read(&mut rd)
711        .ok_or_else(|| FnError::Codec("Failed to parse server ecdh public key".to_string()))?;
712    Ok(params.public.0)
713}
714
715pub fn fn_decode_client_ecdh_pubkey(data: &Vec<u8>) -> Result<Vec<u8>, FnError> {
716    let mut rd = Reader::init(data.as_slice());
717    let params = ClientECDHParams::read(&mut rd)
718        .ok_or_else(|| FnError::Codec("Failed to parse client ecdh public key".to_string()))?;
719    Ok(params.public.0)
720}
721
722pub fn fn_sign_rsa_ecdhe_server_key_exchange12(
723    group: &NamedGroup,
724    client_random: &Random,
725    server_random: &Random,
726    private_key: &Vec<u8>,
727) -> Result<Vec<u8>, FnError> {
728    let kx = tls12_key_exchange(group)?;
729    let params = ServerECDHParams::new(*group, kx.pubkey.as_ref());
730
731    // Assemble the TLS 1.2 signed data: client_random || server_random || ServerECDHParams
732    let mut params_bytes = Vec::new();
733    params.encode(&mut params_bytes);
734    let mut message = Vec::new();
735    message.extend_from_slice(&client_random.0);
736    message.extend_from_slice(&server_random.0);
737    message.extend_from_slice(&params_bytes);
738
739    let scheme = SignatureScheme::RSA_PKCS1_SHA256;
740    let sig = rsa_sign(&message, private_key, &scheme)?;
741
742    let dss = DigitallySignedStruct::new(scheme, sig);
743    let ske = ECDHEServerKeyExchange { params, dss };
744    let mut buf = Vec::new();
745    ske.encode(&mut buf);
746    Ok(buf)
747}
748
749pub fn fn_new_pubkey12(group: &NamedGroup) -> Result<Vec<u8>, FnError> {
750    let kx = tls12_key_exchange(group)?;
751    Ok(Vec::from(kx.pubkey.as_ref()))
752}
753
754pub fn fn_encode_ec_pubkey12(pubkey: &PayloadU8) -> Result<Vec<u8>, FnError> {
755    let mut buf = Vec::new();
756    let ecpoint = pubkey.clone();
757    ecpoint.encode(&mut buf);
758
759    Ok(buf)
760}
761
762pub fn fn_encrypt12(
763    message: &Message,
764    server_random: &Random,
765    peer_ecdh_pubkey: &Vec<u8>,
766    group: &NamedGroup,
767    client: &bool,
768    sequence: &u64,
769    client_random: &Random,
770    suite: &CipherSuite,
771) -> Result<OpaqueMessage, FnError> {
772    let supported_suite = suite_as_supported_suite(suite)?;
773
774    let secrets = tls12_new_secrets(
775        server_random,
776        peer_ecdh_pubkey,
777        group,
778        client_random,
779        supported_suite,
780    )?;
781
782    let (_decrypter, encrypter) = secrets.make_cipher_pair(match *client {
783        true => Side::Client,
784        false => Side::Server,
785    });
786    let encrypted = encrypter
787        .encrypt(PlainMessage::from(message.clone()).borrow(), *sequence)
788        .map_err(|_err| FnError::Crypto("Failed to encrypt it fn_encrypt12".to_string()))?;
789    Ok(encrypted)
790}
791
792pub fn fn_decrypt12(
793    message: &Message,
794    server_random: &Random,
795    peer_ecdh_pubkey: &Vec<u8>,
796    group: &NamedGroup,
797    client: &bool,
798    sequence: &u64,
799    client_random: &Random,
800    suite: &CipherSuite,
801) -> Result<Message, FnError> {
802    let supported_suite = suite_as_supported_suite(suite)?;
803
804    let secrets = tls12_new_secrets(
805        server_random,
806        peer_ecdh_pubkey,
807        group,
808        client_random,
809        supported_suite,
810    )?;
811
812    let (decrypter, _encrypter) = secrets.make_cipher_pair(match *client {
813        true => Side::Client,
814        false => Side::Server,
815    });
816
817    let opaque = PlainMessage::from(message.clone()).into_unencrypted_opaque();
818
819    let plain = decrypter
820        .decrypt(opaque, *sequence)
821        .map_err(|_err| FnError::Crypto("Failed to decrypt it fn_decrypt12".to_string()))?;
822
823    Message::try_from(plain)
824        .map_err(|_| FnError::Codec("Failed to parse decrypted TLS 1.2 message".to_string()))
825}
826
827pub fn fn_new_certificate() -> Result<Certificate, FnError> {
828    let der_cert = hex::decode(
829        "308203473082022fa003020102021406f7fb1d20\
830    b39f71b9a222e8f03a0ab0a79ec54d300d060\
831    92a864886f70d01010b05003033310b30090603550406130241553113301106035504080c0a536f6d652d5374617465\
832    310f300d060355040a0c064861636b6572301e170d3231303731393135323135355a170d32323037313931353231353\
833    55a3033310b30090603550406130241553113301106035504080c0a536f6d652d5374617465310f300d060355040a0c\
834    064861636b657230820122300d06092a864886f70d01010105000382010f003082010a0282010100b7e0f550fa3a22d\
835    6dea0278b03e806a561f283e9bfc20c2b6cef8ae0c7c7e665813fda782a7a27745669044fe0e6627ec89fa63914df80\
836    17d1a52b85057c318512242ad9416b957d74f06263fab9c75c0cb039c2256a4254b41863fa5d8f73114eaa1ccde793d\
837    68ddae7254868d38341768104c9f673262b8bc958cab2a4d763547d744979adfec46497e5b8daf322c5332a86683abc\
838    0a034592436c18321720800baac3c555606ecb1c2aa2b279ddf33f653009f6bd41f7e508f5e53613e9543a865934c28\
839    8ec9558af93d710b093b5f58e053117d3b5a860e489ee5e9cb46ac76b639533ae06ff2d40f476a7f58a90c139d7c03e\
840    17a85ec1426ae1f5b7bbad0203010001a3533051301d0603551d0e04160414f31e256fa78c3cc82c01f1bf46c9b2bfb\
841    6b39da7301f0603551d23041830168014f31e256fa78c3cc82c01f1bf46c9b2bfb6b39da7300f0603551d130101ff04\
842    0530030101ff300d06092a864886f70d01010b05000382010100aacd9f5f166718736c2290f6dcbec1ff19c2f5ab339\
843    0e253fbf6ad3acdcf192a7b8a18f624244b85b68e9bf49dbce18005edb77a271dc6edd7afb427689829f190385b99f4\
844    4f58ab901bf269a1b29eb9fc5603dfd67452544ec19fa51c2af29e4ce2667b778262abad12cca57f8c8a6ab1db57309\
845    2640eda09ec6a001f48c8fa9996c90f0ae6726b12c69b59e18bc16c9c116a373aabdc4bb62b41c77859d2909eba9936\
846    161df1ba38891e9bddec0f196bdcfc9a8801d4e066d4b258a9c072c6f4f13a80da85c75102b7cecae60987997c6b8c3\
847    56bef671e44bc3aceb6e15590befb11b76efb6ee89c69820b91e1ba9d11d0324e961e9b0cb98e38ea2414ae94",
848    );
849    Ok(Certificate(der_cert.map_err(|_err| {
850        FnError::Codec("Failed to load DER certificate".to_string())
851    })?))
852}
853
854pub fn fn_new_certificates() -> Result<Vec<Certificate>, FnError> {
855    Ok(vec![])
856}
857
858pub fn fn_append_certificate(
859    certs: &Vec<Certificate>,
860    cert: &Certificate,
861) -> Result<Vec<Certificate>, FnError> {
862    let mut new_certs = certs.clone();
863    new_certs.push(cert.clone());
864
865    Ok(new_certs)
866}
867
868pub fn fn_new_certificate_entries() -> Result<Vec<CertificateEntry>, FnError> {
869    Ok(vec![])
870}
871
872pub fn fn_certificate_entries_make(
873    entries: &Vec<CertificateEntry>,
874) -> Result<CertificateEntries, FnError> {
875    Ok(CertificateEntries(entries.clone()))
876}
877
878pub fn fn_append_certificate_entries(
879    certs: &Vec<CertificateEntry>,
880    cert_entry: &CertificateEntry,
881) -> Result<Vec<CertificateEntry>, FnError> {
882    let mut new_certs = certs.clone();
883    new_certs.push(cert_entry.clone());
884
885    Ok(new_certs)
886}
887
888pub fn fn_named_group_secp256r1() -> Result<NamedGroup, FnError> {
889    Ok(NamedGroup::secp256r1)
890}
891
892pub fn fn_named_group_secp384r1() -> Result<NamedGroup, FnError> {
893    Ok(NamedGroup::secp384r1)
894}
895
896pub fn fn_named_group_x25519() -> Result<NamedGroup, FnError> {
897    Ok(NamedGroup::X25519)
898}
899
900pub fn fn_u64_to_u32(input: &u64) -> Result<u32, FnError> {
901    Ok(*input as u32)
902}
903
904pub fn fn_u32_to_u16(input: &u32) -> Result<u16, FnError> {
905    Ok(*input as u16)
906}
tlspuffin/tls/fn_utils.rs

tlspuffin/tls/
fn_utils.rs
