1#![allow(dead_code)]
4
5use puffin::agent::{AgentDescriptor, AgentName};
6use puffin::algebra::dynamic_function::TypeShape;
7use puffin::algebra::{DYTerm, Term};
8use puffin::trace::{Action, InputAction, OutputAction, Precomputation, Step, Trace};
9use puffin::{input_action, term};
10
11use crate::protocol::{
12 AgentType, MessageFlight, TLSDescriptorConfig, TLSProtocolBehavior, TLSProtocolTypes,
13 TLSVersion,
14};
15use crate::query::TlsQueryMatcher;
16use crate::tls::fn_impl::*;
17use crate::tls::rustls::msgs::enums::{CipherSuite, Compression, HandshakeType, ProtocolVersion};
18use crate::tls::rustls::msgs::handshake::{Random, ServerExtensions, SessionID};
19use crate::tls::rustls::msgs::message::{Message, OpaqueMessage};
20
21pub fn seed_successful_client_auth(
22 client: AgentName,
23 server: AgentName,
24) -> Trace<TLSProtocolTypes> {
25 Trace {
26 prior_traces: vec![],
27 descriptors: vec![
28 AgentDescriptor::from_config(
29 client,
30 TLSDescriptorConfig {
31 tls_version: TLSVersion::V1_3,
32 typ: AgentType::Client,
33 client_authentication: true,
34 ..TLSDescriptorConfig::default()
35 },
36 ),
37 AgentDescriptor::from_config(
38 server,
39 TLSDescriptorConfig {
40 tls_version: TLSVersion::V1_3,
41 typ: AgentType::Server,
42 client_authentication: true,
43 ..TLSDescriptorConfig::default()
44 },
45 ),
46 ],
47 steps: vec![
48 OutputAction::new_step(client),
49 Step {
51 agent: server,
52 action: Action::Input(input_action! { term! {
53 fn_client_hello(
54 ((client, 0)),
55 ((client, 0)),
56 ((client, 0)),
57 ((client, 0)),
58 ((client, 0)),
59 ((client, 0))
60 )
61 }
62 }),
63 },
64 Step {
66 agent: client,
67 action: Action::Input(input_action! { term! {
68 fn_server_hello(
69 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/ProtocolVersion),
70 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/Random),
71 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/SessionID),
72 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/CipherSuite),
73 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/Compression),
74 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/ServerExtensions)
75 )
76 }
77 }),
78 },
79 Step {
81 agent: client,
82 action: Action::Input(input_action! { term! {
83 fn_application_data(
84 ((server, 0)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
85 )
86 }
87 }),
88 },
89 Step {
91 agent: client,
92 action: Action::Input(input_action! {term! {
93 fn_application_data(
94 ((server, 1)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
95 )
96 }
97 }),
98 },
99 Step {
101 agent: client,
102 action: Action::Input(input_action! {term! {
103 fn_application_data(
104 ((server, 2)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
105 )
106 }
107 }),
108 },
109 Step {
111 agent: client,
112 action: Action::Input(input_action! {term! {
113 fn_application_data(
114 ((server, 3)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
115 )
116 }
117 }),
118 },
119 Step {
121 agent: client,
122 action: Action::Input(input_action! { term! {
123 fn_application_data(
124 ((server, 4)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
125 )
126 }
127 }),
128 },
129 Step {
131 agent: server,
132 action: Action::Input(input_action! { term! {
133 fn_application_data(
134 ((client, 0)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
135 )
136 }
137 }),
138 },
139 Step {
141 agent: server,
142 action: Action::Input(input_action! { term! {
143 fn_application_data(
144 ((client, 1)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
145 )
146 }
147 }),
148 },
149 Step {
151 agent: server,
152 action: Action::Input(input_action! { term! {
153 fn_application_data(
154 ((client, 2)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
155 )
156 }
157 }),
158 },
159 ],
160 ..Default::default()
161 }
162}
163
164pub fn seed_successful(client: AgentName, server: AgentName) -> Trace<TLSProtocolTypes> {
166 Trace {
167 prior_traces: vec![],
168 descriptors: vec![
169 TLSDescriptorConfig::new_client(client, TLSVersion::V1_3),
170 TLSDescriptorConfig::new_server(server, TLSVersion::V1_3),
171 ],
172 steps: vec![
173 OutputAction::new_step(client),
174 Step {
176 agent: server,
177 action: Action::Input(input_action! { term! {
178 (client, 0)/MessageFlight
179 }
180 }),
181 },
182 Step {
185 agent: client,
186 action: Action::Input(input_action! { term! {
187 (server, 0)/MessageFlight
188 }
189 }),
190 },
191 Step {
193 agent: server,
194 action: Action::Input(input_action! { term! {
195 (client, 1)/MessageFlight
196 }
197 }),
198 },
199 ],
200 ..Default::default()
201 }
202}
203
204pub fn seed_successful_mitm(client: AgentName, server: AgentName) -> Trace<TLSProtocolTypes> {
206 Trace {
207 prior_traces: vec![],
208 descriptors: vec![
209 TLSDescriptorConfig::new_client(client, TLSVersion::V1_3),
210 TLSDescriptorConfig::new_server(server, TLSVersion::V1_3),
211 ],
212 steps: vec![
213 OutputAction::new_step(client),
214 Step {
216 agent: server,
217 action: Action::Input(input_action! { term! {
218 fn_client_hello(
219 ((client, 0)),
220 ((client, 0)),
221 ((client, 0)),
222 (fn_cipher_suites_make(
223 (fn_append_cipher_suite(
224 fn_new_cipher_suites,
225 fn_cipher_suite13_aes_128_gcm_sha256
226 ))
227 )),
228 ((client, 0)),
229 ((client, 0))
230 )
231 }
232 }),
233 },
234 Step {
237 agent: client,
238 action: Action::Input(input_action! { term! {
239 (server, 0)/MessageFlight
240 }
241 }),
242 },
243 Step {
245 agent: server,
246 action: Action::Input(input_action! { term! {
247 (client, 1)/MessageFlight
248 }
249 }),
250 },
251 ],
252 ..Default::default()
253 }
254}
255
256pub fn seed_successful12_with_tickets(
258 client: AgentName,
259 server: AgentName,
260) -> Trace<TLSProtocolTypes> {
261 let mut trace = seed_successful12(client, server);
262 trace.steps.insert(
265 9,
266 Step {
267 agent: client,
268 action: Action::Input(input_action! { term! {
269 fn_new_session_ticket(
270 ((server, 0)/u32),
271 (fn_payload_u16(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::NewSessionTicket)))]/Vec<u8>)))
272 )
273 }
274 }),
275 },
276 );
277
278 trace.steps[11] = Step {
279 agent: client,
280 action: Action::Input(input_action! { term! {
281 (server, 6)[None]> TypeShape::of::<OpaqueMessage>()
282 }
283 }),
284 };
285
286 trace
287}
288
289pub fn seed_successful12(client: AgentName, server: AgentName) -> Trace<TLSProtocolTypes> {
290 Trace {
291 prior_traces: vec![],
292 descriptors: vec![
293 TLSDescriptorConfig::new_client(client, TLSVersion::V1_2),
294 TLSDescriptorConfig::new_server(server, TLSVersion::V1_2),
295 ],
296 steps: vec![
297 OutputAction::new_step(client),
298 InputAction::new_step(
300 server,
301 term! {
302 fn_client_hello(
303 ((client, 0)),
304 ((client, 0)),
305 ((client, 0)),
306 ((client, 0)),
307 ((client, 0)),
308 ((client, 0))
309 )
310 },
311 ),
312 InputAction::new_step(
314 client,
315 term! {
316 fn_server_hello(
317 ((server, 0)),
318 ((server, 0)),
319 ((server, 0)),
320 ((server, 0)),
321 ((server, 0)),
322 ((server, 0))
323 )
324 },
325 ),
326 Step {
328 agent: client,
329 action: Action::Input(input_action! { term! {
330 fn_certificate(
331 ((server, 0))
332 )
333 }
334 }),
335 },
336 Step {
338 agent: client,
339 action: Action::Input(input_action! { term! {
340 fn_server_key_exchange(
341 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerKeyExchange)))]/Vec<u8>)
342 )
343 }
344 }),
345 },
346 Step {
348 agent: client,
349 action: Action::Input(input_action! { term! {
350 fn_server_hello_done
351 }
352 }),
353 },
354 Step {
356 agent: server,
357 action: Action::Input(input_action! { term! {
358 fn_client_key_exchange(
359 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientKeyExchange)))]/Vec<u8>)
360 )
361 }
362 }),
363 },
364 Step {
366 agent: server,
367 action: Action::Input(input_action! { term! {
368 fn_change_cipher_spec
369 }
370 }),
371 },
372 Step {
377 agent: server,
378 action: Action::Input(input_action! { term! {
379 (client, 3)[None] > TypeShape::of::<OpaqueMessage>()
380 }
381 }),
382 },
383 Step {
385 agent: client,
386 action: Action::Input(input_action! { term! {
387 fn_change_cipher_spec
388 }
389 }),
390 },
391 Step {
393 agent: client,
394 action: Action::Input(input_action! { term! {
395 (server, 5)[None] > TypeShape::of::<OpaqueMessage>()
396 }
397 }),
398 },
399 ],
400 ..Default::default()
401 }
402}
403
404pub fn seed_successful12_forward(client: AgentName, server: AgentName) -> Trace<TLSProtocolTypes> {
407 Trace {
408 prior_traces: vec![],
409 descriptors: vec![
410 TLSDescriptorConfig::new_client(client, TLSVersion::V1_2),
411 TLSDescriptorConfig::new_server(server, TLSVersion::V1_2),
412 ],
413 steps: vec![
414 OutputAction::new_step(client),
415 Step {
417 agent: server,
418 action: Action::Input(input_action! { term! {
419 (client, 0)/MessageFlight
420 }
421 }),
422 },
423 Step {
426 agent: client,
427 action: Action::Input(input_action! { term! {
428 (server, 0)/MessageFlight
429 }
430 }),
431 },
432 Step {
434 agent: server,
435 action: Action::Input(input_action! { term! {
436 (client, 1)/MessageFlight
437 }
438 }),
439 },
440 Step {
441 agent: client,
442 action: Action::Input(input_action! { term! {
443 (server, 1)/MessageFlight
444 }
445 }),
446 },
447 ],
448 ..Default::default()
449 }
450}
451
452pub fn seed_successful_with_ccs(client: AgentName, server: AgentName) -> Trace<TLSProtocolTypes> {
454 Trace {
455 prior_traces: vec![],
456 descriptors: vec![
457 TLSDescriptorConfig::new_client(client, TLSVersion::V1_3),
458 TLSDescriptorConfig::new_server(server, TLSVersion::V1_3),
459 ],
460 steps: vec![
461 OutputAction::new_step(client),
462 Step {
464 agent: server,
465 action: Action::Input(input_action! { term! {
466 fn_client_hello(
467 ((client, 0)),
468 ((client, 0)),
469 ((client, 0)),
470 ((client, 0)),
471 ((client, 0)),
472 ((client, 0))
473 )
474 }
475 }),
476 },
477 Step {
479 agent: client,
480 action: Action::Input(input_action! { term! {
481 fn_server_hello(
482 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/ProtocolVersion),
483 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/Random),
484 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/SessionID),
485 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/CipherSuite),
486 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/Compression),
487 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]/ServerExtensions)
488 )
489 }
490 }),
491 },
492 Step {
494 agent: client,
495 action: Action::Input(input_action! { term! {
496 fn_change_cipher_spec
497 }
498 }),
499 },
500 Step {
502 agent: client,
503 action: Action::Input(input_action! { term! {
504 fn_application_data(
505 ((server, 0)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
506 )
507 }
508 }),
509 },
510 Step {
512 agent: client,
513 action: Action::Input(input_action! { term! {
514 fn_application_data(
515 ((server, 1)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
516 )
517 }
518 }),
519 },
520 Step {
522 agent: client,
523 action: Action::Input(input_action! { term! {
524 fn_application_data(
525 ((server, 2)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
526 )
527 }
528 }),
529 },
530 Step {
532 agent: client,
533 action: Action::Input(input_action! { term! {
534 fn_application_data(
535 ((server, 3)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
536 )
537 }
538 }),
539 },
540 Step {
541 agent: server,
542 action: Action::Input(input_action! { term! {
543 fn_change_cipher_spec
544 }
545 }),
546 },
547 Step {
549 agent: server,
550 action: Action::Input(input_action! { term! {
551 fn_application_data(
552 ((client, 0)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
553 )
554 }
555 }),
556 },
557 ],
558 ..Default::default()
559 }
560}
561
562pub fn seed_successful_with_tickets(
564 client: AgentName,
565 server: AgentName,
566) -> Trace<TLSProtocolTypes> {
567 let mut trace = seed_successful_with_ccs(client, server);
568
569 trace.steps.push(OutputAction::new_step(server));
570 trace.steps.push(Step {
572 agent: client,
573 action: Action::Input(input_action! { term! {
574 fn_application_data(
575 ((server, 4)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
576 )
577 }
578 }),
579 });
580
581 trace.steps.push(Step {
582 agent: client,
583 action: Action::Input(input_action! { term! {
584 fn_application_data(
585 ((server, 5)[Some(TlsQueryMatcher::ApplicationData)]/Vec<u8>)
586 )
587 }
588 }),
589 });
590
591 trace
592}
593
594pub fn seed_server_attacker_full(client: AgentName) -> Trace<TLSProtocolTypes> {
596 let curve = term! {
597 fn_get_any_client_curve(
598 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))])
599 )
600 };
601
602 let server_hello = term! {
603 fn_server_hello(
604 fn_protocol_version12,
605 fn_new_random,
606 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]),
607 fn_cipher_suite13_aes_128_gcm_sha256,
608 fn_compression,
609 (fn_server_extensions_make(
610 (fn_server_extensions_append(
611 (fn_server_extensions_append(
612 fn_server_extensions_new,
613 (fn_key_share_server_extension(
614 (fn_key_share_deterministic((@curve)))
615 ))
616 )),
617 fn_supported_versions13_server_extension
618 ))))
619 )
620 };
621
622 let server_hello_transcript = term! {
623 fn_append_transcript(
624 (fn_append_transcript(
625 fn_new_transcript,
626 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]) )),
628 (@server_hello) )
630 };
631
632 let encrypted_extensions = term! {
633 fn_encrypted_extensions(
634 fn_server_extensions_new
635 )
636 };
637
638 let certificate = term! {
639 fn_certificate13(
640 (fn_payload_u8((fn_empty_bytes_vec))),
641 (fn_certificate_entries_make(
642 (fn_chain_append_certificate_entry(
643 fn_empty_certificate_chain,
644 (fn_certificate_entry_extensions(
645 fn_alice_cert,
646 (fn_cert_extensions_make(
647 fn_cert_extensions_new
648 ))
649 ))))
650 ))
651 )
652 };
653
654 let encrypted_extensions_transcript = term! {
655 fn_append_transcript(
656 (@server_hello_transcript),
657 (@encrypted_extensions) )
659 };
660
661 let certificate_transcript = term! {
662 fn_append_transcript(
663 (@encrypted_extensions_transcript),
664 (@certificate) )
666 };
667
668 let certificate_verify = term! {
669 fn_certificate_verify(
670 fn_rsa_pss_signature_algorithm,
671 (fn_payload_u16(
672 (fn_rsa_sign_server(
673 (@certificate_transcript),
674 fn_alice_key,
675 fn_rsa_pss_signature_algorithm
676 ))
677 ))
678 )
679 };
680
681 let certificate_verify_transcript = term! {
682 fn_append_transcript(
683 (@certificate_transcript),
684 (@certificate_verify) )
686 };
687
688 let server_finished = term! {
689 fn_finished(
690 (fn_verify_data_server(
691 (@certificate_verify_transcript),
692 (@server_hello_transcript),
694 (fn_get_client_key_share(((client, 0)), (@curve))),
695 (@curve),
696 fn_no_psk,
697 fn_new_random,
698 fn_cipher_suite13_aes_128_gcm_sha256
699 ))
700 )
701 };
702
703 Trace {
704 prior_traces: vec![],
705 descriptors: vec![AgentDescriptor::from_config(
706 client,
707 TLSDescriptorConfig {
708 tls_version: TLSVersion::V1_3,
709 typ: AgentType::Client,
710 ..TLSDescriptorConfig::default()
711 },
712 )],
713 steps: vec![
714 OutputAction::new_step(client),
715 Step {
716 agent: client,
717 action: Action::Input(input_action! { server_hello
718 }),
719 },
720 Step {
721 agent: client,
722 action: Action::Input(input_action! { term! {
723 fn_encrypt_handshake(
724 (@encrypted_extensions),
725 (@server_hello_transcript),
726 (fn_get_client_key_share(((client, 0)), (@curve))),
727 fn_no_psk,
728 (@curve),
729 fn_false,
730 fn_seq_0, fn_new_random,
732 fn_cipher_suite13_aes_128_gcm_sha256
733 )
734 }
735 }),
736 },
737 Step {
738 agent: client,
739 action: Action::Input(input_action! { term! {
740 fn_encrypt_handshake(
741 (@certificate),
742 (@server_hello_transcript),
743 (fn_get_client_key_share(((client, 0)), (@curve))),
744 fn_no_psk,
745 (@curve),
746 fn_false,
747 fn_seq_1, fn_new_random,
749 fn_cipher_suite13_aes_128_gcm_sha256
750 )
751 }
752 }),
753 },
754 Step {
755 agent: client,
756 action: Action::Input(input_action! { term! {
757 fn_encrypt_handshake(
758 (@certificate_verify),
759 (@server_hello_transcript),
760 (fn_get_client_key_share(((client, 0)), (@curve))),
761 fn_no_psk,
762 (@curve),
763 fn_false,
764 fn_seq_2, fn_new_random,
766 fn_cipher_suite13_aes_128_gcm_sha256
767 )
768 }
769 }),
770 },
771 Step {
772 agent: client,
773 action: Action::Input(input_action! { term! {
774 fn_encrypt_handshake(
775 (@server_finished),
776 (@server_hello_transcript),
777 (fn_get_client_key_share(((client, 0)), (@curve))),
778 fn_no_psk,
779 (@curve),
780 fn_false,
781 fn_seq_3, fn_new_random,
783 fn_cipher_suite13_aes_128_gcm_sha256
784 )
785 }
786 }),
787 },
788 ],
789 ..Default::default()
790 }
791}
792
793pub fn seed_server_attacker_full_coalesced(client: AgentName) -> Trace<TLSProtocolTypes> {
794 let curve = term! {
795 fn_get_any_client_curve(
796 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))])
797 )
798 };
799
800 let server_hello = term! {
801 fn_server_hello(
802 fn_protocol_version12,
803 fn_new_random,
804 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]),
805 fn_cipher_suite13_aes_128_gcm_sha256,
806 fn_compression,
807 (fn_server_extensions_make(
808 (fn_server_extensions_append(
809 (fn_server_extensions_append(
810 fn_server_extensions_new,
811 (fn_key_share_server_extension(
812 (fn_key_share_deterministic((@curve)))
813 ))
814 )),
815 fn_supported_versions13_server_extension
816 ))))
817 )
818 };
819
820 let server_hello_transcript = term! {
821 fn_append_transcript(
822 (fn_append_transcript(
823 fn_new_transcript,
824 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]) )),
826 (@server_hello) )
828 };
829
830 let encrypted_extensions = term! {
831 fn_encrypted_extensions(
832 fn_server_extensions_new
833 )
834 };
835
836 let certificate = term! {
837 fn_certificate13(
838 (fn_payload_u8((fn_empty_bytes_vec))),
839 (fn_certificate_entries_make(
840 (fn_chain_append_certificate_entry(
841 fn_empty_certificate_chain,
842 (fn_certificate_entry_extensions(
843 fn_alice_cert,
844 (fn_cert_extensions_make(
845 fn_cert_extensions_new
846 ))
847 ))))
848 ))
849 )
850 };
851
852 let encrypted_extensions_transcript = term! {
853 fn_append_transcript(
854 (@server_hello_transcript),
855 (@encrypted_extensions) )
857 };
858
859 let certificate_transcript = term! {
860 fn_append_transcript(
861 (@encrypted_extensions_transcript),
862 (@certificate) )
864 };
865
866 let certificate_verify = term! {
867 fn_certificate_verify(
868 fn_rsa_pss_signature_algorithm,
869 (fn_payload_u16(
870 (fn_rsa_sign_server(
871 (@certificate_transcript),
872 fn_alice_key,
873 fn_rsa_pss_signature_algorithm
874 ))
875 ))
876 )
877 };
878
879 let certificate_verify_transcript = term! {
880 fn_append_transcript(
881 (@certificate_transcript),
882 (@certificate_verify) )
884 };
885
886 let server_finished = term! {
887 fn_finished(
888 (fn_verify_data_server(
889 (@certificate_verify_transcript),
890 (@server_hello_transcript),
892 (fn_get_client_key_share(((client, 0)), (@curve))),
893 (@curve),
894 fn_no_psk,
895 fn_new_random,
896 fn_cipher_suite13_aes_128_gcm_sha256
897 ))
898 )
899 };
900
901 Trace {
902 prior_traces: vec![],
903 descriptors: vec![AgentDescriptor::from_config(
904 client,
905 TLSDescriptorConfig {
906 tls_version: TLSVersion::V1_3,
907 typ: AgentType::Client,
908 ..TLSDescriptorConfig::default()
909 },
910 )],
911 steps: vec![
912 OutputAction::new_step(client),
913 Step {
914 agent: client,
915 action: Action::Input(input_action! { term! { @server_hello }
916 }),
917 },
918 Step {
919 agent: client,
920 action: Action::Input(input_action! { term! {
921 fn_encrypt_handshake_opaque(
922 (fn_coalesced_flight(
923 (fn_append_flight(
924 (fn_append_flight(
925 (fn_append_flight(
926 (fn_append_flight(
927 fn_new_flight,
928 (@encrypted_extensions)
929 )),
930 (@certificate)
931 )),
932 (@certificate_verify)
933 )),
934 (@server_finished)
935 )))
936 ),
937 (@server_hello_transcript),
938 (fn_get_client_key_share(((client, 0)), (@curve))),
939 fn_no_psk,
940 (@curve),
941 fn_false,
942 fn_seq_0, fn_new_random,
944 fn_cipher_suite13_aes_128_gcm_sha256
945 )
946 }
947 }),
948 },
949 ],
950 ..Default::default()
951 }
952}
953
954pub fn seed_server_attacker_with_hello_retry_request(client: AgentName) -> Trace<TLSProtocolTypes> {
960 let curve = term! {
961 fn_get_any_client_curve(
962 ((client, 1)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))])
963 )
964 };
965
966 let server_hrr = term! {
967 fn_hello_retry_request(
968 fn_protocol_version12,
969 fn_hello_retry_request_random,
970 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]),
971 fn_cipher_suite13_aes_128_gcm_sha256,
972 fn_compressions,
973 (fn_hello_retry_extensions_make(
974 (fn_hello_retry_extensions_append(
975 (fn_hello_retry_extensions_append(
976 fn_hello_retry_extensions_new,
977 fn_supported_versions13_hello_retry_extension
978 )),
979 (fn_key_share_hello_retry_extension(fn_named_group_secp384r1))
981 ))
982 ))
983 )
984 };
985
986 let server_hello = term! {
987 fn_server_hello(
988 fn_protocol_version12,
989 fn_new_random,
990 ((client, 1)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]),
991 fn_cipher_suite13_aes_128_gcm_sha256,
992 fn_compression,
993 (fn_server_extensions_make(
994 (fn_server_extensions_append(
995 (fn_server_extensions_append(
996 fn_server_extensions_new,
997 (fn_key_share_server_extension(
998 (fn_key_share_deterministic((@curve)))
999 ))
1000 )),
1001 fn_supported_versions13_server_extension
1002 ))))
1003 )
1004 };
1005
1006 let server_hello_transcript = term! {
1007 fn_append_transcript(
1008 (fn_append_transcript(
1009 (fn_append_transcript(
1010 (fn_new_hrr_transcript(((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]))),
1013 (@server_hrr)
1014 )),
1015 ((client, 1)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))])
1016 )),
1017 (@server_hello)
1018 )
1019 };
1020
1021 let encrypted_extensions = term! {
1022 fn_encrypted_extensions(
1023 fn_server_extensions_new
1024 )
1025 };
1026
1027 let certificate = term! {
1028 fn_certificate13(
1029 (fn_payload_u8((fn_empty_bytes_vec))),
1030 (fn_certificate_entries_make(
1031 (fn_chain_append_certificate_entry(
1032 fn_empty_certificate_chain,
1033 (fn_certificate_entry_extensions(
1034 fn_alice_cert,
1035 (fn_cert_extensions_make(
1036 fn_cert_extensions_new
1037 ))
1038 ))
1039 ))))
1040 )
1041 };
1042
1043 let encrypted_extensions_transcript = term! {
1044 fn_append_transcript(
1045 (@server_hello_transcript),
1046 (@encrypted_extensions) )
1048 };
1049
1050 let certificate_transcript = term! {
1051 fn_append_transcript(
1052 (@encrypted_extensions_transcript),
1053 (@certificate) )
1055 };
1056
1057 let certificate_verify = term! {
1058 fn_certificate_verify(
1059 fn_rsa_pss_signature_algorithm,
1060 (fn_payload_u16(
1061 (fn_rsa_sign_server(
1062 (@certificate_transcript),
1063 fn_alice_key,
1064 fn_rsa_pss_signature_algorithm
1065 ))
1066 ))
1067 )
1068 };
1069
1070 let certificate_verify_transcript = term! {
1071 fn_append_transcript(
1072 (@certificate_transcript),
1073 (@certificate_verify) )
1075 };
1076
1077 let server_finished = term! {
1078 fn_finished(
1079 (fn_verify_data_server(
1080 (@certificate_verify_transcript),
1081 (@server_hello_transcript),
1083 (fn_get_client_key_share(((client, 1)), (@curve))),
1084 (@curve),
1085 fn_no_psk,
1086 fn_new_random,
1087 fn_cipher_suite13_aes_128_gcm_sha256
1088 ))
1089 )
1090 };
1091
1092 Trace {
1093 prior_traces: vec![],
1094 descriptors: vec![AgentDescriptor::from_config(
1095 client,
1096 TLSDescriptorConfig {
1097 tls_version: TLSVersion::V1_3,
1098 typ: AgentType::Client,
1099 ..TLSDescriptorConfig::default()
1100 },
1101 )],
1102 steps: vec![
1103 OutputAction::new_step(client),
1104 Step {
1105 agent: client,
1106 action: Action::Input(input_action! { server_hrr }),
1107 },
1108 Step {
1109 agent: client,
1110 action: Action::Input(input_action! { server_hello }),
1111 },
1112 Step {
1113 agent: client,
1114 action: Action::Input(input_action! { term! {
1115 fn_encrypt_handshake(
1116 (@encrypted_extensions),
1117 (@server_hello_transcript),
1118 (fn_get_client_key_share(((client, 1)), (@curve))),
1119 fn_no_psk,
1120 (@curve),
1121 fn_false,
1122 fn_seq_0, fn_new_random,
1124 fn_cipher_suite13_aes_128_gcm_sha256
1125 )
1126 }
1127 }),
1128 },
1129 Step {
1130 agent: client,
1131 action: Action::Input(input_action! { term! {
1132 fn_encrypt_handshake(
1133 (@certificate),
1134 (@server_hello_transcript),
1135 (fn_get_client_key_share(((client, 1)), (@curve))),
1136 fn_no_psk,
1137 (@curve),
1138 fn_false,
1139 fn_seq_1, fn_new_random,
1141 fn_cipher_suite13_aes_128_gcm_sha256
1142 )
1143 }
1144 }),
1145 },
1146 Step {
1147 agent: client,
1148 action: Action::Input(input_action! { term! {
1149 fn_encrypt_handshake(
1150 (@certificate_verify),
1151 (@server_hello_transcript),
1152 (fn_get_client_key_share(((client, 1)), (@curve))),
1153 fn_no_psk,
1154 (@curve),
1155 fn_false,
1156 fn_seq_2, fn_new_random,
1158 fn_cipher_suite13_aes_128_gcm_sha256
1159 )
1160 }
1161 }),
1162 },
1163 Step {
1164 agent: client,
1165 action: Action::Input(input_action! { term! {
1166 fn_encrypt_handshake(
1167 (@server_finished),
1168 (@server_hello_transcript),
1169 (fn_get_client_key_share(((client, 1)), (@curve))),
1170 fn_no_psk,
1171 (@curve),
1172 fn_false,
1173 fn_seq_3, fn_new_random,
1175 fn_cipher_suite13_aes_128_gcm_sha256
1176 )
1177 }
1178 }),
1179 },
1180 ],
1181 ..Default::default()
1182 }
1183}
1184
1185pub fn seed_client_attacker_auth(server: AgentName) -> Trace<TLSProtocolTypes> {
1187 let client_hello = term! {
1188 fn_client_hello(
1189 fn_protocol_version12,
1190 fn_new_random,
1191 fn_new_session_id,
1192 (fn_cipher_suites_make(
1193 (fn_append_cipher_suite(
1194 (fn_new_cipher_suites()),
1195 fn_cipher_suite13_aes_128_gcm_sha256
1196 )))),
1197 fn_compressions,
1198 (fn_client_extensions_make(
1199 (fn_client_extensions_append(
1200 (fn_client_extensions_append(
1201 (fn_client_extensions_append(
1202 (fn_client_extensions_append(
1203 fn_client_extensions_new,
1204 (fn_support_group_extension_make(
1205 (fn_support_group_extension_append(
1206 fn_support_group_extension_new,
1207 fn_named_group_secp384r1
1208 ))
1209 ))
1210 )),
1211 (fn_signature_algorithm_extension(
1212 (fn_supported_signature_schemes_extension_append(
1213 (fn_supported_signature_schemes_extension_append(
1214 fn_supported_signature_schemes_extension_new,
1215 fn_sig_scheme_rsa_pkcs1_sha256
1216 )),
1217 fn_sig_scheme_rsa_pss_sha256
1218 ))
1219 ))
1220 )),
1221 (fn_key_share_extension_make(
1222 (fn_key_share_extension_append(
1223 fn_key_share_extension_new,
1224 (fn_key_share_deterministic(fn_named_group_secp384r1))
1225 ))
1226 ))
1227 )),
1228 fn_supported_versions13_extension
1229 ))
1230 )))
1231 };
1232
1233 let extensions = term! {
1234 fn_decrypt_handshake_flight(
1235 ((server, 0)/MessageFlight), (fn_server_hello_transcript(((server, 0)))),
1237 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
1238 fn_no_psk,
1239 fn_named_group_secp384r1,
1240 fn_true,
1241 fn_seq_0, fn_new_random,
1243 fn_cipher_suite13_aes_128_gcm_sha256
1244 )
1245 };
1246
1247 let certificate_request_message = term! {
1249 fn_find_server_certificate_request((@extensions))
1250 };
1251
1252 let certificate = term! {
1253 fn_certificate13(
1254 (fn_payload_u8((fn_get_context((@certificate_request_message))))),
1255 (fn_certificate_entries_make(
1256 (fn_chain_append_certificate_entry(
1257 fn_empty_certificate_chain,
1258 (fn_certificate_entry_extensions(
1259 fn_bob_cert,
1260 (fn_cert_extensions_make(
1261 fn_cert_extensions_new
1262 ))
1263 ))
1264 ))))
1265 )
1266 };
1267
1268 let certificate_verify = term! {
1269 fn_certificate_verify(
1270 fn_rsa_pss_signature_algorithm,
1271 (fn_payload_u16(
1272 (fn_rsa_sign_client(
1273 (fn_certificate_transcript(((server, 0)))),
1274 fn_bob_key,
1275 fn_rsa_pss_signature_algorithm
1276 ))
1277 ))
1278 )
1279 };
1280
1281 let client_finished = term! {
1282 fn_finished(
1283 (fn_verify_data(
1284 (fn_server_finished_transcript(((server, 0)))),
1285 (fn_server_hello_transcript(((server, 0)))),
1286 (fn_get_server_key_share(((server, 0)))),
1287 fn_no_psk,
1288 fn_named_group_secp384r1,
1289 fn_new_random,
1290 fn_cipher_suite13_aes_128_gcm_sha256
1291 ))
1292 )
1293 };
1294
1295 Trace {
1296 prior_traces: vec![],
1297 descriptors: vec![AgentDescriptor::from_config(
1298 server,
1299 TLSDescriptorConfig {
1300 tls_version: TLSVersion::V1_3,
1301 typ: AgentType::Server,
1302 client_authentication: true,
1303 ..TLSDescriptorConfig::default()
1304 },
1305 )],
1306 steps: vec![
1307 Step {
1308 agent: server,
1309 action: Action::Input(input_action! { term! {
1310 @client_hello
1311 }
1312 }),
1313 },
1314 Step {
1315 agent: server,
1316 action: Action::Input(input_action! { term! {
1317 fn_encrypt_handshake(
1318 (@certificate),
1319 (fn_server_hello_transcript(((server, 0)))),
1320 (fn_get_server_key_share(((server, 0)))),
1321 fn_no_psk,
1322 fn_named_group_secp384r1,
1323 fn_true,
1324 fn_seq_0, fn_new_random,
1326 fn_cipher_suite13_aes_128_gcm_sha256
1327 )
1328 }
1329 }),
1330 },
1331 Step {
1332 agent: server,
1333 action: Action::Input(input_action! { term! {
1334 fn_encrypt_handshake(
1335 (@certificate_verify),
1336 (fn_server_hello_transcript(((server, 0)))),
1337 (fn_get_server_key_share(((server, 0)))),
1338 fn_no_psk,
1339 fn_named_group_secp384r1,
1340 fn_true,
1341 fn_seq_1, fn_new_random,
1343 fn_cipher_suite13_aes_128_gcm_sha256
1344 )
1345 }
1346 }),
1347 },
1348 Step {
1349 agent: server,
1350 action: Action::Input(input_action! { term! {
1351 fn_encrypt_handshake(
1352 (@client_finished),
1353 (fn_server_hello_transcript(((server, 0)))),
1354 (fn_get_server_key_share(((server, 0)))),
1355 fn_no_psk,
1356 fn_named_group_secp384r1,
1357 fn_true,
1358 fn_seq_2, fn_new_random,
1360 fn_cipher_suite13_aes_128_gcm_sha256
1361 )
1362 }
1363 }),
1364 },
1365 ],
1366 ..Default::default()
1367 }
1368}
1369
1370pub fn seed_client_attacker(server: AgentName) -> Trace<TLSProtocolTypes> {
1371 let client_hello = term! {
1372 fn_client_hello(
1373 fn_protocol_version12,
1374 fn_new_random,
1375 fn_new_session_id,
1376 (fn_cipher_suites_make(
1377 (fn_append_cipher_suite(
1378 (fn_new_cipher_suites()),
1379 fn_cipher_suite13_aes_128_gcm_sha256
1380 )))),
1381 fn_compressions,
1382 (fn_client_extensions_make(
1383 (fn_client_extensions_append(
1384 (fn_client_extensions_append(
1385 (fn_client_extensions_append(
1386 (fn_client_extensions_append(
1387 (fn_client_extensions_append(
1388 fn_client_extensions_new,
1389 (fn_support_group_extension_make(
1390 (fn_support_group_extension_append(
1391 fn_support_group_extension_new,
1392 fn_named_group_secp384r1
1393 ))
1394 ))
1395 )),
1396 (fn_signature_algorithm_extension(
1397 (fn_supported_signature_schemes_extension_append(
1398 (fn_supported_signature_schemes_extension_append(
1399 fn_supported_signature_schemes_extension_new,
1400 fn_sig_scheme_rsa_pkcs1_sha256
1401 )),
1402 fn_sig_scheme_rsa_pss_sha256
1403 ))
1404 ))
1405 )),
1406 (fn_key_share_extension_make(
1407 (fn_key_share_extension_append(
1408 fn_key_share_extension_new,
1409 (fn_key_share_deterministic(fn_named_group_secp384r1))
1410 ))
1411 ))
1412 )),
1413 fn_supported_versions13_extension
1414 )),
1415 fn_psk_exchange_mode_dhe_ke_extension
1416 ))
1417 )))
1418 };
1419
1420 let client_finished = term! {
1421 fn_finished(
1422 (fn_verify_data(
1423 (fn_server_finished_transcript(((server, 0)))),
1424 (fn_server_hello_transcript(((server, 0)))),
1425 (fn_get_server_key_share(((server, 0)))),
1426 fn_no_psk,
1427 fn_named_group_secp384r1,
1428 fn_new_random,
1429 fn_cipher_suite13_aes_128_gcm_sha256
1430 ))
1431 )
1432 };
1433
1434 Trace {
1435 prior_traces: vec![],
1436 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
1437 steps: vec![
1438 Step {
1439 agent: server,
1440 action: Action::Input(input_action! { term! {
1441 @client_hello
1442 }
1443 }),
1444 },
1445 Step {
1446 agent: server,
1447 action: Action::Input(input_action! { term! {
1448 fn_encrypt_handshake(
1449 (@client_finished),
1450 (fn_server_hello_transcript(((server, 0)))),
1451 (fn_get_server_key_share(((server, 0)))),
1452 fn_no_psk,
1453 fn_named_group_secp384r1,
1454 fn_true,
1455 fn_seq_0, fn_new_random,
1457 fn_cipher_suite13_aes_128_gcm_sha256
1458 )
1459 }
1460 }),
1461 },
1462 OutputAction::new_step(server),
1463 ],
1464 ..Default::default()
1465 }
1466}
1467
1468pub fn seed_client_attacker12(server: AgentName) -> Trace<TLSProtocolTypes> {
1469 _seed_client_attacker12(server).0
1470}
1471
1472pub fn _seed_client_attacker12(
1473 server: AgentName,
1474) -> (Trace<TLSProtocolTypes>, Term<TLSProtocolTypes>) {
1475 let client_hello = term! {
1476 fn_client_hello(
1477 fn_protocol_version12,
1478 fn_new_random,
1479 fn_new_session_id,
1480 (fn_cipher_suites_make(
1481 (fn_append_cipher_suite(
1482 (fn_new_cipher_suites()),
1483 fn_cipher_suite12
1485 )))),
1486 fn_compressions,
1487 (fn_client_extensions_make(
1488 (fn_client_extensions_append(
1489 (fn_client_extensions_append(
1490 (fn_client_extensions_append(
1491 (fn_client_extensions_append(
1492 (fn_client_extensions_append(
1493 (fn_client_extensions_append(
1494 fn_client_extensions_new,
1495 (fn_support_group_extension_make(
1496 (fn_support_group_extension_append(
1497 fn_support_group_extension_new,
1498 fn_named_group_secp384r1
1499 ))
1500 ))
1501 )),
1502 (fn_signature_algorithm_extension(
1503 (fn_supported_signature_schemes_extension_append(
1504 (fn_supported_signature_schemes_extension_append(
1505 fn_supported_signature_schemes_extension_new,
1506 fn_sig_scheme_rsa_pkcs1_sha256
1507 )),
1508 fn_sig_scheme_rsa_pss_sha256
1509 ))
1510 ))
1511 )),
1512 fn_ec_point_formats_extension
1513 )),
1514 fn_signed_certificate_timestamp_extension
1515 )),
1516 (fn_renegotiation_info_extension((fn_payload_u8(fn_empty_bytes_vec))))
1518 )),
1519 fn_signature_algorithm_cert_extension
1521 ))
1522 )))
1523 };
1524
1525 let server_hello_transcript = term! {
1526 fn_append_transcript(
1527 (fn_append_transcript(
1528 fn_new_transcript12,
1529 (@client_hello) )),
1531 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]) )
1533 };
1534
1535 let certificate_transcript = term! {
1536 fn_append_transcript(
1537 (@server_hello_transcript),
1538 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::Certificate)))]) )
1540 };
1541
1542 let server_key_exchange_transcript = term! {
1543 fn_append_transcript(
1544 (@certificate_transcript),
1545 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerKeyExchange)))]) )
1547 };
1548
1549 let server_hello_done_transcript = term! {
1550 fn_append_transcript(
1551 (@server_key_exchange_transcript),
1552 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHelloDone)))]) )
1554 };
1555
1556 let client_key_exchange = term! {
1557 fn_client_key_exchange(
1558 (fn_encode_ec_pubkey12(
1559 (fn_payload_u8((fn_new_pubkey12(fn_named_group_secp384r1))))
1560 ))
1561 )
1562 };
1563
1564 let client_key_exchange_transcript = term! {
1565 fn_append_transcript(
1566 (@server_hello_done_transcript),
1567 (@client_key_exchange)
1568 )
1569 };
1570
1571 let client_verify_data = term! {
1572 fn_client_sign_transcript(
1573 ((server, 0)),
1574 (fn_decode_server_ecdh_pubkey(
1575 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerKeyExchange)))]/Vec<u8>) )),
1577 (@client_key_exchange_transcript),
1578 fn_named_group_secp384r1,
1579 fn_new_random,
1580 fn_cipher_suite12
1581 )
1582 };
1583
1584 let trace = Trace {
1585 prior_traces: vec![],
1586 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_2)],
1587 steps: vec![
1588 Step {
1589 agent: server,
1590 action: Action::Input(input_action! { client_hello
1591 }),
1592 },
1593 Step {
1594 agent: server,
1595 action: Action::Input(input_action! { client_key_exchange
1596 }),
1597 },
1598 Step {
1599 agent: server,
1600 action: Action::Input(input_action! { term! { fn_change_cipher_spec }
1601 }),
1602 },
1603 Step {
1604 agent: server,
1605 action: Action::Input(input_action! { term! {
1606 fn_encrypt12(
1607 (fn_finished((@client_verify_data))),
1608 ((server, 0)),
1609 (fn_decode_server_ecdh_pubkey(
1610 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerKeyExchange)))]/Vec<u8>) )),
1612 fn_named_group_secp384r1,
1613 fn_true,
1614 fn_seq_0,
1615 fn_new_random,
1616 fn_cipher_suite12
1617 )
1618 }
1619 }),
1620 },
1621 ],
1622 ..Default::default()
1623 };
1624
1625 (trace, client_verify_data)
1626}
1627
1628pub fn seed_server_attacker12(client: AgentName) -> Trace<TLSProtocolTypes> {
1629 _seed_server_attacker12(client).0
1630}
1631pub fn _seed_server_attacker12(
1632 client: AgentName,
1633) -> (Trace<TLSProtocolTypes>, Term<TLSProtocolTypes>) {
1634 let server_hello = term! {
1635 fn_server_hello(
1636 fn_protocol_version12,
1637 fn_new_random,
1638 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]),
1639 fn_cipher_suite12,
1640 fn_compression,
1641 (fn_server_extensions_make(
1642 (fn_server_extensions_append(
1643 fn_server_extensions_new,
1644 (fn_renegotiation_info_server_extension((fn_payload_u8(fn_empty_bytes_vec))))
1645 ))))
1646 )
1647 };
1648
1649 let server_hello_transcript = term! {
1650 fn_append_transcript(
1651 (fn_append_transcript(
1652 fn_new_transcript12,
1653 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientHello)))]) )),
1655 (@server_hello) )
1657 };
1658
1659 let server_certificate = term! {
1660 fn_certificate(
1661 (fn_append_certificate(
1662 fn_new_certificates,
1663 (fn_certificate_from_vec_u8(fn_alice_cert))
1664 ))
1665 )
1666 };
1667
1668 let certificate_transcript = term! {
1669 fn_append_transcript(
1670 (@server_hello_transcript),
1671 (@server_certificate)
1672 )
1673 };
1674
1675 let server_key_exchange = term! {
1676 fn_server_key_exchange(
1677 (fn_sign_rsa_ecdhe_server_key_exchange12(
1678 fn_named_group_secp384r1,
1679 ((client, 0)),
1680 fn_new_random,
1681 fn_alice_key
1682 ))
1683 )
1684 };
1685
1686 let server_key_exchange_transcript = term! {
1687 fn_append_transcript(
1688 (@certificate_transcript),
1689 (@server_key_exchange)
1690 )
1691 };
1692
1693 let server_hello_done_transcript = term! {
1694 fn_append_transcript(
1695 (@server_key_exchange_transcript),
1696 (fn_server_hello_done)
1697 )
1698 };
1699
1700 let client_key_exchange_transcript = term! {
1701 fn_append_transcript(
1702 (@server_hello_done_transcript),
1703 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientKeyExchange)))])
1704 )
1705 };
1706
1707 let client_ecdh_pubkey = term! {
1708 fn_decode_client_ecdh_pubkey(
1709 ((client, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ClientKeyExchange)))]/Vec<u8>) )
1711 };
1712
1713 let client_finished_transcript = term! {
1714 fn_append_transcript(
1715 (@client_key_exchange_transcript),
1716 (fn_decrypt12( ((client, 0)[Some(TlsQueryMatcher::Handshake(None))]), fn_new_random,
1719 (@client_ecdh_pubkey),
1720 fn_named_group_secp384r1,
1721 fn_false,
1722 fn_seq_0,
1723 ((client, 0)),
1724 fn_cipher_suite12
1725 ))
1726 )
1727 };
1728
1729 let server_verify_data = term! {
1730 fn_server_sign_transcript(
1731 fn_new_random,
1732 (@client_ecdh_pubkey),
1733 (@client_finished_transcript),
1734 fn_named_group_secp384r1,
1735 ((client, 0)),
1736 fn_cipher_suite12
1737 )
1738 };
1739
1740 let trace = Trace {
1741 prior_traces: vec![],
1742 descriptors: vec![TLSDescriptorConfig::new_client(client, TLSVersion::Both)],
1743 steps: vec![
1744 OutputAction::new_step(client),
1746 Step {
1748 agent: client,
1749 action: Action::Input(input_action! { server_hello
1750 }),
1751 },
1752 Step {
1754 agent: client,
1755 action: Action::Input(input_action! { server_certificate
1756 }),
1757 },
1758 Step {
1760 agent: client,
1761 action: Action::Input(input_action! { server_key_exchange
1762 }),
1763 },
1764 Step {
1766 agent: client,
1767 action: Action::Input(input_action! { term! { fn_server_hello_done }
1768 }),
1769 },
1770 Step {
1777 agent: client,
1778 action: Action::Input(input_action! { term! { fn_change_cipher_spec }
1779 }),
1780 },
1781 Step {
1783 agent: client,
1784 action: Action::Input(input_action! { term! {
1785 fn_encrypt12(
1786 (fn_finished((@server_verify_data))),
1787 fn_new_random,
1788 (@client_ecdh_pubkey),
1789 fn_named_group_secp384r1,
1790 fn_false,
1791 fn_seq_0,
1792 ((client, 0)),
1793 fn_cipher_suite12
1794 )
1795 }
1796 }),
1797 },
1798 ],
1799 ..Default::default()
1800 };
1801
1802 (trace, server_verify_data)
1803}
1804
1805pub fn seed_session_resumption_dhe(
1808 initial_server: AgentName,
1809 server: AgentName,
1810) -> Trace<TLSProtocolTypes> {
1811 let initial_handshake = seed_client_attacker(initial_server);
1812
1813 let extensions = term! {
1814 fn_decrypt_application_flight(
1815 ((initial_server, 1)/MessageFlight), (fn_server_hello_transcript(((initial_server, 0)))),
1817 (fn_server_finished_transcript(((initial_server, 0)))),
1818 (fn_get_server_key_share(((initial_server, 0)))),
1819 fn_no_psk,
1820 fn_named_group_secp384r1,
1821 fn_true,
1822 fn_seq_0, fn_new_random,
1824 fn_cipher_suite13_aes_128_gcm_sha256
1825 )
1826 };
1827
1828 let new_ticket_message = term! {fn_find_server_ticket((@extensions))};
1829
1830 let client_hello = term! {
1831 fn_client_hello(
1832 fn_protocol_version12,
1833 fn_new_random,
1834 fn_new_session_id,
1835 (fn_cipher_suites_make(
1836 (fn_append_cipher_suite(
1837 (fn_new_cipher_suites()),
1838 fn_cipher_suite13_aes_128_gcm_sha256
1839 )))),
1840 fn_compressions,
1841 (fn_client_extensions_make(
1842 (fn_client_extensions_append(
1843 (fn_client_extensions_append(
1844 (fn_client_extensions_append(
1845 (fn_client_extensions_append(
1846 (fn_client_extensions_append(
1847 (fn_client_extensions_append(
1848 fn_client_extensions_new,
1849 (fn_support_group_extension_make(
1850 (fn_support_group_extension_append(
1851 fn_support_group_extension_new,
1852 fn_named_group_secp384r1
1853 ))
1854 ))
1855 )),
1856 (fn_signature_algorithm_extension(
1857 (fn_supported_signature_schemes_extension_append(
1858 (fn_supported_signature_schemes_extension_append(
1859 fn_supported_signature_schemes_extension_new,
1860 fn_sig_scheme_rsa_pkcs1_sha256
1861 )),
1862 fn_sig_scheme_rsa_pss_sha256
1863 ))
1864 ))
1865 )),
1866 fn_supported_versions13_extension
1867 )),
1868 (fn_key_share_extension_make(
1869 (fn_key_share_extension_append(
1870 fn_key_share_extension_new,
1871 (fn_key_share_deterministic(fn_named_group_secp384r1))
1872 ))
1873 ))
1874 )),
1875 fn_psk_exchange_mode_dhe_ke_extension
1876 )),
1877 (fn_preshared_keys_extension_empty_binder(
1880 (@new_ticket_message)
1881 ))
1882 ))
1883 )))
1884 };
1885
1886 let psk = term! {
1887 fn_derive_psk(
1888 (fn_server_hello_transcript(((initial_server, 0)))),
1889 (fn_server_finished_transcript(((initial_server, 0)))),
1890 (fn_client_finished_transcript(((initial_server, 0)))),
1891 (fn_get_server_key_share(((initial_server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
1892 (fn_get_ticket_nonce((@new_ticket_message))),
1893 fn_named_group_secp384r1,
1894 fn_new_random,
1895 fn_cipher_suite13_aes_128_gcm_sha256
1896 )
1897 };
1898
1899 let binder = term! {
1900 fn_derive_binder(
1901 (@client_hello),
1902 (@psk),
1903 fn_cipher_suite13_aes_128_gcm_sha256
1904 )
1905 };
1906
1907 let full_client_hello = term! {
1908 fn_fill_binder(
1909 (@client_hello),
1910 (@binder)
1911 )
1912 };
1913
1914 let resumption_client_finished = term! {
1915 fn_finished(
1916 (fn_verify_data(
1917 (fn_server_finished_transcript(((server, 0)))),
1918 (fn_server_hello_transcript(((server, 0)))),
1919 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
1920 (fn_psk((@psk))),
1921 fn_named_group_secp384r1,
1922 fn_new_random,
1923 fn_cipher_suite13_aes_128_gcm_sha256
1924 ))
1925 )
1926 };
1927
1928 Trace {
1929 prior_traces: vec![initial_handshake],
1930 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
1931 steps: vec![
1932 Step {
1933 agent: server,
1934 action: Action::Input(input_action! { term! {
1935 @full_client_hello
1936 }
1937 }),
1938 },
1939 Step {
1940 agent: server,
1941 action: Action::Input(input_action! { term! {
1942 fn_encrypt_handshake(
1943 (@resumption_client_finished),
1944 (fn_server_hello_transcript(((server, 0)))),
1945 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
1946 (fn_psk((@psk))),
1947 fn_named_group_secp384r1,
1948 fn_true,
1949 fn_seq_0, fn_new_random,
1951 fn_cipher_suite13_aes_128_gcm_sha256
1952 )
1953 }
1954 }),
1955 },
1956 ],
1957 ..Default::default()
1958 }
1959}
1960
1961pub fn seed_session_resumption_ke(
1964 initial_server: AgentName,
1965 server: AgentName,
1966) -> Trace<TLSProtocolTypes> {
1967 let initial_handshake = seed_client_attacker(initial_server);
1968
1969 let extensions = term! {
1970 fn_decrypt_application_flight(
1971 ((initial_server, 1)/MessageFlight), (fn_server_hello_transcript(((initial_server, 0)))),
1973 (fn_server_finished_transcript(((initial_server, 0)))),
1974 (fn_get_server_key_share(((initial_server, 0)))),
1975 fn_no_psk,
1976 fn_named_group_secp384r1,
1977 fn_true,
1978 fn_seq_0, fn_new_random,
1980 fn_cipher_suite13_aes_128_gcm_sha256
1981
1982 )
1983 };
1984
1985 let new_ticket_message = term! {fn_find_server_ticket((@extensions))};
1986
1987 let client_hello = term! {
1988 fn_client_hello(
1989 fn_protocol_version12,
1990 fn_new_random,
1991 fn_new_session_id,
1992 (fn_cipher_suites_make(
1993 (fn_append_cipher_suite(
1994 (fn_new_cipher_suites()),
1995 fn_cipher_suite13_aes_128_gcm_sha256
1996 )))),
1997 fn_compressions,
1998 (fn_client_extensions_make(
1999 (fn_client_extensions_append(
2000 (fn_client_extensions_append(
2001 (fn_client_extensions_append(
2002 (fn_client_extensions_append(
2003 (fn_client_extensions_append(
2004 (fn_client_extensions_append(
2005 fn_client_extensions_new,
2006 (fn_support_group_extension_make(
2007 (fn_support_group_extension_append(
2008 fn_support_group_extension_new,
2009 fn_named_group_secp384r1
2010 ))
2011 ))
2012 )),
2013 (fn_signature_algorithm_extension(
2014 (fn_supported_signature_schemes_extension_append(
2015 (fn_supported_signature_schemes_extension_append(
2016 fn_supported_signature_schemes_extension_new,
2017 fn_sig_scheme_rsa_pkcs1_sha256
2018 )),
2019 fn_sig_scheme_rsa_pss_sha256
2020 ))
2021 ))
2022 )),
2023 fn_supported_versions13_extension
2024 )),
2025 (fn_key_share_extension_make(
2026 (fn_key_share_extension_append(
2027 fn_key_share_extension_new,
2028 (fn_key_share_deterministic(fn_named_group_secp384r1))
2029 ))
2030 ))
2031 )),
2032 fn_psk_exchange_mode_ke_extension
2033 )),
2034 (fn_preshared_keys_extension_empty_binder(
2037 (@new_ticket_message)
2038 ))
2039 ))))
2040 )
2041 };
2042
2043 let psk = term! {
2044 fn_derive_psk(
2045 (fn_server_hello_transcript(((initial_server, 0)))),
2046 (fn_server_finished_transcript(((initial_server, 0)))),
2047 (fn_client_finished_transcript(((initial_server, 0)))),
2048 (fn_get_server_key_share(((initial_server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2049 (fn_get_ticket_nonce((@new_ticket_message))),
2050 fn_named_group_secp384r1,
2051 fn_new_random,
2052 fn_cipher_suite13_aes_128_gcm_sha256
2053 )
2054 };
2055
2056 let binder = term! {
2057 fn_derive_binder(
2058 (@client_hello),
2059 (@psk),
2060 fn_cipher_suite13_aes_128_gcm_sha256
2061 )
2062 };
2063
2064 let full_client_hello = term! {
2065 fn_fill_binder(
2066 (@client_hello),
2067 (@binder)
2068 )
2069 };
2070
2071 let resumption_client_finished = term! {
2072 fn_finished(
2073 (fn_verify_data(
2074 (fn_server_finished_transcript(((server, 0)))),
2075 (fn_server_hello_transcript(((server, 0)))),
2076 fn_no_key_share,
2077 (fn_psk((@psk))),
2078 fn_named_group_secp384r1,
2079 fn_new_random,
2080 fn_cipher_suite13_aes_128_gcm_sha256
2081 ))
2082 )
2083 };
2084
2085 Trace {
2086 prior_traces: vec![initial_handshake],
2087 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
2088 steps: vec![
2089 Step {
2090 agent: server,
2091 action: Action::Input(input_action! { term! {
2092 @full_client_hello
2093 }
2094 }),
2095 },
2096 Step {
2097 agent: server,
2098 action: Action::Input(input_action! { term! {
2099 fn_encrypt_handshake(
2100 (@resumption_client_finished),
2101 (fn_server_hello_transcript(((server, 0)))),
2102 fn_no_key_share,
2103 (fn_psk((@psk))),
2104 fn_named_group_secp384r1,
2105 fn_true,
2106 fn_seq_0, fn_new_random,
2108 fn_cipher_suite13_aes_128_gcm_sha256
2109 )
2110 }
2111 }),
2112 },
2113 ],
2114 ..Default::default()
2115 }
2116}
2117
2118pub fn seed_client_attacker_full(server: AgentName) -> Trace<TLSProtocolTypes> {
2119 _seed_client_attacker_full(server).0
2120}
2121
2122pub fn _seed_client_attacker_full(
2124 server: AgentName,
2125) -> (
2126 Trace<TLSProtocolTypes>,
2127 Term<TLSProtocolTypes>,
2128 Term<TLSProtocolTypes>,
2129 Term<TLSProtocolTypes>,
2130) {
2131 let client_hello = term! {
2132 fn_client_hello(
2133 fn_protocol_version12,
2134 fn_new_random,
2135 fn_new_session_id,
2136 (fn_cipher_suites_make(
2137 (fn_append_cipher_suite(
2138 (fn_new_cipher_suites()),
2139 fn_cipher_suite13_aes_128_gcm_sha256
2140 )))),
2141 fn_compressions,
2142 (fn_client_extensions_make(
2143 (fn_client_extensions_append(
2144 (fn_client_extensions_append(
2145 (fn_client_extensions_append(
2146 (fn_client_extensions_append(
2147 (fn_client_extensions_append(
2148 fn_client_extensions_new,
2149 (fn_support_group_extension_make(
2150 (fn_support_group_extension_append(
2151 fn_support_group_extension_new,
2152 fn_named_group_secp384r1
2153 ))
2154 ))
2155 )),
2156 (fn_signature_algorithm_extension(
2157 (fn_supported_signature_schemes_extension_append(
2158 (fn_supported_signature_schemes_extension_append(
2159 fn_supported_signature_schemes_extension_new,
2160 fn_sig_scheme_rsa_pkcs1_sha256
2161 )),
2162 fn_sig_scheme_rsa_pss_sha256
2163 ))
2164 ))
2165 )),
2166 (fn_key_share_extension_make(
2167 (fn_key_share_extension_append(
2168 fn_key_share_extension_new,
2169 (fn_key_share_deterministic(fn_named_group_secp384r1))
2170 ))
2171 ))
2172 )),
2173 fn_supported_versions13_extension
2174 )),
2175 fn_psk_exchange_mode_dhe_ke_extension
2176 ))
2177 )))
2178 };
2179
2180 let server_hello_transcript = term! {
2181 fn_append_transcript(
2182 (fn_append_transcript(
2183 fn_new_transcript,
2184 (@client_hello) )),
2186 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]) )
2188 };
2189
2190 let extensions = term! {
2193 fn_decrypt_handshake_flight(
2194 ((server, 0)/MessageFlight), (@server_hello_transcript),
2196 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2197 fn_no_psk,
2198 fn_named_group_secp384r1,
2199 fn_true,
2200 fn_seq_0, fn_new_random,
2202 fn_cipher_suite13_aes_128_gcm_sha256
2203 )
2204 };
2205
2206 let encrypted_extensions = term! {
2207 fn_find_encrypted_extensions((@extensions))
2208 };
2209
2210 let encrypted_extension_transcript = term! {
2211 fn_append_transcript(
2212 (@server_hello_transcript),
2213 (@encrypted_extensions) )
2215 };
2216
2217 let server_certificate = term! {
2218 fn_find_server_certificate((@extensions))
2219 };
2220
2221 let server_certificate_transcript = term! {
2222 fn_append_transcript(
2223 (@encrypted_extension_transcript),
2224 (@server_certificate) )
2226 };
2227
2228 let server_certificate_verify = term! {
2229 fn_find_server_certificate_verify((@extensions))
2230 };
2231
2232 let server_certificate_verify_transcript = term! {
2233 fn_append_transcript(
2234 (@server_certificate_transcript),
2235 (@server_certificate_verify) )
2237 };
2238
2239 let server_finished = term! {
2240 fn_find_server_finished((@extensions))
2241 };
2242
2243 let server_finished_transcript = term! {
2244 fn_append_transcript(
2245 (@server_certificate_verify_transcript),
2246 (@server_finished) )
2248 };
2249
2250 let client_finished = term! {
2251 fn_finished(
2252 (fn_verify_data(
2253 (@server_finished_transcript),
2254 (@server_hello_transcript),
2255 (fn_get_server_key_share(((server, 0)))),
2256 fn_no_psk,
2257 fn_named_group_secp384r1,
2258 fn_new_random,
2259 fn_cipher_suite13_aes_128_gcm_sha256
2260 ))
2261 )
2262 };
2263
2264 let client_finished_transcript = term! {
2265 fn_append_transcript(
2266 (@server_finished_transcript),
2267 (@client_finished)
2268 )
2269 };
2270
2271 let trace = Trace {
2272 prior_traces: vec![],
2273 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
2274 steps: vec![
2275 Step {
2276 agent: server,
2277 action: Action::Input(input_action! { term! {
2278 @client_hello
2279 }
2280 }),
2281 },
2282 OutputAction::new_step(server),
2283 Step {
2284 agent: server,
2285 action: Action::Input(input_action! { term! {
2286 fn_encrypt_handshake(
2287 (@client_finished),
2288 (@server_hello_transcript),
2289 (fn_get_server_key_share(((server, 0)))),
2290 fn_no_psk,
2291 fn_named_group_secp384r1,
2292 fn_true,
2293 fn_seq_0, fn_new_random,
2295 fn_cipher_suite13_aes_128_gcm_sha256
2296 )
2297 }
2298 }),
2299 },
2300 OutputAction::new_step(server),
2301 ],
2319 ..Default::default()
2320 };
2321
2322 (
2323 trace,
2324 server_hello_transcript,
2325 server_finished_transcript,
2326 client_finished_transcript,
2327 )
2328}
2329
2330pub fn seed_client_attacker_full_precomputation(server: AgentName) -> Trace<TLSProtocolTypes> {
2331 _seed_client_attacker_full_precomputation(server).0
2332}
2333pub fn _seed_client_attacker_full_precomputation(
2334 server: AgentName,
2335) -> (
2336 Trace<TLSProtocolTypes>,
2337 Term<TLSProtocolTypes>,
2338 Term<TLSProtocolTypes>,
2339 Term<TLSProtocolTypes>,
2340) {
2341 let client_hello = term! {
2342 fn_client_hello(
2343 fn_protocol_version12,
2344 fn_new_random,
2345 fn_new_session_id,
2346 (fn_cipher_suites_make(
2347 (fn_append_cipher_suite(
2348 (fn_new_cipher_suites()),
2349 fn_cipher_suite13_aes_128_gcm_sha256
2350 )))),
2351 fn_compressions,
2352 (fn_client_extensions_make(
2353 (fn_client_extensions_append(
2354 (fn_client_extensions_append(
2355 (fn_client_extensions_append(
2356 (fn_client_extensions_append(
2357 fn_client_extensions_new,
2358 (fn_support_group_extension_make(
2359 (fn_support_group_extension_append(
2360 fn_support_group_extension_new,
2361 fn_named_group_secp384r1
2362 ))
2363 ))
2364 )),
2365 (fn_signature_algorithm_extension(
2366 (fn_supported_signature_schemes_extension_append(
2367 (fn_supported_signature_schemes_extension_append(
2368 fn_supported_signature_schemes_extension_new,
2369 fn_sig_scheme_rsa_pkcs1_sha256
2370 )),
2371 fn_sig_scheme_rsa_pss_sha256
2372 ))
2373 ))
2374 )),
2375 (fn_key_share_extension_make(
2376 (fn_key_share_extension_append(
2377 fn_key_share_extension_new,
2378 (fn_key_share_deterministic(fn_named_group_secp384r1))
2379 ))
2380 ))
2381 )),
2382 fn_supported_versions13_extension
2383 ))))
2384 )
2385 };
2386
2387 let server_hello_transcript = term! {
2388 fn_append_transcript(
2389 (fn_append_transcript(
2390 fn_new_transcript,
2391 (@client_hello) )),
2393 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]) )
2395 };
2396
2397 let extensions = term! {
2399 fn_decrypt_handshake_flight(
2400 ((server, 0)/MessageFlight), (@server_hello_transcript),
2402 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2403 fn_no_psk,
2404 fn_named_group_secp384r1,
2405 fn_true,
2406 fn_seq_0, fn_new_random,
2408 fn_cipher_suite13_aes_128_gcm_sha256
2409 )
2410 };
2411
2412 let encrypted_extensions = term! {
2414 (!"decrypted_extensions", 0)[Some(TlsQueryMatcher::Handshake(Some(
2415 HandshakeType::EncryptedExtensions
2416 )))] / Message
2417 };
2418
2419 let encrypted_extension_transcript = term! {
2420 fn_append_transcript(
2421 (@server_hello_transcript),
2422 (@encrypted_extensions) )
2424 };
2425
2426 let server_certificate = term! {
2427 (!"decrypted_extensions", 0)[Some(TlsQueryMatcher::Handshake(Some(
2428 HandshakeType::Certificate
2429 )))] / Message
2430 };
2431
2432 let server_certificate_transcript = term! {
2433 fn_append_transcript(
2434 (@encrypted_extension_transcript),
2435 (@server_certificate) )
2437 };
2438
2439 let server_certificate_verify = term! {
2440 (!"decrypted_extensions", 0)[Some(TlsQueryMatcher::Handshake(Some(
2441 HandshakeType::CertificateVerify
2442 )))] / Message
2443 };
2444
2445 let server_certificate_verify_transcript = term! {
2446 fn_append_transcript(
2447 (@server_certificate_transcript),
2448 (@server_certificate_verify) )
2450 };
2451
2452 let server_finished = term! {
2453 (!"decrypted_extensions", 0)[Some(TlsQueryMatcher::Handshake(Some(
2454 HandshakeType::Finished
2455 )))] / Message
2456 };
2457
2458 let server_finished_transcript = term! {
2459 fn_append_transcript(
2460 (@server_certificate_verify_transcript),
2461 (@server_finished) )
2463 };
2464
2465 let client_finished = term! {
2466 fn_finished(
2467 (fn_verify_data(
2468 (@server_finished_transcript),
2469 (@server_hello_transcript),
2470 (fn_get_server_key_share(((server, 0)))),
2471 fn_no_psk,
2472 fn_named_group_secp384r1,
2473 fn_new_random,
2474 fn_cipher_suite13_aes_128_gcm_sha256
2475 ))
2476 )
2477 };
2478
2479 let client_finished_transcript = term! {
2480 fn_append_transcript(
2481 (@server_finished_transcript),
2482 (@client_finished)
2483 )
2484 };
2485
2486 let trace = Trace {
2487 prior_traces: vec![],
2488 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
2489 steps: vec![
2490 Step {
2491 agent: server,
2492 action: Action::Input(input_action! { term! {
2493 @client_hello
2494 }
2495 }),
2496 },
2497 OutputAction::new_step(server),
2498 Step {
2499 agent: server,
2500 action: Action::Input(input_action! {
2501 "decrypted_extensions" = term! {
2502 @extensions
2503 }
2504 =>
2505 term! {
2506 fn_encrypt_handshake(
2507 (@client_finished),
2508 (@server_hello_transcript),
2509 (fn_get_server_key_share(((server, 0)))),
2510 fn_no_psk,
2511 fn_named_group_secp384r1,
2512 fn_true,
2513 fn_seq_0, fn_new_random,
2515 fn_cipher_suite13_aes_128_gcm_sha256
2516 )
2517 }
2518 }),
2519 },
2520 OutputAction::new_step(server),
2521 ],
2522 ..Default::default()
2523 };
2524
2525 (
2526 trace,
2527 server_hello_transcript,
2528 server_finished_transcript,
2529 client_finished_transcript,
2530 )
2531}
2532
2533pub fn seed_session_resumption_dhe_full(
2536 initial_server: AgentName,
2537 server: AgentName,
2538) -> Trace<TLSProtocolTypes> {
2539 let (
2540 initial_handshake,
2541 server_hello_transcript,
2542 server_finished_transcript,
2543 client_finished_transcript,
2544 ) = _seed_client_attacker_full(initial_server);
2545
2546 let new_ticket_message = term! {
2547 fn_decrypt_application(
2548 ((initial_server, 4)[Some(TlsQueryMatcher::ApplicationData)]), (@server_hello_transcript),
2550 (@server_finished_transcript),
2551 (fn_get_server_key_share(((initial_server, 0)))),
2552 fn_no_psk,
2553 fn_named_group_secp384r1,
2554 fn_true,
2555 fn_seq_0, fn_new_random,
2557 fn_cipher_suite13_aes_128_gcm_sha256
2558 )
2559 };
2560
2561 let client_hello = term! {
2562 fn_client_hello(
2563 fn_protocol_version12,
2564 fn_new_random,
2565 fn_new_session_id,
2566 (fn_cipher_suites_make(
2567 (fn_append_cipher_suite(
2568 (fn_new_cipher_suites()),
2569 fn_cipher_suite13_aes_128_gcm_sha256
2570 )))),
2571 fn_compressions,
2572 (fn_client_extensions_make(
2573 (fn_client_extensions_append(
2574 (fn_client_extensions_append(
2575 (fn_client_extensions_append(
2576 (fn_client_extensions_append(
2577 (fn_client_extensions_append(
2578 (fn_client_extensions_append(
2579 fn_client_extensions_new,
2580 (fn_support_group_extension_make(
2581 (fn_support_group_extension_append(
2582 fn_support_group_extension_new,
2583 fn_named_group_secp384r1
2584 ))
2585 ))
2586 )),
2587 (fn_signature_algorithm_extension(
2588 (fn_supported_signature_schemes_extension_append(
2589 (fn_supported_signature_schemes_extension_append(
2590 fn_supported_signature_schemes_extension_new,
2591 fn_sig_scheme_rsa_pkcs1_sha256
2592 )),
2593 fn_sig_scheme_rsa_pss_sha256
2594 ))
2595 ))
2596 )),
2597 fn_supported_versions13_extension
2598 )),
2599 (fn_key_share_extension_make(
2600 (fn_key_share_extension_append(
2601 fn_key_share_extension_new,
2602 (fn_key_share_deterministic(fn_named_group_secp384r1))
2603 ))
2604 ))
2605 )),
2606 fn_psk_exchange_mode_dhe_ke_extension
2607 )),
2608 (fn_preshared_keys_extension_empty_binder(
2611 (@new_ticket_message)
2612 ))
2613 ))
2614 )))
2615 };
2616
2617 let psk = term! {
2618 fn_derive_psk(
2619 (@server_hello_transcript),
2620 (@server_finished_transcript),
2621 (@client_finished_transcript),
2622 (fn_get_server_key_share(((initial_server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2623 (fn_get_ticket_nonce((@new_ticket_message))),
2624 fn_named_group_secp384r1,
2625 fn_new_random,
2626 fn_cipher_suite13_aes_128_gcm_sha256
2627 )
2628 };
2629
2630 let binder = term! {
2631 fn_derive_binder(
2632 (@client_hello),
2633 (@psk),
2634 fn_cipher_suite13_aes_128_gcm_sha256
2635 )
2636 };
2637
2638 let full_client_hello = term! {
2639 fn_fill_binder(
2640 (@client_hello),
2641 (@binder)
2642 )
2643 };
2644
2645 let resumption_server_hello_transcript = term! {
2646 fn_append_transcript(
2647 (fn_append_transcript(
2648 fn_new_transcript,
2649 (@full_client_hello) )),
2651 ((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]) )
2653 };
2654
2655 let resumption_decrypted_handshake = term! {
2656 fn_decrypt_handshake_flight(
2657 ((server, 0)/MessageFlight), (@resumption_server_hello_transcript),
2659 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2660 (fn_psk((@psk))),
2661 fn_named_group_secp384r1,
2662 fn_true,
2663 fn_seq_0, fn_new_random,
2665 fn_cipher_suite13_aes_128_gcm_sha256
2666 )
2667 };
2668
2669 let resumption_encrypted_extensions = term! {
2670 fn_find_encrypted_extensions((@resumption_decrypted_handshake))
2671 };
2672
2673 let resumption_encrypted_extension_transcript = term! {
2674 fn_append_transcript(
2675 (@resumption_server_hello_transcript),
2676 (@resumption_encrypted_extensions) )
2678 };
2679
2680 let resumption_server_finished = term! {
2681 fn_find_server_finished((@resumption_decrypted_handshake))
2682 };
2683
2684 let resumption_server_finished_transcript = term! {
2685 fn_append_transcript(
2686 (@resumption_encrypted_extension_transcript),
2687 (@resumption_server_finished) )
2689 };
2690
2691 let resumption_client_finished = term! {
2692 fn_finished(
2693 (fn_verify_data(
2694 (@resumption_server_finished_transcript),
2695 (@resumption_server_hello_transcript),
2696 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2697 (fn_psk((@psk))),
2698 fn_named_group_secp384r1,
2699 fn_new_random,
2700 fn_cipher_suite13_aes_128_gcm_sha256
2701 ))
2702 )
2703 };
2704
2705 Trace {
2706 prior_traces: vec![initial_handshake],
2707 descriptors: vec![TLSDescriptorConfig::new_server(server, TLSVersion::V1_3)],
2708 steps: vec![
2709 Step {
2710 agent: server,
2711 action: Action::Input(input_action! { term! {
2712 @full_client_hello
2713 }
2714 }),
2715 },
2716 Step {
2717 agent: server,
2718 action: Action::Input(input_action! { term! {
2719 fn_encrypt_handshake(
2720 (@resumption_client_finished),
2721 (@resumption_server_hello_transcript),
2722 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2723 (fn_psk((@psk))),
2724 fn_named_group_secp384r1,
2725 fn_true,
2726 fn_seq_0, fn_new_random,
2728 fn_cipher_suite13_aes_128_gcm_sha256
2729 )
2730 }
2731 }),
2732 },
2733 ],
2748 ..Default::default()
2749 }
2750}
2751
2752fn decrypt_handshake_from_claims() -> Term<TLSProtocolTypes> {
2753 let server = AgentName::first();
2754 term! {
2755 fn_decrypt_handshake_flight(
2756 ((server, 0)/MessageFlight),
2757 (fn_server_hello_transcript(((server,0)))),
2758 (fn_get_server_key_share(((server, 0)[Some(TlsQueryMatcher::Handshake(Some(HandshakeType::ServerHello)))]))),
2759 fn_no_psk,
2760 fn_named_group_secp384r1,
2761 fn_true,
2762 fn_seq_0 )
2764 }
2765}
2766
2767pub fn create_corpus(
2768 put: &dyn puffin::put_registry::Factory<TLSProtocolBehavior>,
2769) -> Vec<(Trace<TLSProtocolTypes>, &'static str)> {
2770 puffin::corpus!(
2771 seed_successful: put.supports("tls13"),
2773 seed_successful_with_ccs: put.supports("tls13"),
2774 seed_successful_with_tickets: put.supports("tls13") && put.supports("tls13_session_resumption"),
2775 seed_successful12: put.supports("tls12") && !put.supports("tls12_session_resumption"),
2776 seed_successful12_with_tickets: put.supports("tls12") && put.supports("tls12_session_resumption"),
2777 seed_client_attacker: put.supports("tls13"),
2779 seed_client_attacker_full: put.supports("tls13"),
2780 seed_client_attacker_auth: put.supports("tls13") && put.supports("client_authentication_transcript_extraction"),
2781 seed_client_attacker12: put.supports("tls12"),
2782 seed_session_resumption_dhe: put.supports("tls13") && put.supports("tls13_session_resumption"),
2784 seed_session_resumption_ke: put.supports("tls13") && put.supports("tls13_session_resumption") && put.supports("psk_ke_support"),
2785 seed_server_attacker_full: put.supports("tls13"),
2787 seed_server_attacker_full_coalesced: put.supports("tls13"),
2788 seed_server_attacker_with_hello_retry_request : put.supports("tls13"),
2789 seed_server_attacker12: put.supports("tls12"),
2790 )
2791}
2792
2793#[cfg(test)]
2794pub mod tests {
2795 use puffin::algebra::TermType;
2796 use puffin::fuzzer::utils::TermConstraints;
2797 use puffin::protocol::ProtocolTypes;
2798 use puffin::put::{PutDescriptor, PutOptions};
2799 use puffin::trace::Query;
2800
2801 use super::*;
2802 #[allow(unused_imports)]
2803 use crate::{test_utils::prelude::*, tls::seeds::*};
2804
2805 #[test_log::test]
2806 fn test_version() {
2807 for (id, put) in tls_registry().puts() {
2808 println!("{}:", id);
2809 for (component, version) in put.versions().into_iter() {
2810 println!(" {}: {}", component, version);
2811 }
2812 }
2813 }
2814
2815 #[apply(test_puts, filter = tls12)]
2816 fn test_seed_client_attacker12(put: &str) {
2817 let runner = default_runner_for(put);
2818 let trace = seed_client_attacker12.build_trace();
2819
2820 let ctx = runner.execute(trace, &mut 0).unwrap();
2821
2822 assert!(ctx.agents_successful());
2823 }
2824
2825 #[apply(test_puts, filter = all(tls13, transcript_extraction))]
2826 fn test_seed_client_attacker(put: &str) {
2827 let runner = default_runner_for(put);
2828 let trace = seed_client_attacker.build_trace();
2829
2830 let ctx = runner.execute(trace, &mut 0).unwrap();
2831
2832 assert!(ctx.agents_successful());
2833 }
2834
2835 #[apply(test_puts, filter = all(tls13, client_authentication_transcript_extraction))]
2836 fn test_seed_client_attacker_auth(put: &str) {
2837 let runner = default_runner_for(put);
2838 let trace = seed_client_attacker_auth.build_trace();
2839
2840 let ctx = runner.execute(trace, &mut 0).unwrap();
2841
2842 assert!(ctx.agents_successful());
2843 }
2844
2845 #[apply(test_puts, filter = tls13)]
2846 fn test_seed_client_attacker_full(put: &str) {
2847 let runner = default_runner_for(put);
2848 let trace = seed_client_attacker_full.build_trace();
2849
2850 let ctx = runner.execute(trace, &mut 0).unwrap();
2851
2852 assert!(ctx.agents_successful());
2853 }
2854
2855 #[apply(test_puts, filter = tls13)]
2857 fn test_precomputations(put: &str) {
2858 let runner = default_runner_for(put);
2859 let trace = seed_client_attacker_full_precomputation.build_trace();
2860
2861 let ctx = runner.execute(trace, &mut 0).unwrap();
2862
2863 assert!(ctx.agents_successful());
2864 }
2865
2866 #[apply(test_puts, filter = all(tls12))]
2867 fn test_seed_server_attacker12(put: &str) {
2868 let runner = default_runner_for(put);
2869 let trace = seed_server_attacker12.build_trace();
2870
2871 let ctx = runner.execute(trace, &mut 0).unwrap();
2872
2873 assert!(ctx.agents_successful());
2874 }
2875
2876 #[apply(test_puts, filter = all(tls13))]
2877 fn test_seed_server_attacker_full(put: &str) {
2878 let runner = default_runner_for(put);
2879 let trace = seed_server_attacker_full.build_trace();
2880
2881 let ctx = runner.execute(trace, &mut 0).unwrap();
2882
2883 assert!(ctx.agents_successful());
2884 }
2885
2886 #[apply(test_puts, filter = all(tls13, transcript_extraction, client_authentication_transcript_extraction, not(boringssl), not(disable_postauth), not(wolfssl430)))]
2893 fn test_seeds_differential_decryption(put: &str) {
2894 let traces = vec![
2895 seed_client_attacker.build_trace(),
2896 seed_client_attacker_full.build_trace(),
2897 seed_server_attacker_full.build_trace(),
2898 seed_successful.build_trace(),
2899 ];
2900
2901 for trace in traces {
2902 let runner = default_runner_for(put);
2903 let descriptors = trace.descriptors.clone();
2904 let ctx = runner.execute(trace, &mut 0).unwrap();
2905
2906 let terms = <TLSProtocolTypes as ProtocolTypes>::differential_fuzzing_terms_to_eval(
2907 &descriptors,
2908 );
2909 assert!(
2910 !terms.is_empty(),
2911 "no differential terms produced for {put}"
2912 );
2913
2914 let any_ok = terms.iter().any(|t| t.evaluate_dy(&ctx).is_ok());
2915 assert!(
2916 any_ok,
2917 "no post-computation decryption term evaluated successfully for {put}"
2918 );
2919 }
2920 }
2921
2922 #[apply(test_puts, filter = all(tls13, not(boringssl)))]
2923 fn test_seed_server_attacker_full_coalesced(put: &str) {
2924 let runner = default_runner_for(put);
2925 let trace = seed_server_attacker_full_coalesced.build_trace();
2926
2927 let ctx = runner.execute(trace, &mut 0).unwrap();
2928
2929 assert!(ctx.agents_successful());
2930 }
2931
2932 #[apply(test_puts, filter = all(tls13))]
2933 fn test_seed_server_attacker_with_hello_retry_request(put: &str) {
2934 let runner = default_runner_for(put);
2935 let trace = seed_server_attacker_with_hello_retry_request.build_trace();
2936
2937 let ctx = runner.execute(trace, &mut 0).unwrap();
2938
2939 assert!(ctx.agents_successful());
2940 }
2941
2942 #[apply(test_puts, filter = all(tls13, tls13_session_resumption, not(disable_postauth)))]
2943 fn test_seed_session_resumption_dhe(put: &str) {
2944 let runner = default_runner_for(put);
2945 let trace = seed_session_resumption_dhe.build_trace();
2946
2947 let ctx = runner.execute(trace, &mut 0).unwrap();
2948
2949 assert!(ctx.agents_successful());
2950 }
2951
2952 #[apply(test_puts, filter = all(tls13, tls13_session_resumption, not(disable_postauth)))]
2953 fn test_seed_session_resumption_dhe_full(put: &str) {
2954 let runner = default_runner_for(put);
2955 let trace = seed_session_resumption_dhe_full.build_trace();
2956
2957 let ctx = runner.execute(trace, &mut 0).unwrap();
2958
2959 assert!(ctx.agents_successful());
2960 }
2961
2962 #[apply(test_puts, filter = all(tls13, tls13_session_resumption, psk_ke_support, not(disable_postauth))
2963 )]
2964 fn test_seed_session_resumption_ke(put: &str) {
2965 let runner = default_runner_for(put);
2966 let trace = seed_session_resumption_ke.build_trace();
2967
2968 let ctx = runner.execute(trace, &mut 0).unwrap();
2969
2970 assert!(ctx.agents_successful());
2971 }
2972
2973 #[apply(test_puts, filter = all(tls13))]
2974 fn test_seed_successful(put: &str) {
2975 let runner = default_runner_for(put);
2976 let trace = seed_successful.build_trace();
2977
2978 let ctx = runner.execute(trace, &mut 0).unwrap();
2979
2980 assert!(ctx.agents_successful());
2981 }
2982
2983 #[apply(test_puts, filter = all(tls13))]
2984 fn test_seed_successful_client_auth(put: &str) {
2985 let runner = default_runner_for(put);
2986 let trace = seed_successful_client_auth.build_trace();
2987
2988 let ctx = runner.execute(trace, &mut 0).unwrap();
2989
2990 assert!(ctx.agents_successful());
2991 }
2992
2993 #[apply(test_puts, attrs = [should_panic], filter = tls13)]
2994 fn test_seed_successful_mitm(put: &str) {
2999 let runner = default_runner_for(put);
3000 let trace = seed_successful_mitm.build_trace();
3001
3002 let ctx = runner.execute(trace, &mut 0).unwrap();
3003
3004 assert!(ctx.agents_successful());
3005 }
3006
3007 #[apply(test_puts, filter = all(tls13))]
3008 fn test_seed_successful_with_ccs(put: &str) {
3009 let runner = default_runner_for(put);
3010 let trace = seed_successful_with_ccs.build_trace();
3011
3012 let ctx = runner.execute(trace, &mut 0).unwrap();
3013
3014 assert!(ctx.agents_successful());
3015 }
3016
3017 #[apply(test_puts, filter = all(tls13, tls13_session_resumption))]
3020 fn test_seed_successful_with_tickets(put: &str) {
3021 let runner = default_runner_for(put);
3022 let trace = seed_successful_with_tickets.build_trace();
3023
3024 let ctx = runner.execute(trace, &mut 0).unwrap();
3025
3026 assert!(ctx.agents_successful());
3027 }
3028
3029 #[apply(test_puts, filter = all(tls12))]
3030 fn test_seed_successful12(put: &str) {
3031 let runner = default_runner_for(put);
3032
3033 let trace = if supports!(put, "tls12_session_resumption") {
3034 seed_successful12_with_tickets.build_trace()
3035 } else {
3036 seed_successful12.build_trace()
3037 };
3038
3039 let ctx = runner.execute(trace, &mut 0).unwrap();
3040
3041 assert!(ctx.agents_successful());
3042 }
3043
3044 #[apply(test_puts, filter = all(tls13, any(not(openssl), openssl340, openssl341), not(libressl))
3049 )]
3050 fn test_cipher_config_takes_effect(put: &str) {
3051 use crate::claims::Finished;
3052
3053 let client = AgentName::first();
3054 let server = client.next();
3055 let mut trace = seed_successful(client, server);
3056 trace =
3057 <TLSProtocolTypes as ProtocolTypes>::differential_fuzzing_uniformise_put_config(trace);
3058
3059 let runner = default_runner_for(put);
3060 let ctx = runner.execute(trace, &mut 0).unwrap();
3061 assert!(ctx.agents_successful());
3062
3063 let allowed_ciphers: &[u16] = &[0x1301, 0x1302, 0x1303];
3065
3066 let claim = ctx
3067 .find_claim(server, TypeShape::of::<Finished>())
3068 .expect(&format!("no Finished claim for server agent in {put}"));
3069 let finished = claim.as_ref().as_any().downcast_ref::<Finished>().unwrap();
3070 assert!(
3071 allowed_ciphers.contains(&finished.chosen_cipher),
3072 "{put}: server chosen_cipher 0x{:04x} not in configured set {allowed_ciphers:?}",
3073 finished.chosen_cipher,
3074 );
3075
3076 let allowed_sigalgs: &[i32] = &[0x0804, 0x0805, 0x0806, 0x0401, 0x0501, 0x0601];
3081 assert!(
3082 finished.signature_algorithm != 0,
3083 "{put}: server signature_algorithm not reported (== 0)",
3084 );
3085 assert!(
3086 allowed_sigalgs.contains(&finished.signature_algorithm),
3087 "{put}: server signature_algorithm 0x{:04x} not in configured set {allowed_sigalgs:?}",
3088 finished.signature_algorithm,
3089 );
3090 }
3091
3092 #[apply(test_puts, filter = all(tls12, not(libressl), not(openssl101f), not(openssl102u)))]
3097 fn test_cipher_config_tls12_takes_effect(put: &str) {
3098 use crate::claims::Finished;
3099
3100 let trace = if supports!(put, "tls12_session_resumption") {
3101 seed_successful12_with_tickets.build_trace()
3102 } else {
3103 seed_successful12.build_trace()
3104 };
3105 let server = AgentName::first().next();
3106
3107 let runner = default_runner_for(put);
3108 let ctx = runner.execute(trace, &mut 0).unwrap();
3109 assert!(ctx.agents_successful());
3110
3111 let claim = ctx
3112 .find_claim(server, TypeShape::of::<Finished>())
3113 .expect(&format!("no Finished claim for server agent in {put}"));
3114 let finished = claim.as_ref().as_any().downcast_ref::<Finished>().unwrap();
3115 assert!(
3117 finished.chosen_cipher != 0,
3118 "{put}: server Finished claim has chosen_cipher == 0 (cipher config not reported)",
3119 );
3120 assert!(
3123 (finished.chosen_cipher >> 8) == 0xC0,
3124 "{put}: server chosen_cipher 0x{:04x} is not an ECDHE cipher — \
3125 cipher config may not have taken effect",
3126 finished.chosen_cipher,
3127 );
3128 }
3129
3130 #[test_log::test]
3131 fn test_corpus_file_sizes() {
3132 use puffin::trace::Action;
3133
3134 let registry = tls_registry();
3135 let factory = registry.default();
3136
3137 for (trace, name) in create_corpus(factory) {
3138 for step in &trace.steps {
3139 match &step.action {
3140 Action::Input(input) => {
3141 let terms = input.recipe.size();
3144 assert!(
3145 terms < TermConstraints::default().max_result_term_size,
3146 "{} has step with too large term size {}!",
3147 name,
3148 terms
3149 );
3150 }
3151 Action::Output(_) => {}
3152 }
3153 }
3154 }
3155 }
3156
3157 #[test_log::test]
3158 fn test_term_sizes() {
3159 use puffin::trace::Action;
3160
3161 let client = puffin::agent::AgentName::first();
3162 let _server = client.next();
3163
3164 for (name, trace) in [
3165 seed_successful_client_auth.build_named_trace(),
3166 seed_successful.build_named_trace(),
3167 seed_successful_mitm.build_named_trace(),
3168 seed_successful12_with_tickets.build_named_trace(),
3169 seed_successful12.build_named_trace(),
3170 seed_successful_with_ccs.build_named_trace(),
3171 seed_successful_with_tickets.build_named_trace(),
3172 seed_server_attacker_full.build_named_trace(),
3173 seed_client_attacker_auth.build_named_trace(),
3174 seed_client_attacker.build_named_trace(),
3175 seed_client_attacker12.build_named_trace(),
3176 seed_session_resumption_dhe.build_named_trace(),
3177 seed_session_resumption_ke.build_named_trace(),
3178 seed_client_attacker_full.build_named_trace(),
3179 seed_server_attacker12.build_named_trace(),
3180 ] {
3182 for step in &trace.steps {
3183 match &step.action {
3184 Action::Input(input) => {
3185 let terms = input.recipe.size();
3188 assert!(
3189 terms < TermConstraints::default().max_result_term_size,
3190 "{} has step with too large term size {}!",
3191 name,
3192 terms
3193 );
3194 }
3195 Action::Output(_) => {}
3196 }
3197 }
3198 }
3199 }
3200
3201 pub mod serialization {
3202 use puffin::protocol::ProtocolTypes;
3203 use puffin::trace::Trace;
3204
3205 use crate::test_utils::prelude::*;
3206 use crate::tls::seeds::*;
3207
3208 fn test_postcard_serialization<PT: ProtocolTypes>(trace: Trace<PT>) {
3209 let serialized1 = trace.serialize_postcard().unwrap();
3210 let deserialized_trace =
3211 Trace::<TLSProtocolTypes>::deserialize_postcard(serialized1.as_ref()).unwrap();
3212 let serialized2 = deserialized_trace.serialize_postcard().unwrap();
3213
3214 assert_eq!(serialized1, serialized2);
3215 }
3216
3217 fn test_json_serialization<PT: ProtocolTypes>(trace: Trace<PT>) {
3218 let serialized1 = serde_json::to_string_pretty(&trace).unwrap();
3219 let deserialized_trace =
3220 serde_json::from_str::<Trace<TLSProtocolTypes>>(serialized1.as_str()).unwrap();
3221 let serialized2 = serde_json::to_string_pretty(&deserialized_trace).unwrap();
3222
3223 assert_eq!(serialized1, serialized2);
3224 }
3225
3226 #[test_log::test]
3227 fn test_serialisation_seed_seed_session_resumption_dhe_json() {
3228 let trace = seed_session_resumption_dhe.build_trace();
3229 test_json_serialization(trace);
3230 }
3231
3232 #[test_log::test]
3233 fn test_serialisation_seed_seed_session_resumption_ke_json() {
3234 let trace = seed_session_resumption_ke.build_trace();
3235 test_json_serialization(trace);
3236 }
3237
3238 #[test_log::test]
3239 fn test_serialisation_seed_client_attacker12_json() {
3240 let trace = seed_client_attacker12.build_trace();
3241 test_json_serialization(trace);
3242 }
3243
3244 #[test_log::test]
3245 fn test_serialisation_seed_server_attacker12_json() {
3246 let trace = seed_server_attacker12.build_trace();
3247 test_json_serialization(trace);
3248 }
3249
3250 #[test_log::test]
3251 fn test_serialisation_seed_successful_json() {
3252 let trace = seed_successful.build_trace();
3253 test_json_serialization(trace);
3254 }
3255
3256 #[test_log::test]
3257 fn test_serialisation_seed_successful_postcard() {
3258 let trace = seed_successful.build_trace();
3259 test_postcard_serialization(trace);
3260 }
3261
3262 #[test_log::test]
3263 fn test_serialisation_seed_successful12_json() {
3264 let trace = seed_successful12.build_trace();
3265 test_json_serialization(trace);
3266 }
3267
3268 #[test_log::test]
3269 fn test_serialisation_seed_client_attacker_auth_json() {
3270 let trace = seed_client_attacker_auth.build_trace();
3271 test_json_serialization(trace);
3272 }
3273
3274 #[test_log::test]
3275 fn test_serialisation_seed_client_attacker_auth_postcard() {
3276 let trace = seed_client_attacker_auth.build_trace();
3277 test_postcard_serialization(trace);
3278 }
3279
3280 #[test_log::test]
3281 fn test_serialisation_seed_server_attacker_full_json() {
3282 let trace = seed_server_attacker_full.build_trace();
3283 test_json_serialization(trace);
3284 }
3285
3286 #[test_log::test]
3287 fn test_serialisation_seed_server_attacker_full_postcard() {
3288 let trace = seed_server_attacker_full.build_trace();
3289 test_postcard_serialization(trace);
3290 }
3291 }
3292
3293 pub mod rustls {
3294 use puffin::codec::{Codec, Reader};
3295
3296 use crate::tls::rustls::msgs::base::Payload;
3297 use crate::tls::rustls::msgs::enums::{ContentType, HandshakeType, ProtocolVersion};
3298 use crate::tls::rustls::msgs::handshake::{
3299 CipherSuites, ClientExtensions, ClientHelloPayload, Compressions,
3300 HandshakeMessagePayload, HandshakePayload, Random, SessionID,
3301 };
3302 use crate::tls::rustls::msgs::message::MessagePayload::Handshake;
3303 use crate::tls::rustls::msgs::message::{Message, OpaqueMessage, PlainMessage};
3304
3305 fn create_message(opaque_message: OpaqueMessage) -> Message {
3306 Message::try_from(opaque_message.into_plain_message()).unwrap()
3307 }
3308
3309 #[test_log::test]
3310 fn test_rustls_message_stability_ch() {
3311 let hello_client_hex = "1603010136010001320303aa1795f64f48fcfcd0121368f88f176fe2570b07\
3312 68bbc85e9f2c80c557553d7d20e1e15d0028932f4f7479cf256302b7847d81a68e708525f9d38d94fc6ef742a30\
3313 03e130213031301c02cc030009fcca9cca8ccaac02bc02f009ec024c028006bc023c0270067c00ac0140039c009\
3314 c0130033009d009c003d003c0035002f00ff010000ab00000012001000000d6d6178616d6d616e6e2e6f7267000\
3315 b000403000102000a000c000a001d0017001e00190018002300000016000000170000000d0030002e0403050306\
3316 03080708080809080a080b080408050806040105010601030302030301020103020202040205020602002b00090\
3317 80304030303020301002d00020101003300260024001d00209b8a24e29770f7ed95bf330e7e3929b21090350a41\
3318 5ab4cdf01b04e9ffc0fc50";
3319
3320 let hello_client = hex::decode(hello_client_hex).unwrap();
3321
3322 let opaque_message =
3323 OpaqueMessage::read(&mut Reader::init(hello_client.as_slice())).unwrap();
3324 create_message(opaque_message);
3325 }
3326
3327 #[test_log::test]
3328 fn test_heartbleed_ch() {
3329 let hello_client_hex = "
3331 16 03 03 00 dc 01 00 00 d8 03 03 53
3332 43 5b 90 9d 9b 72 0b bc 0c bc 2b 92 a8 48 97 cf
3333 bd 39 04 cc 16 0a 85 03 90 9f 77 04 33 d4 de 00
3334 00 66 c0 14 c0 0a c0 22 c0 21 00 39 00 38 00 88
3335 00 87 c0 0f c0 05 00 35 00 84 c0 12 c0 08 c0 1c
3336 c0 1b 00 16 00 13 c0 0d c0 03 00 0a c0 13 c0 09
3337 c0 1f c0 1e 00 33 00 32 00 9a 00 99 00 45 00 44
3338 c0 0e c0 04 00 2f 00 96 00 41 c0 11 c0 07 c0 0c
3339 c0 02 00 05 00 04 00 15 00 12 00 09 00 14 00 11
3340 00 08 00 06 00 03 00 ff 01 00 00 49 00 0b 00 04
3341 03 00 01 02 00 0a 00 34 00 32 00 0e 00 0d 00 19
3342 00 0b 00 0c 00 18 00 09 00 0a 00 16 00 17 00 08
3343 00 06 00 07 00 14 00 15 00 04 00 05 00 12 00 13
3344 00 01 00 02 00 03 00 0f 00 10 00 11 00 23 00 00
3345 00 0f 00 01 01";
3346
3347 let hello_client =
3348 hex::decode(hello_client_hex.to_string().replace([' ', '\n'], "")).unwrap();
3349 let opaque_message =
3352 OpaqueMessage::read(&mut Reader::init(hello_client.as_slice())).unwrap();
3353 create_message(opaque_message);
3354 }
3355
3356 #[test_log::test]
3357 fn test_rustls_message_stability_ch_renegotiation() {
3358 let hello_client_hex = "16030300cc\
3360 010000c8030368254f1b232142c49512b09ac3929df07b6d461dc15473c064\
3361 e1ffdfbfd5cc9d000036c02cc030009fcca9cca8ccaac02bc02f009ec024c028006bc023c0270067c00ac014003\
3362 9c009c0130033009d009c003d003c0035002f01000069ff01000d0cdcf098f907352157bc31b073000b00040300\
3363 0102000a000c000a001d0017001e00190018002300000016000000170000000d0030002e0403050306030807080\
3364 80809080a080b080408050806040105010601030302030301020103020202040205020602";
3365
3366 let hello_client = hex::decode(hello_client_hex).unwrap();
3367 let opaque_message =
3370 OpaqueMessage::read(&mut Reader::init(hello_client.as_slice())).unwrap();
3371 create_message(opaque_message);
3372 }
3373
3374 #[test_log::test]
3376 fn test_server_hello_parsing() {
3377 let hex = "160303004a020000460303de257a3941501c11fa7898af1b1b2aea4f5e39e521b35dc84ffab\
3378 e830e9a98ec20e1cb49645b1cd6e2d0aa5c87b5a3837bcf33334e96c37a77a79c9df63413dc15c02f00";
3379 let binary = hex::decode(hex).unwrap();
3380 let opaque_message = OpaqueMessage::read(&mut Reader::init(binary.as_slice())).unwrap();
3381 create_message(opaque_message);
3382 }
3383
3384 #[test_log::test]
3385 fn test_encrypted_tls12_messages() {
3386 let hexn = vec![
3387 "1603030028155e38ddd323ca97440b4bb44fe810e9f4d10e5280795ca0660c7d8c8dddcd95355538a3d2cc0256",
3388 "16030300280d8d288b7a398d5c078280388c71106391756b19d1bb5c95ec18f5de8a0c772062df0d18f24e02b5",
3389 "16030300280032e43a49aa2134ac20d701f3427aee8cf7c397eb2b9ed88a09bfba4c9fe94a10e6c88be89a7a67",
3390 "1603030028149ee35e3205a0fea0fd2f14555c7fd0b6acc2bf926a674841375ed061dbf359ac64905c8c616095",
3391 "1603030028182bdc85dc708633cc973b23173fd1e9a7296c744ce44443c678b2be0d9c0b050b3b26f9cd697ed9",
3392 "160303002805330e9cee1941f19b744f7ddab94a8caf2afcc8ceb97e4389c4f7c0b329219bcbf4d68c1fc71266",
3393 "1603030028fe4121bb8fb7467a63b25cc96f2eb3df1ef61fc31431a37db61825a7680d85b9fc04e980055e65db",
3394 ];
3395
3396 for hex in hexn {
3397 let binary = hex::decode(hex).unwrap();
3398 let opaque_message =
3399 OpaqueMessage::read(&mut Reader::init(binary.as_slice())).unwrap();
3400 create_message(opaque_message);
3401 }
3402 }
3403
3404 #[test_log::test]
3405 fn test_rustls_message_stability_cert() {
3406 let cert_hex = "16030309b50b0009b1000009ad00053a308205363082041ea00302010202120400ca59\
3407 61d39c1622093596f2132488f93e300d06092a864886f70d01010b05003032310b3009060355040613025553311\
3408 63014060355040a130d4c6574277320456e6372797074310b3009060355040313025233301e170d323130333238\
3409 3031343335385a170d3231303632363031343335385a301c311a3018060355040313117777772e6d6178616d6d6\
3410 16e6e2e6f726730820122300d06092a864886f70d01010105000382010f003082010a0282010100b8ad1a3825f4\
3411 aa8f8cdf5221a5d98d29f93be72f470397e07e1ceca379376bf1b148d19feaf6c5d3b01b344369bcc50dd33f967\
3412 b281eec6edf4e9ee6b1a134589d40b3d3c2b2d51814ecafebcd59da1b01aea221af57f50e523694ac7603bf363b\
3413 3a5380d48bef06cffbae66123046a7cfb3055f35755b50c71c93aef4c2a0bc8badb56b37d07be0d3319cac9b2f2\
3414 10a29115b4b6377734b647088adcbc12cc82a59a5f10fe2478ab2937f4ed667fbbdda3c468148f974da14dda787\
3415 234811457d4a2d99677f27a3eae68f782c1291243e02653a4fe70ca4cb3d3eda66ba47926e25b25045b92ef8c20\
3416 a89b1b5fce69ac18091f1229d9be473f96f23ed40d43f0203010001a382025a30820256300e0603551d0f0101ff\
3417 0404030205a0301d0603551d250416301406082b0601050507030106082b06010505070302300c0603551d13010\
3418 1ff04023000301d0603551d0e0416041412b43a1e54091741afc831d1e4de7babcb110ebe301f0603551d230418\
3419 30168014142eb317b75856cbae500940e61faf9d8b14c2c6305506082b0601050507010104493047302106082b0\
3420 60105050730018615687474703a2f2f72332e6f2e6c656e63722e6f7267302206082b0601050507300286166874\
3421 74703a2f2f72332e692e6c656e63722e6f72672f302b0603551d1104243022820d6d6178616d6d616e6e2e6f726\
3422 782117777772e6d6178616d6d616e6e2e6f7267304c0603551d20044530433008060667810c0102013037060b2b\
3423 0601040182df130101013028302606082b06010505070201161a687474703a2f2f6370732e6c657473656e63727\
3424 970742e6f726730820103060a2b06010401d6790204020481f40481f100ef0076004494652eb0eeceafc44007d8\
3425 a8fe28c0dae682bed8cb31b53fd33396b5b681a80000017876b7770e000004030047304502201c5b58adfa5df8a\
3426 bf6077d94b765750a24d32b49b3af2dcf5c65efaf32c949d6022100866e2301bf3633cf54a33124459c9dc69e6f\
3427 953c9b2200f7c73919cefee849150075007d3ef2f88fff88556824c2c0ca9e5289792bc50e78097f2e6a9768997\
3428 e22f0d70000017876b7772e00000403004630440220030a54d2296566cab9b5fa3e6505566e5e014d48f15f6cd8\
3429 727896e2cc352eb302207aff1ae19ca44c14dc0e136583dde241f742f141ec518adf26c5b08d59d92936300d060\
3430 92a864886f70d01010b050003820101008c770bcf525fc99d9f8f04d279b724bbb2bebc42184e671aa392b05826\
3431 5b097de2d9f668f64e696d0048a00023ad2c6dfd5cc6f41bde11810d0fbad97822c6863012a4f0e8430a385cfeb\
3432 699278e99622af1cca45419cb61d59dcbb80464cf65ff07d15c05f69caf2a69970cae8b4533f5a006b9b9414cba\
3433 a6d8a8ac862c430dadb8149e6c151ff75efe0a69b17658b85dbd95a6eb363e52784b9f11c78bbe906ca303f58bb\
3434 eab8748e92d31344a6c297dfab4738351602951622cd3730f2b94ba7e68ecc1f678a79f5535f6758be357cf0a8a\
3435 9efa907c2980b2d281c270b7fb97d8c3e1d3af37089002d09e7524d8d441950da466ee77489d25018e5cfa05fe0\
3436 000000469308204653082034da0030201020210400175048314a4c8218c84a90c16cddf300d06092a864886f70d\
3437 01010b0500303f31243022060355040a131b4469676974616c205369676e617475726520547275737420436f2e3\
3438 11730150603550403130e44535420526f6f74204341205833301e170d3230313030373139323134305a170d3231\
3439 303932393139323134305a3032310b300906035504061302555331163014060355040a130d4c6574277320456e6\
3440 372797074310b300906035504031302523330820122300d06092a864886f70d01010105000382010f003082010a\
3441 0282010100bb021528ccf6a094d30f12ec8d5592c3f882f199a67a4288a75d26aab52bb9c54cb1af8e6bf975c8a\
3442 3d70f4794145535578c9ea8a23919f5823c42a94e6ef53bc32edb8dc0b05cf35938e7edcf69f05a0b1bbec09424\
3443 2587fa3771b313e71cace19befdbe43b45524596a9c153ce34c852eeb5aeed8fde6070e2a554abb66d0e97a5403\
3444 46b2bd3bc66eb66347cfa6b8b8f572999f830175dba726ffb81c5add286583d17c7e709bbf12bf786dcc1da715d\
3445 d446e3ccad25c188bc60677566b3f118f7a25ce653ff3a88b647a5ff1318ea9809773f9d53f9cf01e5f5a670171\
3446 4af63a4ff99b3939ddc53a706fe48851da169ae2575bb13cc5203f5ed51a18bdb150203010001a3820168308201\
3447 6430120603551d130101ff040830060101ff020100300e0603551d0f0101ff040403020186304b06082b0601050\
3448 5070101043f303d303b06082b06010505073002862f687474703a2f2f617070732e6964656e74727573742e636f\
3449 6d2f726f6f74732f647374726f6f74636178332e703763301f0603551d23041830168014c4a7b1a47b2c71fadbe\
3450 14b9075ffc4156085891030540603551d20044d304b3008060667810c010201303f060b2b0601040182df130101\
3451 013030302e06082b060105050702011622687474703a2f2f6370732e726f6f742d78312e6c657473656e6372797\
3452 0742e6f7267303c0603551d1f043530333031a02fa02d862b687474703a2f2f63726c2e6964656e74727573742e\
3453 636f6d2f445354524f4f544341583343524c2e63726c301d0603551d0e04160414142eb317b75856cbae500940e\
3454 61faf9d8b14c2c6301d0603551d250416301406082b0601050507030106082b06010505070302300d06092a8648\
3455 86f70d01010b05000382010100d94ce0c9f584883731dbbb13e2b3fc8b6b62126c58b7497e3c02b7a81f2861ebc\
3456 ee02e73ef49077a35841f1dad68f0d8fe56812f6d7f58a66e3536101c73c3e5bd6d5e01d76e72fb2aa0b8d35764\
3457 e55bc269d4d0b2f77c4bc3178e887273dcfdfc6dbde3c90b8e613a16587d74362b55803dc763be8443c639a10e6\
3458 b579e3f29c180f6b2bd47cbaa306cb732e159540b1809175e636cfb96673c1c730c938bc611762486de400707e4\
3459 7d2d66b525a39658c8ea80eecf693b96fce68dc033f389f8292d14142d7ef06170955df70be5c0fb24faec8ecb6\
3460 1c8ee637128a82c053b77ef9b5e0364f051d1e485535cb00297d47ec634d2ce1000e4b1df3ac2ea17be0000";
3461
3462 let cert = hex::decode(cert_hex).unwrap();
3463
3464 let mut opaque_message =
3465 OpaqueMessage::read(&mut Reader::init(cert.as_slice())).unwrap();
3466 opaque_message.version = ProtocolVersion::TLSv1_3;
3468 create_message(opaque_message);
3469 }
3470
3471 #[test_log::test]
3472 fn test_encrypted_tls12_into_message() {
3473 let opaque_message = OpaqueMessage {
3474 typ: ContentType::Handshake,
3475 version: ProtocolVersion::TLSv1_2,
3476 payload: Payload::new(vec![1, 2, 3]),
3477 };
3478
3479 create_message(opaque_message);
3480 }
3481
3482 #[test_log::test]
3483 fn test_rustls_message_stability() {
3484 let random = [0u8; 32];
3485 let message = Message {
3486 version: ProtocolVersion::TLSv1_2,
3487 payload: Handshake(HandshakeMessagePayload {
3488 typ: HandshakeType::ClientHello,
3489 payload: HandshakePayload::ClientHello(ClientHelloPayload {
3490 client_version: ProtocolVersion::TLSv1_3,
3491 random: Random::from(random),
3492 session_id: SessionID::empty(),
3493 cipher_suites: CipherSuites(vec![]),
3494 compression_methods: Compressions(vec![]),
3495 extensions: ClientExtensions(vec![]),
3496 }),
3497 }),
3498 };
3499
3500 let mut out: Vec<u8> = Vec::new();
3501 out.append(
3502 &mut PlainMessage::from(message)
3503 .into_unencrypted_opaque()
3504 .get_encoding(),
3505 );
3506 let opaque_message = OpaqueMessage::read(&mut Reader::init(out.as_slice())).unwrap();
3509 create_message(opaque_message);
3510 }
3511 }
3512
3513 #[apply(test_puts, filter = all(tls13, not(any(wolfssl430, wolfssl440))))]
3517 fn test_trigger_alert(put: &str) {
3518 let trace = Trace {
3520 prior_traces: vec![],
3521 descriptors: vec![AgentDescriptor::from_config(
3522 AgentName::first(),
3523 TLSDescriptorConfig {
3524 tls_version: TLSVersion::V1_3,
3525 typ: AgentType::Server,
3526 ..TLSDescriptorConfig::default()
3527 },
3528 )],
3529 steps: vec![Step {
3530 agent: AgentName::first(),
3531 action: Action::Input(input_action! { term! {
3532 fn_client_hello(
3534 fn_protocol_version12,
3535 fn_new_random,
3536 fn_new_session_id,
3537 (fn_cipher_suites_make(
3538 fn_new_cipher_suites
3539 )),
3540 fn_compressions,
3541 (fn_client_extensions_make(
3542 fn_client_extensions_new
3543 ))
3544 )
3545 }
3546 }),
3547 }],
3548 ..Default::default()
3549 };
3550
3551 let mut ctx = puffin::trace::TraceContext::new(
3552 puffin::trace::Spawner::new(tls_registry()).with_mapping(&[(
3553 AgentName::first(),
3554 PutDescriptor::new(put, PutOptions::empty()),
3555 )]),
3556 );
3557 let _ = trace.execute(&mut ctx, &mut 0, true);
3558
3559 let alert = ctx.find_variable(
3561 TypeShape::of::<Message>(),
3562 &Query {
3563 source: None,
3564 matcher: Some(TlsQueryMatcher::Alert),
3565 counter: 0,
3566 },
3567 );
3568
3569 assert!(alert.is_some());
3570 }
3571
3572 #[allow(dead_code)]
3574 fn assert_no_differential_differences(first_put: &str, second_put: &str) {
3575 use puffin::execution::{DifferentialRunner, TraceRunner};
3576 use puffin::protocol::ProtocolTypes;
3577 use puffin::trace::Spawner;
3578
3579 use crate::protocol::TLSProtocolTypes;
3580
3581 let registry = crate::put_registry::tls_registry();
3582 let first_factory = registry
3583 .find_by_id(first_put)
3584 .expect("first differential PUT must exist in the TLS registry");
3585 let second_factory = registry
3586 .find_by_id(second_put)
3587 .expect("second differential PUT must exist in the TLS registry");
3588
3589 let second_seed_names: std::collections::HashSet<_> = super::create_corpus(second_factory)
3590 .into_iter()
3591 .map(|(_, name)| name)
3592 .collect();
3593 let corpus: Vec<_> = super::create_corpus(first_factory)
3594 .into_iter()
3595 .filter(|(_, name)| second_seed_names.contains(name))
3596 .collect();
3597
3598 for (trace, name) in corpus {
3599 let trace =
3600 <TLSProtocolTypes as ProtocolTypes>::differential_fuzzing_uniformise_put_config(
3601 trace,
3602 );
3603 let first_mappings: Vec<_> = trace
3607 .all_descriptors()
3608 .iter()
3609 .map(|d| {
3610 (
3611 d.name,
3612 PutDescriptor::new(first_put, registry.default_put_options().clone()),
3613 )
3614 })
3615 .collect();
3616 let second_mappings: Vec<_> = trace
3617 .all_descriptors()
3618 .iter()
3619 .map(|d| {
3620 (
3621 d.name,
3622 PutDescriptor::new(second_put, registry.default_put_options().clone()),
3623 )
3624 })
3625 .collect();
3626
3627 let runner = DifferentialRunner::new(
3628 registry.clone(),
3629 Spawner::new(registry.clone()).with_mapping(&first_mappings),
3630 Spawner::new(registry.clone()).with_mapping(&second_mappings),
3631 );
3632
3633 let result = runner.execute(trace, &mut 0);
3634 assert!(
3635 result.is_ok(),
3636 "Differential test failed between {} and {}: seed '{}': {:?}",
3637 first_put,
3638 second_put,
3639 name,
3640 result.err()
3641 );
3642 }
3643 }
3644
3645 #[apply(test_differential_puts, first = "openssl340", second = "wolfssl580")]
3646 fn test_differential_openssl340_vs_wolfssl580() {
3647 assert_no_differential_differences("openssl340", "wolfssl580");
3648 }
3649
3650 #[apply(test_differential_puts, first = "openssl340", second = "libressl421")]
3651 fn test_differential_openssl340_vs_libressl421() {
3652 assert_no_differential_differences("openssl340", "libressl421");
3653 }
3654
3655 #[apply(test_differential_puts, first = "openssl340", second = "libressl333")]
3656 fn test_differential_openssl340_vs_libressl333() {
3657 assert_no_differential_differences("openssl340", "libressl333");
3658 }
3659
3660 #[apply(
3661 test_differential_puts,
3662 first = "openssl340",
3663 second = "boringssl20260508"
3664 )]
3665 fn test_differential_openssl340_vs_boringssl20260508() {
3666 assert_no_differential_differences("openssl340", "boringssl20260508");
3667 }
3668}