1 use super::*;
2 
3 #[tokio::test]
4 async fn test_handshake_cache_single_push() -> Result<()> {
5     let tests = vec![
6         (
7             "Single Push",
8             vec![HandshakeCacheItem {
9                 typ: 0.into(),
10                 is_client: true,
11                 epoch: 0,
12                 message_sequence: 0,
13                 data: vec![0x00],
14             }],
15             vec![HandshakeCachePullRule {
16                 typ: 0.into(),
17                 epoch: 0,
18                 is_client: true,
19                 optional: false,
20             }],
21             vec![0x00],
22         ),
23         (
24             "Multi Push",
25             vec![
26                 HandshakeCacheItem {
27                     typ: 0.into(),
28                     is_client: true,
29                     epoch: 0,
30                     message_sequence: 0,
31                     data: vec![0x00],
32                 },
33                 HandshakeCacheItem {
34                     typ: 1.into(),
35                     is_client: true,
36                     epoch: 0,
37                     message_sequence: 1,
38                     data: vec![0x01],
39                 },
40                 HandshakeCacheItem {
41                     typ: 2.into(),
42                     is_client: true,
43                     epoch: 0,
44                     message_sequence: 2,
45                     data: vec![0x02],
46                 },
47             ],
48             vec![
49                 HandshakeCachePullRule {
50                     typ: 0.into(),
51                     epoch: 0,
52                     is_client: true,
53                     optional: false,
54                 },
55                 HandshakeCachePullRule {
56                     typ: 1.into(),
57                     epoch: 0,
58                     is_client: true,
59                     optional: false,
60                 },
61                 HandshakeCachePullRule {
62                     typ: 2.into(),
63                     epoch: 0,
64                     is_client: true,
65                     optional: false,
66                 },
67             ],
68             vec![0x00, 0x01, 0x02],
69         ),
70         (
71             "Multi Push, Rules set order",
72             vec![
73                 HandshakeCacheItem {
74                     typ: 2.into(),
75                     is_client: true,
76                     epoch: 0,
77                     message_sequence: 2,
78                     data: vec![0x02],
79                 },
80                 HandshakeCacheItem {
81                     typ: 0.into(),
82                     is_client: true,
83                     epoch: 0,
84                     message_sequence: 0,
85                     data: vec![0x00],
86                 },
87                 HandshakeCacheItem {
88                     typ: 1.into(),
89                     is_client: true,
90                     epoch: 0,
91                     message_sequence: 1,
92                     data: vec![0x01],
93                 },
94             ],
95             vec![
96                 HandshakeCachePullRule {
97                     typ: 0.into(),
98                     epoch: 0,
99                     is_client: true,
100                     optional: false,
101                 },
102                 HandshakeCachePullRule {
103                     typ: 1.into(),
104                     epoch: 0,
105                     is_client: true,
106                     optional: false,
107                 },
108                 HandshakeCachePullRule {
109                     typ: 2.into(),
110                     epoch: 0,
111                     is_client: true,
112                     optional: false,
113                 },
114             ],
115             vec![0x00, 0x01, 0x02],
116         ),
117         (
118             "Multi Push, Dupe Seqnum",
119             vec![
120                 HandshakeCacheItem {
121                     typ: 0.into(),
122                     is_client: true,
123                     epoch: 0,
124                     message_sequence: 0,
125                     data: vec![0x00],
126                 },
127                 HandshakeCacheItem {
128                     typ: 1.into(),
129                     is_client: true,
130                     epoch: 0,
131                     message_sequence: 1,
132                     data: vec![0x01],
133                 },
134                 HandshakeCacheItem {
135                     typ: 1.into(),
136                     is_client: true,
137                     epoch: 0,
138                     message_sequence: 1,
139                     data: vec![0x01],
140                 },
141             ],
142             vec![
143                 HandshakeCachePullRule {
144                     typ: 0.into(),
145                     epoch: 0,
146                     is_client: true,
147                     optional: false,
148                 },
149                 HandshakeCachePullRule {
150                     typ: 1.into(),
151                     epoch: 0,
152                     is_client: true,
153                     optional: false,
154                 },
155             ],
156             vec![0x00, 0x01],
157         ),
158         (
159             "Multi Push, Dupe Seqnum Client/Server",
160             vec![
161                 HandshakeCacheItem {
162                     typ: 0.into(),
163                     is_client: true,
164                     epoch: 0,
165                     message_sequence: 0,
166                     data: vec![0x00],
167                 },
168                 HandshakeCacheItem {
169                     typ: 1.into(),
170                     is_client: true,
171                     epoch: 0,
172                     message_sequence: 1,
173                     data: vec![0x01],
174                 },
175                 HandshakeCacheItem {
176                     typ: 1.into(),
177                     is_client: false,
178                     epoch: 0,
179                     message_sequence: 1,
180                     data: vec![0x02],
181                 },
182             ],
183             vec![
184                 HandshakeCachePullRule {
185                     typ: 0.into(),
186                     epoch: 0,
187                     is_client: true,
188                     optional: false,
189                 },
190                 HandshakeCachePullRule {
191                     typ: 1.into(),
192                     epoch: 0,
193                     is_client: true,
194                     optional: false,
195                 },
196                 HandshakeCachePullRule {
197                     typ: 1.into(),
198                     epoch: 0,
199                     is_client: false,
200                     optional: false,
201                 },
202             ],
203             vec![0x00, 0x01, 0x02],
204         ),
205         (
206             "Multi Push, Dupe Seqnum with Unique HandshakeType",
207             vec![
208                 HandshakeCacheItem {
209                     typ: 1.into(),
210                     is_client: true,
211                     epoch: 0,
212                     message_sequence: 0,
213                     data: vec![0x00],
214                 },
215                 HandshakeCacheItem {
216                     typ: 2.into(),
217                     is_client: true,
218                     epoch: 0,
219                     message_sequence: 1,
220                     data: vec![0x01],
221                 },
222                 HandshakeCacheItem {
223                     typ: 3.into(),
224                     is_client: false,
225                     epoch: 0,
226                     message_sequence: 0,
227                     data: vec![0x02],
228                 },
229             ],
230             vec![
231                 HandshakeCachePullRule {
232                     typ: 1.into(),
233                     epoch: 0,
234                     is_client: true,
235                     optional: false,
236                 },
237                 HandshakeCachePullRule {
238                     typ: 2.into(),
239                     epoch: 0,
240                     is_client: true,
241                     optional: false,
242                 },
243                 HandshakeCachePullRule {
244                     typ: 3.into(),
245                     epoch: 0,
246                     is_client: false,
247                     optional: false,
248                 },
249             ],
250             vec![0x00, 0x01, 0x02],
251         ),
252         (
253             "Multi Push, Wrong epoch",
254             vec![
255                 HandshakeCacheItem {
256                     typ: 1.into(),
257                     is_client: true,
258                     epoch: 0,
259                     message_sequence: 0,
260                     data: vec![0x00],
261                 },
262                 HandshakeCacheItem {
263                     typ: 2.into(),
264                     is_client: true,
265                     epoch: 1,
266                     message_sequence: 1,
267                     data: vec![0x01],
268                 },
269                 HandshakeCacheItem {
270                     typ: 2.into(),
271                     is_client: true,
272                     epoch: 0,
273                     message_sequence: 2,
274                     data: vec![0x11],
275                 },
276                 HandshakeCacheItem {
277                     typ: 3.into(),
278                     is_client: false,
279                     epoch: 0,
280                     message_sequence: 0,
281                     data: vec![0x02],
282                 },
283                 HandshakeCacheItem {
284                     typ: 3.into(),
285                     is_client: false,
286                     epoch: 1,
287                     message_sequence: 0,
288                     data: vec![0x12],
289                 },
290                 HandshakeCacheItem {
291                     typ: 3.into(),
292                     is_client: false,
293                     epoch: 2,
294                     message_sequence: 0,
295                     data: vec![0x12],
296                 },
297             ],
298             vec![
299                 HandshakeCachePullRule {
300                     typ: 1.into(),
301                     epoch: 0,
302                     is_client: true,
303                     optional: false,
304                 },
305                 HandshakeCachePullRule {
306                     typ: 2.into(),
307                     epoch: 1,
308                     is_client: true,
309                     optional: false,
310                 },
311                 HandshakeCachePullRule {
312                     typ: 3.into(),
313                     epoch: 0,
314                     is_client: false,
315                     optional: false,
316                 },
317             ],
318             vec![0x00, 0x01, 0x02],
319         ),
320     ];
321 
322     for (name, inputs, rules, expected) in tests {
323         let mut h = HandshakeCache::new();
324         for i in inputs {
325             h.push(i.data, i.epoch, i.message_sequence, i.typ, i.is_client)
326                 .await;
327         }
328         let verify_data = h.pull_and_merge(&rules).await;
329         assert_eq!(
330             verify_data, expected,
331             "handshakeCache '{}' exp:{:?} actual {:?}",
332             name, expected, verify_data,
333         );
334     }
335 
336     Ok(())
337 }
338 
339 #[tokio::test]
340 async fn test_handshake_cache_session_hash() -> Result<()> {
341     let tests = vec![
342         (
343             "Standard Handshake",
344             vec![
345                 HandshakeCacheItem {
346                     typ: HandshakeType::ClientHello,
347                     is_client: true,
348                     epoch: 0,
349                     message_sequence: 0,
350                     data: vec![0x00],
351                 },
352                 HandshakeCacheItem {
353                     typ: HandshakeType::ServerHello,
354                     is_client: false,
355                     epoch: 0,
356                     message_sequence: 1,
357                     data: vec![0x01],
358                 },
359                 HandshakeCacheItem {
360                     typ: HandshakeType::Certificate,
361                     is_client: false,
362                     epoch: 0,
363                     message_sequence: 2,
364                     data: vec![0x02],
365                 },
366                 HandshakeCacheItem {
367                     typ: HandshakeType::ServerKeyExchange,
368                     is_client: false,
369                     epoch: 0,
370                     message_sequence: 3,
371                     data: vec![0x03],
372                 },
373                 HandshakeCacheItem {
374                     typ: HandshakeType::ServerHelloDone,
375                     is_client: false,
376                     epoch: 0,
377                     message_sequence: 4,
378                     data: vec![0x04],
379                 },
380                 HandshakeCacheItem {
381                     typ: HandshakeType::ClientKeyExchange,
382                     is_client: true,
383                     epoch: 0,
384                     message_sequence: 5,
385                     data: vec![0x05],
386                 },
387             ],
388             vec![
389                 0x17, 0xe8, 0x8d, 0xb1, 0x87, 0xaf, 0xd6, 0x2c, 0x16, 0xe5, 0xde, 0xbf, 0x3e, 0x65,
390                 0x27, 0xcd, 0x00, 0x6b, 0xc0, 0x12, 0xbc, 0x90, 0xb5, 0x1a, 0x81, 0x0c, 0xd8, 0x0c,
391                 0x2d, 0x51, 0x1f, 0x43,
392             ],
393         ),
394         (
395             "Handshake With Client Cert Request",
396             vec![
397                 HandshakeCacheItem {
398                     typ: HandshakeType::ClientHello,
399                     is_client: true,
400                     epoch: 0,
401                     message_sequence: 0,
402                     data: vec![0x00],
403                 },
404                 HandshakeCacheItem {
405                     typ: HandshakeType::ServerHello,
406                     is_client: false,
407                     epoch: 0,
408                     message_sequence: 1,
409                     data: vec![0x01],
410                 },
411                 HandshakeCacheItem {
412                     typ: HandshakeType::Certificate,
413                     is_client: false,
414                     epoch: 0,
415                     message_sequence: 2,
416                     data: vec![0x02],
417                 },
418                 HandshakeCacheItem {
419                     typ: HandshakeType::ServerKeyExchange,
420                     is_client: false,
421                     epoch: 0,
422                     message_sequence: 3,
423                     data: vec![0x03],
424                 },
425                 HandshakeCacheItem {
426                     typ: HandshakeType::CertificateRequest,
427                     is_client: false,
428                     epoch: 0,
429                     message_sequence: 4,
430                     data: vec![0x04],
431                 },
432                 HandshakeCacheItem {
433                     typ: HandshakeType::ServerHelloDone,
434                     is_client: false,
435                     epoch: 0,
436                     message_sequence: 5,
437                     data: vec![0x05],
438                 },
439                 HandshakeCacheItem {
440                     typ: HandshakeType::ClientKeyExchange,
441                     is_client: true,
442                     epoch: 0,
443                     message_sequence: 6,
444                     data: vec![0x06],
445                 },
446             ],
447             vec![
448                 0x57, 0x35, 0x5a, 0xc3, 0x30, 0x3c, 0x14, 0x8f, 0x11, 0xae, 0xf7, 0xcb, 0x17, 0x94,
449                 0x56, 0xb9, 0x23, 0x2c, 0xde, 0x33, 0xa8, 0x18, 0xdf, 0xda, 0x2c, 0x2f, 0xcb, 0x93,
450                 0x25, 0x74, 0x9a, 0x6b,
451             ],
452         ),
453         (
454             "Handshake Ignores after ClientKeyExchange",
455             vec![
456                 HandshakeCacheItem {
457                     typ: HandshakeType::ClientHello,
458                     is_client: true,
459                     epoch: 0,
460                     message_sequence: 0,
461                     data: vec![0x00],
462                 },
463                 HandshakeCacheItem {
464                     typ: HandshakeType::ServerHello,
465                     is_client: false,
466                     epoch: 0,
467                     message_sequence: 1,
468                     data: vec![0x01],
469                 },
470                 HandshakeCacheItem {
471                     typ: HandshakeType::Certificate,
472                     is_client: false,
473                     epoch: 0,
474                     message_sequence: 2,
475                     data: vec![0x02],
476                 },
477                 HandshakeCacheItem {
478                     typ: HandshakeType::ServerKeyExchange,
479                     is_client: false,
480                     epoch: 0,
481                     message_sequence: 3,
482                     data: vec![0x03],
483                 },
484                 HandshakeCacheItem {
485                     typ: HandshakeType::CertificateRequest,
486                     is_client: false,
487                     epoch: 0,
488                     message_sequence: 4,
489                     data: vec![0x04],
490                 },
491                 HandshakeCacheItem {
492                     typ: HandshakeType::ServerHelloDone,
493                     is_client: false,
494                     epoch: 0,
495                     message_sequence: 5,
496                     data: vec![0x05],
497                 },
498                 HandshakeCacheItem {
499                     typ: HandshakeType::ClientKeyExchange,
500                     is_client: true,
501                     epoch: 0,
502                     message_sequence: 6,
503                     data: vec![0x06],
504                 },
505                 HandshakeCacheItem {
506                     typ: HandshakeType::CertificateVerify,
507                     is_client: true,
508                     epoch: 0,
509                     message_sequence: 7,
510                     data: vec![0x07],
511                 },
512                 HandshakeCacheItem {
513                     typ: HandshakeType::Finished,
514                     is_client: true,
515                     epoch: 1,
516                     message_sequence: 7,
517                     data: vec![0x08],
518                 },
519                 HandshakeCacheItem {
520                     typ: HandshakeType::Finished,
521                     is_client: false,
522                     epoch: 1,
523                     message_sequence: 7,
524                     data: vec![0x09],
525                 },
526             ],
527             vec![
528                 0x57, 0x35, 0x5a, 0xc3, 0x30, 0x3c, 0x14, 0x8f, 0x11, 0xae, 0xf7, 0xcb, 0x17, 0x94,
529                 0x56, 0xb9, 0x23, 0x2c, 0xde, 0x33, 0xa8, 0x18, 0xdf, 0xda, 0x2c, 0x2f, 0xcb, 0x93,
530                 0x25, 0x74, 0x9a, 0x6b,
531             ],
532         ),
533         (
534             "Handshake Ignores wrong epoch",
535             vec![
536                 HandshakeCacheItem {
537                     typ: HandshakeType::ClientHello,
538                     is_client: true,
539                     epoch: 0,
540                     message_sequence: 0,
541                     data: vec![0x00],
542                 },
543                 HandshakeCacheItem {
544                     typ: HandshakeType::ServerHello,
545                     is_client: false,
546                     epoch: 0,
547                     message_sequence: 1,
548                     data: vec![0x01],
549                 },
550                 HandshakeCacheItem {
551                     typ: HandshakeType::Certificate,
552                     is_client: false,
553                     epoch: 0,
554                     message_sequence: 2,
555                     data: vec![0x02],
556                 },
557                 HandshakeCacheItem {
558                     typ: HandshakeType::ServerKeyExchange,
559                     is_client: false,
560                     epoch: 0,
561                     message_sequence: 3,
562                     data: vec![0x03],
563                 },
564                 HandshakeCacheItem {
565                     typ: HandshakeType::CertificateRequest,
566                     is_client: false,
567                     epoch: 0,
568                     message_sequence: 4,
569                     data: vec![0x04],
570                 },
571                 HandshakeCacheItem {
572                     typ: HandshakeType::ServerHelloDone,
573                     is_client: false,
574                     epoch: 0,
575                     message_sequence: 5,
576                     data: vec![0x05],
577                 },
578                 HandshakeCacheItem {
579                     typ: HandshakeType::ClientKeyExchange,
580                     is_client: true,
581                     epoch: 0,
582                     message_sequence: 6,
583                     data: vec![0x06],
584                 },
585                 HandshakeCacheItem {
586                     typ: HandshakeType::CertificateVerify,
587                     is_client: true,
588                     epoch: 0,
589                     message_sequence: 7,
590                     data: vec![0x07],
591                 },
592                 HandshakeCacheItem {
593                     typ: HandshakeType::Finished,
594                     is_client: true,
595                     epoch: 0,
596                     message_sequence: 7,
597                     data: vec![0xf0],
598                 },
599                 HandshakeCacheItem {
600                     typ: HandshakeType::Finished,
601                     is_client: false,
602                     epoch: 0,
603                     message_sequence: 7,
604                     data: vec![0xf1],
605                 },
606                 HandshakeCacheItem {
607                     typ: HandshakeType::Finished,
608                     is_client: true,
609                     epoch: 1,
610                     message_sequence: 7,
611                     data: vec![0x08],
612                 },
613                 HandshakeCacheItem {
614                     typ: HandshakeType::Finished,
615                     is_client: false,
616                     epoch: 1,
617                     message_sequence: 7,
618                     data: vec![0x09],
619                 },
620                 HandshakeCacheItem {
621                     typ: HandshakeType::Finished,
622                     is_client: true,
623                     epoch: 0,
624                     message_sequence: 7,
625                     data: vec![0xf0],
626                 },
627                 HandshakeCacheItem {
628                     typ: HandshakeType::Finished,
629                     is_client: false,
630                     epoch: 0,
631                     message_sequence: 7,
632                     data: vec![0xf1],
633                 },
634             ],
635             vec![
636                 0x57, 0x35, 0x5a, 0xc3, 0x30, 0x3c, 0x14, 0x8f, 0x11, 0xae, 0xf7, 0xcb, 0x17, 0x94,
637                 0x56, 0xb9, 0x23, 0x2c, 0xde, 0x33, 0xa8, 0x18, 0xdf, 0xda, 0x2c, 0x2f, 0xcb, 0x93,
638                 0x25, 0x74, 0x9a, 0x6b,
639             ],
640         ),
641     ];
642 
643     for (name, inputs, expected) in tests {
644         let mut h = HandshakeCache::new();
645         for i in inputs {
646             h.push(i.data, i.epoch, i.message_sequence, i.typ, i.is_client)
647                 .await;
648         }
649 
650         let verify_data = h.session_hash(CipherSuiteHash::Sha256, 0, &[]).await?;
651 
652         assert_eq!(
653             verify_data, expected,
654             "handshakeCacheSesssionHassh '{}' exp: {:?} actual {:?}",
655             name, expected, verify_data
656         );
657     }
658 
659     Ok(())
660 }
661