Debian Codegraph @

tests/test_main.py

raw
1 # -*- coding: utf-8 -*-
2 # Copyright: (c) 2021, Jordan Borean (@jborean93) <[email protected]>
3 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
4
5 import base64
6 import io
7 import json
8 import os.path
9
10 import pytest
11
12 import spnego.__main__ as entrypoint
13 from spnego._ntlm_raw.messages import (
14 Authenticate,
15 AvId,
16 Challenge,
17 Negotiate,
18 SingleHost,
19 TargetInfo,
20 )
21 from spnego._spnego import NegTokenResp
22
23 from .conftest import get_data
24
25
26 def test_parse_with_hex(capsys):
27 entrypoint.main(["--token", base64.b16encode(get_data("ntlm_negotiate")).decode().lower()])
28 actual_out = capsys.readouterr()
29
30 assert actual_out.err == ""
31 actual = json.loads(actual_out.out)
32
33 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
34 assert actual["RawData"] is not None
35 assert actual["Data"] is not None
36
37
38 def test_parse_with_file(capsys):
39 entrypoint.main(["--file", os.path.join(os.path.dirname(__file__), "data", "ntlm_negotiate")])
40 actual_out = capsys.readouterr()
41
42 assert actual_out.err == ""
43 actual = json.loads(actual_out.out)
44
45 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
46 assert actual["RawData"] is not None
47 assert actual["Data"] is not None
48
49
50 def test_parse_with_file_missing():
51 with pytest.raises(ValueError, match="Cannot find file at path"):
52 entrypoint.main(["--file", "missing"])
53
54
55 def test_parse_from_stdin(capsys, monkeypatch):
56 monkeypatch.setattr("sys.stdin", io.TextIOWrapper(io.BytesIO(get_data("ntlm_negotiate"))))
57 entrypoint.main([])
58 actual_out = capsys.readouterr()
59
60 assert actual_out.err == ""
61 actual = json.loads(actual_out.out)
62
63 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
64 assert actual["RawData"] is not None
65 assert actual["Data"] is not None
66
67
68 def test_parse_from_stdin_base16(capsys, monkeypatch):
69 monkeypatch.setattr("sys.stdin", io.TextIOWrapper(io.BytesIO(base64.b16encode(get_data("ntlm_negotiate")))))
70 entrypoint.main([])
71 actual_out = capsys.readouterr()
72
73 assert actual_out.err == ""
74 actual = json.loads(actual_out.out)
75
76 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
77 assert actual["RawData"] is not None
78 assert actual["Data"] is not None
79
80
81 def test_parse_from_stdin_base64(capsys, monkeypatch):
82 monkeypatch.setattr("sys.stdin", io.TextIOWrapper(io.BytesIO(base64.b64encode(get_data("ntlm_negotiate")))))
83 entrypoint.main([])
84 actual_out = capsys.readouterr()
85
86 assert actual_out.err == ""
87 actual = json.loads(actual_out.out)
88
89 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
90 assert actual["RawData"] is not None
91 assert actual["Data"] is not None
92
93
94 def test_parse_output_yaml(capsys):
95 ruamel = pytest.importorskip("ruamel")
96 entrypoint.main(
97 [
98 "--token",
99 base64.b64encode(get_data("ntlm_negotiate")).decode(),
100 "--format",
101 "yaml",
102 ]
103 )
104 actual_out = capsys.readouterr()
105
106 assert actual_out.err == ""
107 with pytest.raises(ValueError):
108 json.loads(actual_out.out)
109
110 loader = ruamel.yaml.YAML(typ="safe", pure=True)
111 actual = loader.load(actual_out.out)
112
113 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
114 assert actual["RawData"] is not None
115 assert actual["Data"] is not None
116
117
118 def test_parse_output_yaml_not_installed(monkeypatch):
119 monkeypatch.setattr(entrypoint, "HAS_YAML", False)
120
121 with pytest.raises(ValueError, match="Cannot output as yaml as ruamel.yaml is not installed"):
122 entrypoint.main(
123 [
124 "--token",
125 base64.b64encode(get_data("ntlm_negotiate")).decode(),
126 "--format",
127 "yaml",
128 ]
129 )
130
131
132 def test_parse_invalid_spnego_token(capsys):
133 resp = NegTokenResp(response_token=b"invalid")
134 entrypoint.main(
135 [
136 "--token",
137 base64.b64encode(resp.pack()).decode(),
138 ]
139 )
140 actual_out = capsys.readouterr()
141
142 assert actual_out.err == ""
143 actual = json.loads(actual_out.out)
144
145 assert actual["MessageType"] == "SPNEGO NegTokenResp"
146 assert actual["RawData"] is not None
147 assert actual["Data"]["negState"] is None
148 assert actual["Data"]["supportedMech"] is None
149 assert actual["Data"]["responseToken"]["MessageType"] == "Unknown - Failed to parse see Data for more details."
150 assert (
151 actual["Data"]["responseToken"]["Data"]
152 == "Failed to parse token: Expecting a tag number of 0 not 9 for InitialContextToken"
153 )
154 assert actual["Data"]["responseToken"]["RawData"] == "696E76616C6964"
155 assert actual["Data"]["mechListMIC"] is None
156
157
158 def test_ntlm_negotiate(capsys):
159 entrypoint.main(["--token", base64.b64encode(get_data("ntlm_negotiate")).decode()])
160 actual_out = capsys.readouterr()
161
162 assert actual_out.err == ""
163 actual = json.loads(actual_out.out)
164
165 assert actual["MessageType"] == "NEGOTIATE_MESSAGE (1)"
166 assert actual["RawData"] is not None
167
168 assert actual["Data"]["NegotiateFlags"]["raw"] == 3792208567
169 assert set(actual["Data"]["NegotiateFlags"]["flags"]) == {
170 "NTLMSSP_NEGOTIATE_56 (2147483648)",
171 "NTLMSSP_NEGOTIATE_KEY_EXCH (1073741824)",
172 "NTLMSSP_NEGOTIATE_128 (536870912)",
173 "NTLMSSP_NEGOTIATE_VERSION (33554432)",
174 "NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY (524288)",
175 "NTLMSSP_NEGOTIATE_ALWAYS_SIGN (32768)",
176 "NTLMSSP_NEGOTIATE_NTLM (512)",
177 "NTLMSSP_NEGOTIATE_LM_KEY (128)",
178 "NTLMSSP_NEGOTIATE_SEAL (32)",
179 "NTLMSSP_NEGOTIATE_SIGN (16)",
180 "NTLMSSP_REQUEST_TARGET (4)",
181 "NTLMSSP_NEGOTIATE_OEM (2)",
182 "NTLMSSP_NEGOTIATE_UNICODE (1)",
183 }
184
185 assert actual["Data"]["DomainNameFields"] == {
186 "Len": 0,
187 "MaxLen": 0,
188 "BufferOffset": 0,
189 }
190 assert actual["Data"]["WorkstationFields"] == {
191 "Len": 0,
192 "MaxLen": 0,
193 "BufferOffset": 0,
194 }
195 assert actual["Data"]["Version"] == {
196 "Major": 10,
197 "Minor": 0,
198 "Build": 17763,
199 "Reserved": "000000",
200 "NTLMRevision": 15,
201 }
202 assert actual["Data"]["Payload"] == {
203 "DomainName": None,
204 "Workstation": None,
205 }
206
207
208 def test_ntlm_challenge(capsys):
209 entrypoint.main(["--token", base64.b64encode(get_data("ntlm_challenge")).decode()])
210 actual_out = capsys.readouterr()
211
212 assert actual_out.err == ""
213 actual = json.loads(actual_out.out)
214
215 assert actual["MessageType"] == "CHALLENGE_MESSAGE (2)"
216 assert actual["RawData"] is not None
217
218 assert actual["Data"]["TargetNameFields"] == {
219 "Len": 12,
220 "MaxLen": 12,
221 "BufferOffset": 56,
222 }
223 assert actual["Data"]["NegotiateFlags"]["raw"] == 3800662581
224 assert set(actual["Data"]["NegotiateFlags"]["flags"]) == {
225 "NTLMSSP_NEGOTIATE_56 (2147483648)",
226 "NTLMSSP_NEGOTIATE_KEY_EXCH (1073741824)",
227 "NTLMSSP_NEGOTIATE_128 (536870912)",
228 "NTLMSSP_NEGOTIATE_VERSION (33554432)",
229 "NTLMSSP_NEGOTIATE_TARGET_INFO (8388608)",
230 "NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY (524288)",
231 "NTLMSSP_TARGET_TYPE_DOMAIN (65536)",
232 "NTLMSSP_NEGOTIATE_ALWAYS_SIGN (32768)",
233 "NTLMSSP_NEGOTIATE_NTLM (512)",
234 "NTLMSSP_NEGOTIATE_SEAL (32)",
235 "NTLMSSP_NEGOTIATE_SIGN (16)",
236 "NTLMSSP_REQUEST_TARGET (4)",
237 "NTLMSSP_NEGOTIATE_UNICODE (1)",
238 }
239 assert actual["Data"]["ServerChallenge"] == "E4101014CF8A90BE"
240 assert actual["Data"]["Reserved"] == "0000000000000000"
241 assert actual["Data"]["TargetInfoFields"] == {
242 "Len": 138,
243 "MaxLen": 138,
244 "BufferOffset": 68,
245 }
246 assert actual["Data"]["Version"] == {
247 "Major": 10,
248 "Minor": 0,
249 "Build": 14393,
250 "Reserved": "000000",
251 "NTLMRevision": 15,
252 }
253 assert actual["Data"]["Payload"]["TargetName"] == "DOMAIN"
254 assert actual["Data"]["Payload"]["TargetInfo"] == [
255 {"AvId": "MSV_AV_NB_DOMAIN_NAME (2)", "Value": "DOMAIN"},
256 {"AvId": "MSV_AV_NB_COMPUTER_NAME (1)", "Value": "DC01"},
257 {"AvId": "MSV_AV_DNS_DOMAIN_NAME (4)", "Value": "domain.local"},
258 {"AvId": "MSV_AV_DNS_COMPUTER_NAME (3)", "Value": "DC01.domain.local"},
259 {"AvId": "MSV_AV_DNS_TREE_NAME (5)", "Value": "domain.local"},
260 {"AvId": "MSV_AV_TIMESTAMP (7)", "Value": "2020-04-30T02:46:22.4140792Z"},
261 {"AvId": "MSV_AV_EOL (0)", "Value": None},
262 ]
263
264
265 def test_ntlm_authenticate(capsys):
266 entrypoint.main(["--token", base64.b64encode(get_data("ntlm_authenticate")).decode()])
267 actual_out = capsys.readouterr()
268
269 assert actual_out.err == ""
270 actual = json.loads(actual_out.out)
271
272 assert actual["MessageType"] == "AUTHENTICATE_MESSAGE (3)"
273 assert actual["RawData"] is not None
274
275 assert actual["Data"]["LmChallengeResponseFields"] == {
276 "Len": 0,
277 "MaxLen": 0,
278 "BufferOffset": 72,
279 }
280 assert actual["Data"]["NtChallengeResponseFields"] == {
281 "Len": 252,
282 "MaxLen": 252,
283 "BufferOffset": 72,
284 }
285 assert actual["Data"]["DomainNameFields"] == {
286 "Len": 0,
287 "MaxLen": 0,
288 "BufferOffset": 0,
289 }
290 assert actual["Data"]["UserNameFields"] == {
291 "Len": 54,
292 "MaxLen": 54,
293 "BufferOffset": 324,
294 }
295 assert actual["Data"]["WorkstationFields"] == {
296 "Len": 26,
297 "MaxLen": 26,
298 "BufferOffset": 378,
299 }
300 assert actual["Data"]["EncryptedRandomSessionKeyFields"] == {
301 "Len": 16,
302 "MaxLen": 16,
303 "BufferOffset": 404,
304 }
305 assert actual["Data"]["NegotiateFlags"]["raw"] == 3800662581
306 assert set(actual["Data"]["NegotiateFlags"]["flags"]) == {
307 "NTLMSSP_NEGOTIATE_56 (2147483648)",
308 "NTLMSSP_NEGOTIATE_KEY_EXCH (1073741824)",
309 "NTLMSSP_NEGOTIATE_128 (536870912)",
310 "NTLMSSP_NEGOTIATE_VERSION (33554432)",
311 "NTLMSSP_NEGOTIATE_TARGET_INFO (8388608)",
312 "NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY (524288)",
313 "NTLMSSP_TARGET_TYPE_DOMAIN (65536)",
314 "NTLMSSP_NEGOTIATE_ALWAYS_SIGN (32768)",
315 "NTLMSSP_NEGOTIATE_NTLM (512)",
316 "NTLMSSP_NEGOTIATE_SEAL (32)",
317 "NTLMSSP_NEGOTIATE_SIGN (16)",
318 "NTLMSSP_REQUEST_TARGET (4)",
319 "NTLMSSP_NEGOTIATE_UNICODE (1)",
320 }
321 assert actual["Data"]["Version"] == {
322 "Major": 6,
323 "Minor": 2,
324 "Build": 0,
325 "Reserved": "000000",
326 "NTLMRevision": 15,
327 }
328 assert actual["Data"]["MIC"] is None
329 assert actual["Data"]["Payload"]["LmChallengeResponse"] is None
330 assert actual["Data"]["Payload"]["NtChallengeResponse"]["ResponseType"] == "NTLMv2"
331 assert actual["Data"]["Payload"]["NtChallengeResponse"]["NTProofStr"] == "C543CC0D1A0FBD9EC05E1AAB0771B124"
332 assert actual["Data"]["Payload"]["NtChallengeResponse"]["ClientChallenge"] == {
333 "RespType": 1,
334 "HiRespType": 1,
335 "Reserved1": 0,
336 "Reserved2": 0,
337 "TimeStamp": "2020-04-30T02:46:22.4140792Z",
338 "ChallengeFromClient": "DC5A7473AC5672FC",
339 "Reserved3": 0,
340 "AvPairs": [
341 {"AvId": "MSV_AV_NB_COMPUTER_NAME (1)", "Value": "DC01"},
342 {"AvId": "MSV_AV_NB_DOMAIN_NAME (2)", "Value": "DOMAIN"},
343 {"AvId": "MSV_AV_DNS_COMPUTER_NAME (3)", "Value": "DC01.domain.local"},
344 {"AvId": "MSV_AV_DNS_DOMAIN_NAME (4)", "Value": "domain.local"},
345 {"AvId": "MSV_AV_DNS_TREE_NAME (5)", "Value": "domain.local"},
346 {"AvId": "MSV_AV_FLAGS (6)", "Value": {"raw": 0, "flags": []}},
347 {"AvId": "MSV_AV_TIMESTAMP (7)", "Value": "2020-04-30T02:46:22.4140792Z"},
348 {"AvId": "MSV_AV_TARGET_NAME (9)", "Value": "dc01.domain.local"},
349 {"AvId": "MSV_AV_CHANNEL_BINDINGS (10)", "Value": "00000000000000000000000000000000"},
350 {"AvId": "MSV_AV_EOL (0)", "Value": None},
351 ],
352 "Reserved4": 0,
353 }
354 assert actual["Data"]["Payload"]["DomainName"] is None
355 assert actual["Data"]["Payload"]["UserName"] == "[email protected]"
356 assert actual["Data"]["Payload"]["Workstation"] == "JBOREAN-LINUX"
357 assert actual["Data"]["Payload"]["EncryptedRandomSessionKey"] == "3765D5AFD13EC3A6C97C0726CE9F30C9"
358 assert actual["Data"]["SessionKey"] == "Failed to derive"
359
360
361 def test_ntlm_authenticate_with_secret(capsys):
362 entrypoint.main(
363 [
364 "--token",
365 base64.b64encode(get_data("ntlm_authenticate")).decode(),
366 "--secret",
367 "VagrantPass1",
368 ]
369 )
370 actual_out = capsys.readouterr()
371
372 assert actual_out.err == ""
373 actual = json.loads(actual_out.out)
374 assert actual["Data"]["SessionKey"] == "4E10F9B8AA8C2A5DF0A2AD75A8ECF433"
375
376
377 def test_ntlm_authenticate_ntlmv1(capsys):
378 data = base64.b64encode(
379 b"\x4E\x54\x4C\x4D\x53\x53\x50\x00"
380 b"\x03\x00\x00\x00"
381 b"\x18\x00"
382 b"\x18\x00"
383 b"\x6C\x00\x00\x00"
384 b"\x18\x00"
385 b"\x18\x00"
386 b"\x84\x00\x00\x00"
387 b"\x0C\x00"
388 b"\x0C\x00"
389 b"\x48\x00\x00\x00"
390 b"\x08\x00"
391 b"\x08\x00"
392 b"\x54\x00\x00\x00"
393 b"\x10\x00"
394 b"\x10\x00"
395 b"\x5C\x00\x00\x00"
396 b"\x10\x00"
397 b"\x10\x00"
398 b"\x9C\x00\x00\x00"
399 b"\x35\x82\x80\xE2"
400 b"\x05\x01\x28\x0A\x00\x00\x00\x0F"
401 b"\x44\x00\x6F\x00\x6D\x00\x61\x00\x69\x00\x6E\x00"
402 b"\x55\x00\x73\x00\x65\x00\x72\x00"
403 b"\x43\x00\x4F\x00\x4D\x00\x50\x00\x55\x00\x54\x00\x45\x00\x52\x00"
404 b"\x98\xDE\xF7\xB8\x7F\x88\xAA\x5D\xAF\xE2\xDF\x77\x96\x88\xA1\x72"
405 b"\xDE\xF1\x1C\x7D\x5C\xCD\xEF\x13"
406 b"\x67\xC4\x30\x11\xF3\x02\x98\xA2\xAD\x35\xEC\xE6\x4F\x16\x33\x1C"
407 b"\x44\xBD\xBE\xD9\x27\x84\x1F\x94"
408 b"\x51\x88\x22\xB1\xB3\xF3\x50\xC8\x95\x86\x82\xEC\xBB\x3E\x3C\xB7"
409 ).decode()
410
411 entrypoint.main(["--token", data])
412 actual_out = capsys.readouterr()
413
414 assert actual_out.err == ""
415 actual = json.loads(actual_out.out)
416
417 assert actual["Data"]["LmChallengeResponseFields"] == {
418 "Len": 24,
419 "MaxLen": 24,
420 "BufferOffset": 108,
421 }
422 assert actual["Data"]["NtChallengeResponseFields"] == {
423 "Len": 24,
424 "MaxLen": 24,
425 "BufferOffset": 132,
426 }
427
428 assert actual["Data"]["Payload"]["LmChallengeResponse"]["ResponseType"] == "LMv1"
429 assert (
430 actual["Data"]["Payload"]["LmChallengeResponse"]["LMProofStr"]
431 == "98DEF7B87F88AA5DAFE2DF779688A172DEF11C7D5CCDEF13"
432 )
433 assert actual["Data"]["Payload"]["NtChallengeResponse"]["ResponseType"] == "NTLMv1"
434 assert (
435 actual["Data"]["Payload"]["NtChallengeResponse"]["NTProofStr"]
436 == "67C43011F30298A2AD35ECE64F16331C44BDBED927841F94"
437 )
438
439
440 def test_ntlm_authenticate_lmv2(capsys):
441 data = base64.b64encode(
442 b"\x4E\x54\x4C\x4D\x53\x53\x50\x00"
443 b"\x03\x00\x00\x00"
444 b"\x18\x00"
445 b"\x18\x00"
446 b"\x6C\x00\x00\x00"
447 b"\x54\x00"
448 b"\x54\x00"
449 b"\x84\x00\x00\x00"
450 b"\x0C\x00"
451 b"\x0C\x00"
452 b"\x48\x00\x00\x00"
453 b"\x08\x00"
454 b"\x08\x00"
455 b"\x54\x00\x00\x00"
456 b"\x10\x00"
457 b"\x10\x00"
458 b"\x5C\x00\x00\x00"
459 b"\x10\x00"
460 b"\x10\x00"
461 b"\xD8\x00\x00\x00"
462 b"\x35\x82\x88\xE2"
463 b"\x05\x01\x28\x0A\x00\x00\x00\x0F"
464 b"\x44\x00\x6F\x00\x6D\x00\x61\x00\x69\x00\x6E\x00"
465 b"\x55\x00\x73\x00\x65\x00\x72\x00"
466 b"\x43\x00\x4F\x00\x4D\x00\x50\x00\x55\x00\x54\x00\x45\x00\x52\x00"
467 b"\x86\xC3\x50\x97\xAC\x9C\xEC\x10\x25\x54\x76\x4A\x57\xCC\xCC\x19"
468 b"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
469 b"\x68\xCD\x0A\xB8\x51\xE5\x1C\x96\xAA\xBC\x92\x7B\xEB\xEF\x6A\x1C"
470 b"\x01"
471 b"\x01"
472 b"\x00\x00"
473 b"\x00\x00\x00\x00"
474 b"\x00\x00\x00\x00\x00\x00\x00\x00"
475 b"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
476 b"\x00\x00\x00\x00"
477 b"\x02\x00\x0C\x00\x44\x00\x6F\x00\x6D\x00\x61\x00\x69\x00\x6E\x00"
478 b"\x01\x00\x0C\x00\x53\x00\x65\x00\x72\x00\x76\x00\x65\x00\x72\x00"
479 b"\x00\x00\x00\x00"
480 b"\x00\x00\x00\x00"
481 b"\xC5\xDA\xD2\x54\x4F\xC9\x79\x90\x94\xCE\x1C\xE9\x0B\xC9\xD0\x3E"
482 ).decode()
483
484 entrypoint.main(["--token", data])
485 actual_out = capsys.readouterr()
486
487 assert actual_out.err == ""
488 actual = json.loads(actual_out.out)
489
490 assert actual["Data"]["LmChallengeResponseFields"] == {
491 "Len": 24,
492 "MaxLen": 24,
493 "BufferOffset": 108,
494 }
495 assert actual["Data"]["NtChallengeResponseFields"] == {
496 "Len": 84,
497 "MaxLen": 84,
498 "BufferOffset": 132,
499 }
500
501 assert actual["Data"]["Payload"]["LmChallengeResponse"]["ResponseType"] == "LMv2"
502 assert actual["Data"]["Payload"]["LmChallengeResponse"]["LMProofStr"] == "86C35097AC9CEC102554764A57CCCC19"
503 assert actual["Data"]["Payload"]["LmChallengeResponse"]["ChallengeFromClient"] == "AAAAAAAAAAAAAAAA"
504 assert actual["Data"]["Payload"]["NtChallengeResponse"]["ResponseType"] == "NTLMv2"
505 assert actual["Data"]["Payload"]["NtChallengeResponse"]["NTProofStr"] == "68CD0AB851E51C96AABC927BEBEF6A1C"
506 assert actual["Data"]["Payload"]["NtChallengeResponse"]["ClientChallenge"] == {
507 "RespType": 1,
508 "HiRespType": 1,
509 "Reserved1": 0,
510 "Reserved2": 0,
511 "TimeStamp": "1601-01-01T00:00:00Z",
512 "ChallengeFromClient": "AAAAAAAAAAAAAAAA",
513 "Reserved3": 0,
514 "AvPairs": [
515 {"AvId": "MSV_AV_NB_DOMAIN_NAME (2)", "Value": "Domain"},
516 {"AvId": "MSV_AV_NB_COMPUTER_NAME (1)", "Value": "Server"},
517 {"AvId": "MSV_AV_EOL (0)", "Value": None},
518 ],
519 "Reserved4": 0,
520 }
521
522
523 def test_nltm_session_key_no_sign_seal(capsys):
524 entrypoint.main(
525 [
526 "--token",
527 base64.b64encode(get_data("ntlm_authenticate_no_sign_seal")).decode(),
528 "--secret",
529 "vagrant",
530 ]
531 )
532 actual_out = capsys.readouterr()
533
534 assert actual_out.err == ""
535 actual = json.loads(actual_out.out)
536 assert actual["Data"]["SessionKey"] == "92D93576421343CEB1937AAD4CD78116"
537
538
539 def test_ntlm_without_version(capsys):
540 msg = Negotiate()
541 entrypoint.main(
542 [
543 "--token",
544 base64.b64encode(msg.pack()).decode(),
545 ]
546 )
547 actual_out = capsys.readouterr()
548
549 assert actual_out.err == ""
550 actual = json.loads(actual_out.out)
551
552 assert actual["Data"]["Version"] is None
553
554
555 def test_ntlm_no_target_info(capsys):
556 msg = Challenge()
557 entrypoint.main(
558 [
559 "--token",
560 base64.b64encode(msg.pack()).decode(),
561 ]
562 )
563 actual_out = capsys.readouterr()
564
565 assert actual_out.err == ""
566 actual = json.loads(actual_out.out)
567
568 assert actual["Data"]["Payload"]["TargetInfo"] is None
569
570
571 def test_ntlm_av_single_host(capsys):
572 ti = TargetInfo(
573 {
574 AvId.single_host: SingleHost(size=4, z4=0, custom_data=b"\x01" * 8, machine_id=b"\x02" * 32),
575 }
576 )
577 msg = Challenge(target_info=ti)
578 entrypoint.main(
579 [
580 "--token",
581 base64.b64encode(msg.pack()).decode(),
582 ]
583 )
584 actual_out = capsys.readouterr()
585
586 assert actual_out.err == ""
587 actual = json.loads(actual_out.out)
588
589 assert len(actual["Data"]["Payload"]["TargetInfo"]) == 2
590 assert actual["Data"]["Payload"]["TargetInfo"][0]["AvId"] == "MSV_AV_SINGLE_HOST (8)"
591 assert actual["Data"]["Payload"]["TargetInfo"][0]["Value"] == {
592 "Size": 4,
593 "Z4": 0,
594 "CustomData": "0101010101010101",
595 "MachineId": "0202020202020202020202020202020202020202020202020202020202020202",
596 }
597 assert actual["Data"]["Payload"]["TargetInfo"][1] == {"AvId": "MSV_AV_EOL (0)", "Value": None}
598
599
600 def test_krb_as_rep(capsys):
601 entrypoint.main(
602 [
603 "--token",
604 base64.b64encode(get_data("krb_as_rep")).decode(),
605 ]
606 )
607 actual_out = capsys.readouterr()
608
609 assert actual_out.err == ""
610 actual = json.loads(actual_out.out)
611
612 assert actual["MessageType"] == "AS-REP (11)"
613 assert actual["RawData"] is not None
614
615 assert actual["Data"]["pvno"] == 5
616 assert actual["Data"]["msg-type"] == "AS-REP (11)"
617 assert actual["Data"]["padata"] == [
618 {
619 "padata-type": "PA-ETYPE-INFO2 (19)",
620 "padata-value": [
621 {
622 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
623 "salt": "444F4D41494E2E4C4F43414C76616772616E742D646F6D61696E",
624 "s2kparams": None,
625 },
626 ],
627 },
628 ]
629 assert actual["Data"]["crealm"] == "DOMAIN.LOCAL"
630 assert actual["Data"]["cname"] == {
631 "name-type": "NT-PRINCIPAL (1)",
632 "name-string": ["vagrant-domain"],
633 }
634 assert actual["Data"]["ticket"] == {
635 "tkt-vno": 5,
636 "realm": "DOMAIN.LOCAL",
637 "sname": {
638 "name-type": "NT-SRV-INST (2)",
639 "name-string": ["krbtgt", "DOMAIN.LOCAL"],
640 },
641 "enc-part": {
642 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
643 "kvno": 2,
644 "cipher": actual["Data"]["ticket"]["enc-part"]["cipher"],
645 },
646 }
647 assert actual["Data"]["ticket"]["enc-part"]["cipher"] is not None
648 assert actual["Data"]["enc-part"] == {
649 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
650 "kvno": 11,
651 "cipher": actual["Data"]["enc-part"]["cipher"],
652 }
653 assert actual["Data"]["enc-part"]["cipher"] is not None
654
655
656 def test_krb_as_req(capsys):
657 entrypoint.main(
658 [
659 "--token",
660 base64.b64encode(get_data("krb_as_req")).decode(),
661 ]
662 )
663 actual_out = capsys.readouterr()
664
665 assert actual_out.err == ""
666 actual = json.loads(actual_out.out)
667
668 assert actual["MessageType"] == "AS-REQ (10)"
669 assert actual["RawData"] is not None
670
671 assert actual["Data"]["pvno"] == 5
672 assert actual["Data"]["msg-type"] == "AS-REQ (10)"
673 assert actual["Data"]["padata"] == [
674 {
675 "padata-type": "PA-ENC-TIMESTAMP (2)",
676 "padata-value": {
677 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
678 "kvno": None,
679 "cipher": actual["Data"]["padata"][0]["padata-value"]["cipher"],
680 },
681 },
682 {
683 "padata-type": "PA-REQ-ENC-PA-REP (149)",
684 "padata-value": "",
685 },
686 ]
687 assert actual["Data"]["padata"][0]["padata-value"]["cipher"] is not None
688 assert actual["Data"]["req-body"] == {
689 "kdc-options": {
690 "raw": 1073741824,
691 "flags": ["forwardable (1073741824)"],
692 },
693 "cname": {
694 "name-type": "NT-PRINCIPAL (1)",
695 "name-string": ["vagrant-domain"],
696 },
697 "realm": "DOMAIN.LOCAL",
698 "sname": {
699 "name-type": "NT-SRV-INST (2)",
700 "name-string": ["krbtgt", "DOMAIN.LOCAL"],
701 },
702 "from": None,
703 "till": "2020-06-14T07:04:20+00:00",
704 "rtime": None,
705 "nonce": 734266074,
706 "etype": [
707 "AES256_CTS_HMAC_SHA1_96 (18)",
708 "AES128_CTS_HMAC_SHA1_96 (17)",
709 "DES3_CBC_SHA1 (16)",
710 "RC4_HMAC (23)",
711 ],
712 "addresses": None,
713 "enc-authorization-data": None,
714 "additional-tickets": None,
715 }
716
717
718 def test_krb_error(capsys):
719 entrypoint.main(
720 [
721 "--token",
722 base64.b64encode(get_data("krb_error")).decode(),
723 ]
724 )
725 actual_out = capsys.readouterr()
726
727 assert actual_out.err == ""
728 actual = json.loads(actual_out.out)
729
730 assert actual["MessageType"] == "KRB-ERROR (30)"
731 assert actual["RawData"] is not None
732
733 assert actual["Data"]["pvno"] == 5
734 assert actual["Data"]["msg-type"] == "KRB-ERROR (30)"
735 assert actual["Data"]["ctime"] is None
736 assert actual["Data"]["cusec"] is None
737 assert actual["Data"]["stime"] == "2020-06-13T21:04:23+00:00"
738 assert actual["Data"]["susec"] == 748591
739 assert actual["Data"]["error-code"] == "KDC_ERR_PREAUTH_REQUIRED (25)"
740 assert actual["Data"]["crealm"] is None
741 assert actual["Data"]["cname"] is None
742 assert actual["Data"]["realm"] == "DOMAIN.LOCAL"
743 assert actual["Data"]["sname"] == {"name-type": "NT-SRV-INST (2)", "name-string": ["krbtgt", "DOMAIN.LOCAL"]}
744 assert actual["Data"]["e-text"] is None
745 assert actual["Data"]["e-data"] is not None
746
747
748 def test_krb_tgs_rep(capsys):
749 entrypoint.main(
750 [
751 "--token",
752 base64.b64encode(get_data("krb_tgs_rep")).decode(),
753 ]
754 )
755 actual_out = capsys.readouterr()
756
757 assert actual_out.err == ""
758 actual = json.loads(actual_out.out)
759
760 assert actual["MessageType"] == "TGS-REP (13)"
761 assert actual["RawData"] is not None
762
763 assert actual["Data"]["pvno"] == 5
764 assert actual["Data"]["msg-type"] == "TGS-REP (13)"
765 assert actual["Data"]["padata"] is None
766 assert actual["Data"]["crealm"] == "DOMAIN.LOCAL"
767 assert actual["Data"]["cname"] == {
768 "name-type": "NT-PRINCIPAL (1)",
769 "name-string": ["vagrant-domain"],
770 }
771 assert actual["Data"]["ticket"] == {
772 "tkt-vno": 5,
773 "realm": "DOMAIN.LOCAL",
774 "sname": {
775 "name-type": "NT-SRV-HST (3)",
776 "name-string": ["HTTP", "server2019.domain.local"],
777 },
778 "enc-part": {
779 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
780 "kvno": 6,
781 "cipher": actual["Data"]["ticket"]["enc-part"]["cipher"],
782 },
783 }
784 assert actual["Data"]["ticket"]["enc-part"]["cipher"] is not None
785 assert actual["Data"]["enc-part"] == {
786 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
787 "kvno": None,
788 "cipher": actual["Data"]["enc-part"]["cipher"],
789 }
790 assert actual["Data"]["enc-part"]["cipher"] is not None
791
792
793 def test_krb_tgs_req(capsys):
794 entrypoint.main(
795 [
796 "--token",
797 base64.b64encode(get_data("krb_tgs_req")).decode(),
798 ]
799 )
800 actual_out = capsys.readouterr()
801
802 assert actual_out.err == ""
803 actual = json.loads(actual_out.out)
804
805 assert actual["MessageType"] == "TGS-REQ (12)"
806 assert actual["RawData"] is not None
807
808 assert actual["Data"]["pvno"] == 5
809 assert actual["Data"]["msg-type"] == "TGS-REQ (12)"
810 assert len(actual["Data"]["padata"]) == 1
811 assert actual["Data"]["padata"][0]["padata-type"] == "PA-TGS-REQ (1)"
812 assert actual["Data"]["padata"][0]["padata-value"]["pvno"] == 5
813 assert actual["Data"]["padata"][0]["padata-value"]["msg-type"] == "AP-REQ (14)"
814 assert actual["Data"]["padata"][0]["padata-value"]["ap-options"] == {
815 "raw": 0,
816 "flags": [],
817 }
818 assert actual["Data"]["padata"][0]["padata-value"]["ticket"] == {
819 "tkt-vno": 5,
820 "realm": "DOMAIN.LOCAL",
821 "sname": {"name-type": "NT-SRV-INST (2)", "name-string": ["krbtgt", "DOMAIN.LOCAL"]},
822 "enc-part": {
823 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
824 "kvno": 2,
825 "cipher": actual["Data"]["padata"][0]["padata-value"]["ticket"]["enc-part"]["cipher"],
826 },
827 }
828 assert actual["Data"]["padata"][0]["padata-value"]["ticket"]["enc-part"]["cipher"] is not None
829 assert actual["Data"]["padata"][0]["padata-value"]["authenticator"] == {
830 "etype": "AES256_CTS_HMAC_SHA1_96 (18)",
831 "kvno": None,
832 "cipher": actual["Data"]["padata"][0]["padata-value"]["authenticator"]["cipher"],
833 }
834 assert actual["Data"]["padata"][0]["padata-value"]["authenticator"]["cipher"] is not None
835
836 assert actual["Data"]["req-body"]["kdc-options"] == {
837 "raw": 1073807360,
838 "flags": ["forwardable (1073741824)", "canonicalize (65536)"],
839 }
840 assert actual["Data"]["req-body"]["cname"] is None
841 assert actual["Data"]["req-body"]["realm"] == "DOMAIN.LOCAL"
842 assert actual["Data"]["req-body"]["sname"] == {
843 "name-type": "NT-SRV-HST (3)",
844 "name-string": ["HTTP", "server2019.domain.local"],
845 }
846 assert actual["Data"]["req-body"]["from"] is None
847 assert actual["Data"]["req-body"]["till"] == "1970-01-01T00:00:00+00:00"
848 assert actual["Data"]["req-body"]["rtime"] is None
849 assert actual["Data"]["req-body"]["nonce"] == 333512069
850 assert actual["Data"]["req-body"]["etype"] == [
851 "AES256_CTS_HMAC_SHA1_96 (18)",
852 "AES128_CTS_HMAC_SHA1_96 (17)",
853 "DES3_CBC_SHA1 (16)",
854 "RC4_HMAC (23)",
855 ]
856 assert actual["Data"]["req-body"]["addresses"] is None
857 assert actual["Data"]["req-body"]["enc-authorization-data"] is None
858 assert actual["Data"]["req-body"]["additional-tickets"] is None
859
860
861 def test_krb_ap_req_in_initial_context_token(capsys):
862 entrypoint.main(
863 [
864 "--token",
865 base64.b64encode(get_data("initial_context_token_krb_ap_rep")).decode(),
866 ]
867 )
868 actual_out = capsys.readouterr()
869
870 assert actual_out.err == ""
871 actual = json.loads(actual_out.out)
872
873 assert actual["MessageType"] == "SPNEGO InitialContextToken"
874 assert actual["RawData"] is not None
875
876 assert actual["Data"]["thisMech"] == "Kerberos (1.2.840.113554.1.2.2)"
877 assert actual["Data"]["innerContextToken"]["MessageType"] == "AP-REP (15)"
878 assert actual["Data"]["innerContextToken"]["RawData"] is not None
879 assert actual["Data"]["innerContextToken"]["Data"]["pvno"] == 5
880 assert actual["Data"]["innerContextToken"]["Data"]["msg-type"] == "AP-REP (15)"
881
882
883 def test_neg_token_init(capsys):
884 entrypoint.main(
885 [
886 "--token",
887 base64.b64encode(get_data("initial_context_token_neg_token_init")).decode(),
888 ]
889 )
890 actual_out = capsys.readouterr()
891
892 assert actual_out.err == ""
893 actual = json.loads(actual_out.out)
894
895 assert actual["MessageType"] == "SPNEGO InitialContextToken"
896 assert actual["RawData"] is not None
897
898 assert actual["Data"]["thisMech"] == "SPNEGO (1.3.6.1.5.5.2)"
899 assert actual["Data"]["innerContextToken"]["MessageType"] == "SPNEGO NegTokenInit"
900 assert actual["Data"]["innerContextToken"]["RawData"] is not None
901 assert actual["Data"]["innerContextToken"]["Data"]["mechTypes"] == [
902 "Kerberos (1.2.840.113554.1.2.2)",
903 "NTLM (1.3.6.1.4.1.311.2.2.10)",
904 ]
905 assert actual["Data"]["innerContextToken"]["Data"]["reqFlags"] is None
906 assert actual["Data"]["innerContextToken"]["Data"]["mechListMIC"] is None
907
908 mech_token = actual["Data"]["innerContextToken"]["Data"]["mechToken"]
909 assert mech_token is not None
910
911 assert mech_token["MessageType"] == "SPNEGO InitialContextToken"
912 assert mech_token["RawData"] is not None
913
914 assert mech_token["Data"]["thisMech"] == "Kerberos (1.2.840.113554.1.2.2)"
915 assert mech_token["Data"]["innerContextToken"]["MessageType"] == "AP-REQ (14)"
916
917
918 def test_neg_token_init2(capsys):
919 entrypoint.main(
920 [
921 "--token",
922 base64.b64encode(get_data("initial_context_token_neg_token_init2")).decode(),
923 ]
924 )
925 actual_out = capsys.readouterr()
926
927 assert actual_out.err == ""
928 actual = json.loads(actual_out.out)
929
930 assert actual["MessageType"] == "SPNEGO InitialContextToken"
931 assert actual["RawData"] is not None
932
933 assert actual["Data"]["thisMech"] == "SPNEGO (1.3.6.1.5.5.2)"
934 assert actual["Data"]["innerContextToken"]["MessageType"] == "SPNEGO NegTokenInit2"
935 assert actual["Data"]["innerContextToken"]["RawData"] is not None
936 assert actual["Data"]["innerContextToken"]["Data"]["mechTypes"] == [
937 "NEGOEX (1.3.6.1.4.1.311.2.2.30)",
938 "MS Kerberos (1.2.840.48018.1.2.2)",
939 "Kerberos (1.2.840.113554.1.2.2)",
940 "Kerberos User to User (1.2.840.113554.1.2.2.3)",
941 "NTLM (1.3.6.1.4.1.311.2.2.10)",
942 ]
943 assert actual["Data"]["innerContextToken"]["Data"]["reqFlags"] is None
944 assert actual["Data"]["innerContextToken"]["Data"]["mechToken"] is None
945 assert actual["Data"]["innerContextToken"]["Data"]["mechListMIC"] is None
946 assert actual["Data"]["innerContextToken"]["Data"]["negHints"] == {
947 "hintName": "not_defined_in_RFC4178@please_ignore",
948 "hintAddress": None,
949 }
950
951
952 def test_neg_token_resp(capsys):
953 entrypoint.main(
954 [
955 "--token",
956 base64.b64encode(get_data("neg_token_resp")).decode(),
957 ]
958 )
959 actual_out = capsys.readouterr()
960
961 assert actual_out.err == ""
962 actual = json.loads(actual_out.out)
963
964 assert actual["MessageType"] == "SPNEGO NegTokenResp"
965 assert actual["RawData"] is not None
966 assert actual["Data"]["negState"] == "accept-complete (0)"
967 assert actual["Data"]["supportedMech"] == "Kerberos (1.2.840.113554.1.2.2)"
968 assert actual["Data"]["responseToken"]["MessageType"] == "SPNEGO InitialContextToken"
969 assert actual["Data"]["responseToken"]["Data"]["thisMech"] == "Kerberos (1.2.840.113554.1.2.2)"
970 assert actual["Data"]["responseToken"]["Data"]["innerContextToken"]["MessageType"] == "AP-REP (15)"
971 assert actual["Data"]["mechListMIC"] is None
972
973
974 def test_tls13_client_hello(capsys):
975 entrypoint.main(["--token", base64.b64encode(get_data("tls1.3_client_hello")).decode()])
976 actual_out = capsys.readouterr()
977
978 assert actual_out.err == ""
979 actual = json.loads(actual_out.out)
980
981 assert isinstance(actual, list)
982 assert len(actual) == 1
983
984 assert isinstance(actual[0], dict)
985 assert actual[0]["ContentType"] == "handshake (22)"
986 assert actual[0]["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
987 assert actual[0]["RawData"] is not None
988
989 actual = actual[0]["Data"]
990 assert isinstance(actual, list)
991 assert len(actual) == 1
992 assert isinstance(actual[0], dict)
993
994 assert actual[0]["HandshakeType"] == "client_hello (1)"
995 assert actual[0]["RawData"] is not None
996 actual = actual[0]["Data"]
997
998 assert actual["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
999 assert actual["Random"] == "6A8DEBD01B3A24DDEE8428FDB204F819C5CC5FC9B780B037B723446D3F4CE66B"
1000 assert actual["SessionID"] == "2AE52188EF97D27FD6EA670EC3DB3064DBE431B12E262A0B87F45EAA13E29F45"
1001 assert len(actual["CipherSuites"]) == 36
1002 for cs in actual["CipherSuites"]:
1003 assert isinstance(cs, str)
1004 assert len(actual["CompressionMethods"]) == 1
1005 assert actual["CompressionMethods"][0] == "none (0)"
1006 assert len(actual["Extensions"]) == 10
1007
1008 assert actual["Extensions"][0]["ExtensionType"] == "server_name (0)"
1009 assert actual["Extensions"][0]["Data"] == [{"Type": "server_name (0)", "Name": "server2022.domain.test"}]
1010 assert actual["Extensions"][0]["RawData"] is not None
1011
1012 assert actual["Extensions"][1]["ExtensionType"] == "ec_point_formats (11)"
1013 assert actual["Extensions"][1]["Data"] == [
1014 "uncompressed (0)",
1015 "ansiX962_compressed_prime (1)",
1016 "ansiX962_compressed_char2 (2)",
1017 ]
1018 assert actual["Extensions"][1]["RawData"] is not None
1019
1020 assert actual["Extensions"][2]["ExtensionType"] == "supported_groups (10)"
1021 assert actual["Extensions"][2]["Data"] == [
1022 "x25519 (29)",
1023 "secp256r1 (23)",
1024 "x448 (30)",
1025 "secp521r1 (25)",
1026 "secp384r1 (24)",
1027 "ffdhe2048 (256)",
1028 "ffdhe3072 (257)",
1029 "ffdhe4096 (258)",
1030 "ffdhe6144 (259)",
1031 "ffdhe8192 (260)",
1032 ]
1033 assert actual["Extensions"][2]["RawData"] is not None
1034
1035 assert actual["Extensions"][3] == {"ExtensionType": "session_ticket (35)"}
1036
1037 assert actual["Extensions"][4] == {"ExtensionType": "encrypt_then_mac (22)"}
1038
1039 assert actual["Extensions"][5] == {"ExtensionType": "extended_master_secret (23)"}
1040
1041 assert actual["Extensions"][6]["ExtensionType"] == "signature_algorithms (13)"
1042 assert actual["Extensions"][6]["Data"] == [
1043 "ecdsa_secp256r1_sha256 (1027)",
1044 "ecdsa_secp384r1_sha384 (1283)",
1045 "ecdsa_secp521r1_sha512 (1539)",
1046 "ed25519 (2055)",
1047 "ed448 (2056)",
1048 "rsa_pss_pss_sha256 (2057)",
1049 "rsa_pss_pss_sha384 (2058)",
1050 "rsa_pss_pss_sha512 (2059)",
1051 "rsa_pss_rsae_sha256 (2052)",
1052 "rsa_pss_rsae_sha384 (2053)",
1053 "rsa_pss_rsae_sha512 (2054)",
1054 "rsa_pkcs1_sha256 (1025)",
1055 "rsa_pkcs1_sha384 (1281)",
1056 "rsa_pkcs1_sha512 (1537)",
1057 "sha224_ecdsa (771)",
1058 "sha224_rsa (769)",
1059 ]
1060 assert actual["Extensions"][6]["RawData"] is not None
1061
1062 assert actual["Extensions"][7]["ExtensionType"] == "supported_versions (43)"
1063 assert actual["Extensions"][7]["Data"] == [
1064 "TLS 1.3 (0x0304) (772)",
1065 "TLS 1.2 (0x0303) (771)",
1066 ]
1067 assert actual["Extensions"][7]["RawData"] is not None
1068
1069 assert actual["Extensions"][8]["ExtensionType"] == "psk_key_exchange_modes (45)"
1070 assert actual["Extensions"][8]["Data"] == [
1071 "psk_dhe_ke (1)",
1072 ]
1073 assert actual["Extensions"][8]["RawData"] is not None
1074
1075 assert actual["Extensions"][9]["ExtensionType"] == "key_share (51)"
1076 assert actual["Extensions"][9]["Data"] == [
1077 {
1078 "Group": "x25519 (29)",
1079 "Key": "C016598ACACC7390AC94D0479A20B490D8FDDA0D7CFBA4F86A8996098B96293F",
1080 },
1081 ]
1082 assert actual["Extensions"][9]["RawData"] is not None
1083
1084
1085 def test_tls12_client_hello(capsys):
1086 entrypoint.main(["--token", base64.b64encode(get_data("tls1.2_client_hello")).decode()])
1087 actual_out = capsys.readouterr()
1088
1089 assert actual_out.err == ""
1090 actual = json.loads(actual_out.out)
1091
1092 assert isinstance(actual, list)
1093 assert len(actual) == 1
1094
1095 assert isinstance(actual[0], dict)
1096 assert actual[0]["ContentType"] == "handshake (22)"
1097 assert actual[0]["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1098 assert actual[0]["RawData"] is not None
1099
1100 actual = actual[0]["Data"]
1101 assert isinstance(actual, list)
1102 assert len(actual) == 1
1103 assert isinstance(actual[0], dict)
1104
1105 assert actual[0]["HandshakeType"] == "client_hello (1)"
1106 assert actual[0]["RawData"] is not None
1107 actual = actual[0]["Data"]
1108
1109 assert actual["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1110 assert actual["Random"] == "003E759A1FC0B769CEF34EE66CA42CE37AD626D2B7D27CACB590358D642EE878"
1111 assert actual["SessionID"] == ""
1112 assert len(actual["CipherSuites"]) == 32
1113 for cs in actual["CipherSuites"]:
1114 assert isinstance(cs, str)
1115 assert len(actual["CompressionMethods"]) == 1
1116 assert actual["CompressionMethods"][0] == "none (0)"
1117 assert len(actual["Extensions"]) == 7
1118
1119 assert actual["Extensions"][0]["ExtensionType"] == "server_name (0)"
1120 assert actual["Extensions"][0]["Data"] == [{"Type": "server_name (0)", "Name": "server2022.domain.test"}]
1121 assert actual["Extensions"][0]["RawData"] is not None
1122
1123 assert actual["Extensions"][1]["ExtensionType"] == "ec_point_formats (11)"
1124 assert actual["Extensions"][1]["Data"] == [
1125 "uncompressed (0)",
1126 "ansiX962_compressed_prime (1)",
1127 "ansiX962_compressed_char2 (2)",
1128 ]
1129 assert actual["Extensions"][1]["RawData"] is not None
1130
1131 assert actual["Extensions"][2]["ExtensionType"] == "supported_groups (10)"
1132 assert actual["Extensions"][2]["Data"] == [
1133 "x25519 (29)",
1134 "secp256r1 (23)",
1135 "x448 (30)",
1136 "secp521r1 (25)",
1137 "secp384r1 (24)",
1138 ]
1139 assert actual["Extensions"][2]["RawData"] is not None
1140
1141 assert actual["Extensions"][3] == {"ExtensionType": "session_ticket (35)"}
1142
1143 assert actual["Extensions"][4] == {"ExtensionType": "encrypt_then_mac (22)"}
1144
1145 assert actual["Extensions"][5] == {"ExtensionType": "extended_master_secret (23)"}
1146
1147 assert actual["Extensions"][6]["ExtensionType"] == "signature_algorithms (13)"
1148 assert actual["Extensions"][6]["Data"] == [
1149 "ecdsa_secp256r1_sha256 (1027)",
1150 "ecdsa_secp384r1_sha384 (1283)",
1151 "ecdsa_secp521r1_sha512 (1539)",
1152 "ed25519 (2055)",
1153 "ed448 (2056)",
1154 "rsa_pss_pss_sha256 (2057)",
1155 "rsa_pss_pss_sha384 (2058)",
1156 "rsa_pss_pss_sha512 (2059)",
1157 "rsa_pss_rsae_sha256 (2052)",
1158 "rsa_pss_rsae_sha384 (2053)",
1159 "rsa_pss_rsae_sha512 (2054)",
1160 "rsa_pkcs1_sha256 (1025)",
1161 "rsa_pkcs1_sha384 (1281)",
1162 "rsa_pkcs1_sha512 (1537)",
1163 "sha224_ecdsa (771)",
1164 "sha224_rsa (769)",
1165 ]
1166 assert actual["Extensions"][6]["RawData"] is not None
1167
1168
1169 def test_tls11_client_hello(capsys):
1170 entrypoint.main(["--token", base64.b64encode(get_data("tls1.1_client_hello")).decode()])
1171 actual_out = capsys.readouterr()
1172
1173 assert actual_out.err == ""
1174 actual = json.loads(actual_out.out)
1175
1176 assert isinstance(actual, list)
1177 assert len(actual) == 1
1178
1179 assert isinstance(actual[0], dict)
1180 assert actual[0]["ContentType"] == "handshake (22)"
1181 assert actual[0]["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1182 assert actual[0]["RawData"] is not None
1183
1184 actual = actual[0]["Data"]
1185 assert isinstance(actual, list)
1186 assert len(actual) == 1
1187 assert isinstance(actual[0], dict)
1188
1189 assert actual[0]["HandshakeType"] == "client_hello (1)"
1190 assert actual[0]["RawData"] is not None
1191 actual = actual[0]["Data"]
1192
1193 assert actual["ProtocolVersion"] == "TLS 1.1 (0x0302) (770)"
1194 assert actual["Random"] == "2DBA71B73F9355CA456C2BE070BAEF289EC194678A18BA6467DA96D1211C45CC"
1195 assert actual["SessionID"] == ""
1196 assert len(actual["CipherSuites"]) == 9
1197 for cs in actual["CipherSuites"]:
1198 assert isinstance(cs, str)
1199 assert len(actual["CompressionMethods"]) == 1
1200 assert actual["CompressionMethods"][0] == "none (0)"
1201 assert len(actual["Extensions"]) == 6
1202
1203 assert actual["Extensions"][0]["ExtensionType"] == "server_name (0)"
1204 assert actual["Extensions"][0]["Data"] == [{"Type": "server_name (0)", "Name": "server2022.domain.test"}]
1205 assert actual["Extensions"][0]["RawData"] is not None
1206
1207 assert actual["Extensions"][1]["ExtensionType"] == "ec_point_formats (11)"
1208 assert actual["Extensions"][1]["Data"] == [
1209 "uncompressed (0)",
1210 "ansiX962_compressed_prime (1)",
1211 "ansiX962_compressed_char2 (2)",
1212 ]
1213 assert actual["Extensions"][1]["RawData"] is not None
1214
1215 assert actual["Extensions"][2]["ExtensionType"] == "supported_groups (10)"
1216 assert actual["Extensions"][2]["Data"] == [
1217 "x25519 (29)",
1218 "secp256r1 (23)",
1219 "x448 (30)",
1220 "secp521r1 (25)",
1221 "secp384r1 (24)",
1222 ]
1223 assert actual["Extensions"][2]["RawData"] is not None
1224
1225 assert actual["Extensions"][3] == {"ExtensionType": "session_ticket (35)"}
1226
1227 assert actual["Extensions"][4] == {"ExtensionType": "encrypt_then_mac (22)"}
1228
1229 assert actual["Extensions"][5] == {"ExtensionType": "extended_master_secret (23)"}
1230
1231
1232 def test_tls10_client_hello(capsys):
1233 entrypoint.main(["--token", base64.b64encode(get_data("tls1.0_client_hello")).decode()])
1234 actual_out = capsys.readouterr()
1235
1236 assert actual_out.err == ""
1237 actual = json.loads(actual_out.out)
1238
1239 assert isinstance(actual, list)
1240 assert len(actual) == 1
1241
1242 assert isinstance(actual[0], dict)
1243 assert actual[0]["ContentType"] == "handshake (22)"
1244 assert actual[0]["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1245 assert actual[0]["RawData"] is not None
1246
1247 actual = actual[0]["Data"]
1248 assert isinstance(actual, list)
1249 assert len(actual) == 1
1250 assert isinstance(actual[0], dict)
1251
1252 assert actual[0]["HandshakeType"] == "client_hello (1)"
1253 assert actual[0]["RawData"] is not None
1254 actual = actual[0]["Data"]
1255
1256 assert actual["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1257 assert actual["Random"] == "009B6CD8070904706A6CD7AD711D04E942FF64500853D0CCB7709285ED0D31F5"
1258 assert actual["SessionID"] == ""
1259 assert len(actual["CipherSuites"]) == 9
1260 for cs in actual["CipherSuites"]:
1261 assert isinstance(cs, str)
1262 assert len(actual["CompressionMethods"]) == 1
1263 assert actual["CompressionMethods"][0] == "none (0)"
1264 assert len(actual["Extensions"]) == 6
1265
1266 assert actual["Extensions"][0]["ExtensionType"] == "server_name (0)"
1267 assert actual["Extensions"][0]["Data"] == [{"Type": "server_name (0)", "Name": "server2022.domain.test"}]
1268 assert actual["Extensions"][0]["RawData"] is not None
1269
1270 assert actual["Extensions"][1]["ExtensionType"] == "ec_point_formats (11)"
1271 assert actual["Extensions"][1]["Data"] == [
1272 "uncompressed (0)",
1273 "ansiX962_compressed_prime (1)",
1274 "ansiX962_compressed_char2 (2)",
1275 ]
1276 assert actual["Extensions"][1]["RawData"] is not None
1277
1278 assert actual["Extensions"][2]["ExtensionType"] == "supported_groups (10)"
1279 assert actual["Extensions"][2]["Data"] == [
1280 "x25519 (29)",
1281 "secp256r1 (23)",
1282 "x448 (30)",
1283 "secp521r1 (25)",
1284 "secp384r1 (24)",
1285 ]
1286 assert actual["Extensions"][2]["RawData"] is not None
1287
1288 assert actual["Extensions"][3] == {"ExtensionType": "session_ticket (35)"}
1289
1290 assert actual["Extensions"][4] == {"ExtensionType": "encrypt_then_mac (22)"}
1291
1292 assert actual["Extensions"][5] == {"ExtensionType": "extended_master_secret (23)"}
1293
1294
1295 def test_tls13_server_hello(capsys):
1296 entrypoint.main(["--token", base64.b64encode(get_data("tls1.3_server_hello")).decode()])
1297 actual_out = capsys.readouterr()
1298
1299 assert actual_out.err == ""
1300 actual = json.loads(actual_out.out)
1301
1302 assert isinstance(actual, list)
1303 assert len(actual) == 3
1304
1305 assert isinstance(actual[0], dict)
1306 assert actual[0]["ContentType"] == "handshake (22)"
1307 assert actual[0]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1308 assert actual[0]["RawData"] is not None
1309
1310 actual_handshakes = actual[0]["Data"]
1311 assert isinstance(actual_handshakes, list)
1312 assert len(actual_handshakes) == 1
1313 assert isinstance(actual_handshakes[0], dict)
1314
1315 assert actual_handshakes[0]["HandshakeType"] == "server_hello (2)"
1316 assert actual_handshakes[0]["RawData"] is not None
1317
1318 actual_hello = actual_handshakes[0]["Data"]
1319 assert actual_hello["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1320 assert actual_hello["Random"] == "0C330D260EFB17B9BC142F29ACA1369B5176ACE30BFBAE56090DEC68A59BF457"
1321 assert actual_hello["SessionID"] == "2AE52188EF97D27FD6EA670EC3DB3064DBE431B12E262A0B87F45EAA13E29F45"
1322 assert actual_hello["CipherSuite"] == "TLS_AES_256_GCM_SHA384 - 0x1302"
1323 assert actual_hello["CompressionMethod"] == "none (0)"
1324 assert len(actual_hello["Extensions"]) == 2
1325
1326 assert actual_hello["Extensions"][0]["ExtensionType"] == "supported_versions (43)"
1327 assert actual_hello["Extensions"][0]["Data"] == "TLS 1.3 (0x0304) (772)"
1328 assert actual_hello["Extensions"][0]["RawData"] is not None
1329
1330 assert actual_hello["Extensions"][1]["ExtensionType"] == "key_share (51)"
1331 assert actual_hello["Extensions"][1]["Data"] == {
1332 "Group": "x25519 (29)",
1333 "Key": "20BABC51697B813B09E7228F3453178C35A1D4005584859EEB5DC38248C84950",
1334 }
1335 assert actual_hello["Extensions"][1]["RawData"] is not None
1336
1337 assert isinstance(actual[1], dict)
1338 assert actual[1] == {
1339 "ContentType": "change_cipher_spec (20)",
1340 "ProtocolVersion": "TLS 1.2 (0x0303) (771)",
1341 "RawData": "140303000101",
1342 }
1343
1344 assert isinstance(actual[2], dict)
1345 assert actual[2]["ContentType"] == "application_data (23)"
1346 assert actual[2]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1347 assert actual[2]["RawData"] is not None
1348
1349
1350 def test_tls12_server_hello(capsys):
1351 entrypoint.main(["--token", base64.b64encode(get_data("tls1.2_server_hello")).decode()])
1352 actual_out = capsys.readouterr()
1353
1354 assert actual_out.err == ""
1355 actual = json.loads(actual_out.out)
1356
1357 assert isinstance(actual, list)
1358 assert len(actual) == 4
1359
1360 assert isinstance(actual[0], dict)
1361 assert actual[0]["ContentType"] == "handshake (22)"
1362 assert actual[0]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1363 assert actual[0]["RawData"] is not None
1364
1365 entry1 = actual[0]["Data"]
1366 assert isinstance(entry1, list)
1367 assert len(entry1) == 1
1368 assert isinstance(entry1[0], dict)
1369
1370 assert entry1[0]["HandshakeType"] == "server_hello (2)"
1371 assert entry1[0]["RawData"] is not None
1372
1373 actual_hello = entry1[0]["Data"]
1374 assert actual_hello["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1375 assert actual_hello["Random"] == "3A1EAF5E3C0B9BD4FE889BAE819C1F392613D5320910907469C7A79158430C40"
1376 assert actual_hello["SessionID"] == "394772ADC4255C0B50C4F3892CE8AC4827A63F1FE056E1E60B35306F83B19A27"
1377 assert actual_hello["CipherSuite"] == "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 - 0xC02F"
1378 assert actual_hello["CompressionMethod"] == "none (0)"
1379 assert len(actual_hello["Extensions"]) == 4
1380
1381 assert actual_hello["Extensions"][0] == {"ExtensionType": "server_name (0)"}
1382
1383 assert actual_hello["Extensions"][1]["ExtensionType"] == "renegotiation_info (65281)"
1384 assert actual_hello["Extensions"][1]["RawData"] == "00"
1385
1386 assert actual_hello["Extensions"][2]["ExtensionType"] == "ec_point_formats (11)"
1387 assert actual_hello["Extensions"][2]["Data"] == [
1388 "uncompressed (0)",
1389 "ansiX962_compressed_prime (1)",
1390 "ansiX962_compressed_char2 (2)",
1391 ]
1392 assert actual_hello["Extensions"][2]["RawData"] == "03000102"
1393
1394 assert actual_hello["Extensions"][3]["ExtensionType"] == "application_layer_protocol_negotiation (16)"
1395 assert actual_hello["Extensions"][3]["Data"] == [
1396 "http/1.1",
1397 ]
1398 assert actual_hello["Extensions"][3]["RawData"] == "000908687474702F312E31"
1399
1400 assert isinstance(actual[1], dict)
1401 assert actual[1]["ContentType"] == "handshake (22)"
1402 assert actual[1]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1403 assert actual[1]["RawData"] is not None
1404
1405 entry2 = actual[1]["Data"]
1406 assert isinstance(entry2, list)
1407 assert len(entry2) == 1
1408
1409 assert isinstance(entry2[0], dict)
1410 assert entry2[0]["HandshakeType"] == "certificate (11)"
1411 assert entry2[0]["RawData"] is not None
1412
1413 actual_certificate = entry2[0]["Data"]
1414 assert actual_certificate["Certificate"] is not None
1415
1416 assert isinstance(actual[2], dict)
1417 assert actual[2]["ContentType"] == "handshake (22)"
1418 assert actual[2]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1419 assert actual[2]["RawData"] is not None
1420
1421 entry3 = actual[2]["Data"]
1422 assert isinstance(entry3, list)
1423 assert len(entry3) == 1
1424
1425 assert isinstance(entry2[0], dict)
1426 assert entry3[0]["HandshakeType"] == "server_key_exchange (12)"
1427 assert entry3[0]["RawData"] is not None
1428
1429 actual_server_key_exch = entry3[0]["Data"]
1430 assert actual_server_key_exch["CurveType"] == "named_curve (3)"
1431 assert actual_server_key_exch["Curve"] == "secp256r1 (23)"
1432 assert actual_server_key_exch["PublicKey"] is not None
1433 assert actual_server_key_exch["SignatureAlgorithm"] == "rsa_pkcs1_sha512 (1537)"
1434 assert actual_server_key_exch["Signature"] is not None
1435
1436 assert isinstance(actual[3], dict)
1437 assert actual[3]["ContentType"] == "handshake (22)"
1438 assert actual[3]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1439 assert actual[3]["RawData"] is not None
1440
1441 entry4 = actual[3]["Data"]
1442 assert isinstance(entry4, list)
1443 assert len(entry4) == 2
1444
1445 assert isinstance(entry4[0], dict)
1446 assert entry4[0]["HandshakeType"] == "certificate_request (13)"
1447 assert entry4[0]["RawData"] is not None
1448
1449 actual_cert_req = entry4[0]["Data"]
1450 assert actual_cert_req["CertificateTypes"] == [
1451 "rsa_sign (1)",
1452 "dss_sign (2)",
1453 "ecdsa_sign (64)",
1454 ]
1455 assert actual_cert_req["SignatureAlgorithms"] == [
1456 "rsa_pkcs1_sha512 (1537)",
1457 "dsa_sha512 (1538)",
1458 "ecdsa_secp521r1_sha512 (1539)",
1459 "rsa_pkcs1_sha384 (1281)",
1460 "dsa_sha384 (1282)",
1461 "ecdsa_secp384r1_sha384 (1283)",
1462 "rsa_pkcs1_sha256 (1025)",
1463 "dsa_sha256 (1026)",
1464 "ecdsa_secp256r1_sha256 (1027)",
1465 "sha224_rsa (769)",
1466 "dsa_sha224 (770)",
1467 "sha224_ecdsa (771)",
1468 "rsa_pkcs1_sha1 (513)",
1469 "dsa_sha1 (514)",
1470 "ecdsa_sha1 (515)",
1471 ]
1472 assert actual_cert_req["CertificateAuthorities"] == [
1473 {"OID": "id-at-countryName (2.5.4.6)", "Value": "US"},
1474 {"OID": "id-at-stateOrProvinceName (2.5.4.8)", "Value": "California"},
1475 {"OID": "id-at-localityName (2.5.4.7)", "Value": "San Francisco"},
1476 {"OID": "id-at-organizationName (2.5.4.10)", "Value": "BadSSL"},
1477 {"OID": "id-at-commonName (2.5.4.3)", "Value": "BadSSL Client Root Certificate Authority"},
1478 ]
1479
1480 assert isinstance(entry4[1], dict)
1481 assert entry4[1]["HandshakeType"] == "server_hello_done (14)"
1482 assert entry4[1]["RawData"] is not None
1483
1484
1485 def test_tls11_server_hello(capsys):
1486 entrypoint.main(["--token", base64.b64encode(get_data("tls1.1_server_hello")).decode()])
1487 actual_out = capsys.readouterr()
1488
1489 assert actual_out.err == ""
1490 actual = json.loads(actual_out.out)
1491
1492 assert isinstance(actual, list)
1493 assert len(actual) == 1
1494
1495 assert isinstance(actual[0], dict)
1496 assert actual[0]["ContentType"] == "handshake (22)"
1497 assert actual[0]["ProtocolVersion"] == "TLS 1.1 (0x0302) (770)"
1498 assert actual[0]["RawData"] is not None
1499
1500 actual_handshakes = actual[0]["Data"]
1501 assert isinstance(actual_handshakes, list)
1502 assert len(actual_handshakes) == 4
1503 assert isinstance(actual_handshakes[0], dict)
1504
1505 assert actual_handshakes[0]["HandshakeType"] == "server_hello (2)"
1506 assert actual_handshakes[0]["RawData"] is not None
1507
1508 actual_hello = actual_handshakes[0]["Data"]
1509 assert actual_hello["ProtocolVersion"] == "TLS 1.1 (0x0302) (770)"
1510 assert actual_hello["Random"] == "636B6A884D89DB703FB99037847AF10F7BC64846CE4EBA7C444F574E47524400"
1511 assert actual_hello["SessionID"] == "2610000040B449AC2B16836E336AF8E42783E74EE2E2ABB2D5916199C996B633"
1512 assert actual_hello["CipherSuite"] == "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA - 0xC014"
1513 assert actual_hello["CompressionMethod"] == "none (0)"
1514 assert len(actual_hello["Extensions"]) == 2
1515
1516 assert actual_hello["Extensions"][0] == {
1517 "ExtensionType": "extended_master_secret (23)",
1518 }
1519
1520 assert actual_hello["Extensions"][1]["ExtensionType"] == "renegotiation_info (65281)"
1521 assert actual_hello["Extensions"][1]["RawData"] == "00"
1522
1523 assert actual_handshakes[1]["HandshakeType"] == "certificate (11)"
1524 assert actual_handshakes[1]["RawData"] is not None
1525 actual_certificate = actual_handshakes[1]["Data"]
1526 assert actual_certificate["Certificate"] is not None
1527
1528 assert actual_handshakes[2]["HandshakeType"] == "server_key_exchange (12)"
1529 assert actual_handshakes[2]["RawData"] is not None
1530 actual_server_key_exch = actual_handshakes[2]["Data"]
1531 assert actual_server_key_exch["CurveType"] == "named_curve (3)"
1532 assert actual_server_key_exch["Curve"] == "secp384r1 (24)"
1533 assert actual_server_key_exch["PublicKey"] is not None
1534 assert actual_server_key_exch["SignatureAlgorithm"] is None
1535 assert actual_server_key_exch["Signature"] is not None
1536
1537 assert actual_handshakes[3]["HandshakeType"] == "server_hello_done (14)"
1538 assert actual_handshakes[3]["RawData"] is not None
1539
1540
1541 def test_tls10_server_hello(capsys):
1542 entrypoint.main(["--token", base64.b64encode(get_data("tls1.0_server_hello")).decode()])
1543 actual_out = capsys.readouterr()
1544
1545 assert actual_out.err == ""
1546 actual = json.loads(actual_out.out)
1547
1548 assert isinstance(actual, list)
1549 assert len(actual) == 1
1550
1551 assert isinstance(actual[0], dict)
1552 assert actual[0]["ContentType"] == "handshake (22)"
1553 assert actual[0]["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1554 assert actual[0]["RawData"] is not None
1555
1556 actual_handshakes = actual[0]["Data"]
1557 assert isinstance(actual_handshakes, list)
1558 assert len(actual_handshakes) == 4
1559 assert isinstance(actual_handshakes[0], dict)
1560
1561 assert actual_handshakes[0]["HandshakeType"] == "server_hello (2)"
1562 assert actual_handshakes[0]["RawData"] is not None
1563
1564 actual_hello = actual_handshakes[0]["Data"]
1565 assert actual_hello["ProtocolVersion"] == "TLS 1.0 (0x0301) (769)"
1566 assert actual_hello["Random"] == "636B6A8EF194ACC4C15811DBEC314A07D8ECF15DEF047781444F574E47524400"
1567 assert actual_hello["SessionID"] == "2B380000A583E220707B9E7D5372F3ED2946D32586F79E5BC0E36BD4DD8E6A0C"
1568 assert actual_hello["CipherSuite"] == "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA - 0xC014"
1569 assert actual_hello["CompressionMethod"] == "none (0)"
1570 assert len(actual_hello["Extensions"]) == 2
1571
1572 assert actual_hello["Extensions"][0] == {
1573 "ExtensionType": "extended_master_secret (23)",
1574 }
1575
1576 assert actual_hello["Extensions"][1]["ExtensionType"] == "renegotiation_info (65281)"
1577 assert actual_hello["Extensions"][1]["RawData"] == "00"
1578
1579 assert actual_handshakes[1]["HandshakeType"] == "certificate (11)"
1580 assert actual_handshakes[1]["RawData"] is not None
1581 actual_certificate = actual_handshakes[1]["Data"]
1582 assert actual_certificate["Certificate"] is not None
1583
1584 assert actual_handshakes[2]["HandshakeType"] == "server_key_exchange (12)"
1585 assert actual_handshakes[2]["RawData"] is not None
1586 actual_server_key_exch = actual_handshakes[2]["Data"]
1587 assert actual_server_key_exch["CurveType"] == "named_curve (3)"
1588 assert actual_server_key_exch["Curve"] == "secp384r1 (24)"
1589 assert actual_server_key_exch["PublicKey"] is not None
1590 assert actual_server_key_exch["SignatureAlgorithm"] is None
1591 assert actual_server_key_exch["Signature"] is not None
1592
1593 assert actual_handshakes[3]["HandshakeType"] == "server_hello_done (14)"
1594 assert actual_handshakes[3]["RawData"] is not None
1595
1596
1597 def test_tls12_client_key_exchange(capsys):
1598 entrypoint.main(["--token", base64.b64encode(get_data("tls1.2_client_key_exchange")).decode()])
1599 actual_out = capsys.readouterr()
1600
1601 assert actual_out.err == ""
1602 actual = json.loads(actual_out.out)
1603
1604 assert isinstance(actual, list)
1605 assert len(actual) == 1
1606
1607 assert isinstance(actual[0], dict)
1608 assert actual[0]["ContentType"] == "handshake (22)"
1609 assert actual[0]["ProtocolVersion"] == "TLS 1.2 (0x0303) (771)"
1610 assert actual[0]["RawData"] is not None
1611
1612 actual_handshakes = actual[0]["Data"]
1613 assert isinstance(actual_handshakes, list)
1614 assert len(actual_handshakes) == 1
1615 assert isinstance(actual_handshakes[0], dict)
1616
1617 assert actual_handshakes[0]["HandshakeType"] == "client_key_exchange (16)"
1618 assert actual_handshakes[0]["RawData"] is not None
1619
1620 actual_ckx = actual_handshakes[0]["Data"]
1621 assert actual_ckx["PublicKey"] is not None