Debian Codegraph @

tests/test_kerberos.py

raw
1 # -*- coding: utf-8 -*-
2 # Copyright: (c) 2020, Jordan Borean (@jborean93) <[email protected]>
3 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
4
5 import datetime
6
7 import spnego._kerberos as kerb
8 import spnego._spnego as sp
9 from spnego._asn1 import (
10 TagClass,
11 TypeTagNumber,
12 pack_asn1,
13 pack_asn1_bit_string,
14 pack_asn1_general_string,
15 pack_asn1_integer,
16 pack_asn1_octet_string,
17 pack_asn1_sequence,
18 )
19 from spnego._context import GSSMech
20
21 from .conftest import get_data
22
23
24 def test_parse_enum_unknown():
25 actual = kerb.parse_enum(10, enum_type=kerb.KerberosAPOptions)
26 assert actual == "UNKNOWN (10)"
27
28
29 def test_parse_flags_unknown():
30 actual = kerb.parse_flags(10, enum_type=kerb.KerberosAPOptions)
31 assert actual["raw"] == 10
32 assert actual["flags"] == ["UNKNOWN (10)"]
33
34
35 def test_kerberos_ap_options_native_labels():
36 actual = kerb.KerberosAPOptions.native_labels()
37
38 assert isinstance(actual, dict)
39 assert actual[kerb.KerberosAPOptions.mutual_required] == "mutual-required"
40
41
42 def test_kerberos_kdc_options_native_labels():
43 actual = kerb.KerberosKDCOptions.native_labels()
44
45 assert isinstance(actual, dict)
46 assert actual[kerb.KerberosKDCOptions.forwardable] == "forwardable"
47
48
49 def test_kerberos_encryption_type_native_labels():
50 actual = kerb.KerberosEncryptionType.native_labels()
51
52 assert isinstance(actual, dict)
53 assert actual[kerb.KerberosEncryptionType.des_cbc_crc] == "DES_CBC_CRC"
54
55
56 def test_kerberos_error_code_native_labels():
57 actual = kerb.KerberosErrorCode.native_labels()
58
59 assert isinstance(actual, dict)
60 assert actual[kerb.KerberosErrorCode.none] == "KDC_ERR_NONE"
61
62
63 def test_kerberos_message_type_native_labels():
64 actual = kerb.KerberosMessageType.native_labels()
65
66 assert isinstance(actual, dict)
67 assert actual[kerb.KerberosMessageType.as_req] == "AS-REQ"
68
69
70 def test_kerberos_pa_data_type_native_labels():
71 actual = kerb.KerberosPADataType.native_labels()
72
73 assert isinstance(actual, dict)
74 assert actual[kerb.KerberosPADataType.tgs_req] == "PA-TGS-REQ"
75
76
77 def test_kerberos_principal_name_type_native_labels():
78 actual = kerb.KerberosPrincipalNameType.native_labels()
79
80 assert isinstance(actual, dict)
81 assert actual[kerb.KerberosPrincipalNameType.principal] == "NT-PRINCIPAL"
82
83
84 def test_kerberos_host_address_type_native_labels():
85 actual = kerb.KerberosHostAddressType.native_labels()
86
87 assert isinstance(actual, dict)
88 assert actual[kerb.KerberosHostAddressType.ipv4] == "IPv4"
89
90
91 def test_unpack_unknown_krb():
92 sequence = pack_asn1_sequence(
93 [
94 pack_asn1(TagClass.context_specific, True, 0, pack_asn1_integer(5)),
95 pack_asn1(TagClass.context_specific, True, 1, pack_asn1_integer(0)),
96 ]
97 )
98 actual = sp.unpack_token(sequence, unwrap=True)
99
100 assert isinstance(actual, kerb.KerberosV5Msg)
101 assert actual.PVNO == 5
102 assert isinstance(actual.sequence, dict)
103
104 assert actual.sequence[0].tag_class == TagClass.universal
105 assert not actual.sequence[0].constructed
106 assert actual.sequence[0].tag_number == TypeTagNumber.integer
107 assert actual.sequence[0].b_data == b"\x05"
108
109 assert actual.sequence[1].tag_class == TagClass.universal
110 assert not actual.sequence[1].constructed
111 assert actual.sequence[1].tag_number == TypeTagNumber.integer
112 assert actual.sequence[1].b_data == b"\x00"
113
114
115 def test_unpack_krb_as_req():
116 data = get_data("krb_as_req")
117
118 actual = sp.unpack_token(data)
119 assert actual == data
120
121 actual = sp.unpack_token(data, unwrap=True)
122
123 assert isinstance(actual, kerb.KrbAsReq)
124 assert actual.PVNO == 5
125 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.as_req
126 assert isinstance(actual.padata, list)
127 assert len(actual.padata) == 2
128
129 assert actual.padata[0].data_type == kerb.KerberosPADataType.enc_timestamp
130 assert (
131 actual.padata[0].b_value == b"\x30\x41\xA0\x03\x02\x01\x12\xA2\x3A\x04\x38\x07\x40\x46\x03\xA8"
132 b"\x69\xC9\x31\x76\xE2\x8E\xDA\xD1\x34\xCE\x7F\xC4\xC8\x73\x58\x0D"
133 b"\xF4\x61\x1C\x85\x5F\x43\xF6\xAA\x9E\x48\xE2\xF0\x8C\xC2\x88\x70"
134 b"\xAA\xBC\xF0\xF7\xF2\xD4\xA2\xC2\xE3\x53\xDE\x81\xF7\x30\x2F\xAF"
135 b"\x7C\x85\x12"
136 )
137 pa1_val = actual.padata[0].value
138 assert isinstance(pa1_val, kerb.EncryptedData)
139 assert pa1_val.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
140 assert pa1_val.kvno is None
141 assert (
142 pa1_val.cipher == b"\x07\x40\x46\x03\xA8\x69\xC9\x31\x76\xE2\x8E\xDA\xD1\x34\xCE\x7F"
143 b"\xC4\xC8\x73\x58\x0D\xF4\x61\x1C\x85\x5F\x43\xF6\xAA\x9E\x48\xE2"
144 b"\xF0\x8C\xC2\x88\x70\xAA\xBC\xF0\xF7\xF2\xD4\xA2\xC2\xE3\x53\xDE"
145 b"\x81\xF7\x30\x2F\xAF\x7C\x85\x12"
146 )
147
148 assert actual.padata[1].data_type == 149
149 assert actual.padata[1].b_value == b""
150 assert actual.padata[1].value == b""
151
152 assert isinstance(actual.req_body, kerb.KdcReqBody)
153 assert actual.req_body.additional_tickets is None
154 assert actual.req_body.addresses is None
155 assert actual.req_body.cname == kerb.PrincipalName(kerb.KerberosPrincipalNameType.principal, [b"vagrant-domain"])
156 assert actual.req_body.enc_authorization_data is None
157 assert actual.req_body.etype == [
158 kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96,
159 kerb.KerberosEncryptionType.aes128_cts_hmac_sha1_96,
160 kerb.KerberosEncryptionType.des3_cbc_sha1,
161 kerb.KerberosEncryptionType.rc4_hmac,
162 ]
163 assert actual.req_body.kdc_options == 1073741824
164 assert actual.req_body.nonce == 734266074
165 assert actual.req_body.postdated_from is None
166 assert actual.req_body.postdated_till == datetime.datetime(2020, 6, 14, 7, 4, 20, tzinfo=datetime.timezone.utc)
167 assert actual.req_body.realm == b"DOMAIN.LOCAL"
168 assert actual.req_body.rtime is None
169 assert actual.req_body.sname == kerb.PrincipalName(
170 kerb.KerberosPrincipalNameType.srv_inst, [b"krbtgt", b"DOMAIN.LOCAL"]
171 )
172
173 # Test pyspnego-parse dict.
174 actual = kerb.parse_kerberos_token(actual)
175 assert isinstance(actual, dict)
176 assert actual["pvno"] == 5
177 assert actual["msg-type"] == "AS-REQ (10)"
178 assert isinstance(actual["padata"], list)
179 assert len(actual["padata"]) == 2
180 assert actual["padata"][0]["padata-type"] == "PA-ENC-TIMESTAMP (2)"
181 assert actual["padata"][0]["padata-value"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
182 assert actual["padata"][0]["padata-value"]["kvno"] is None
183 assert (
184 actual["padata"][0]["padata-value"]["cipher"] == "07404603A869C93176E28EDAD134CE7F"
185 "C4C873580DF4611C855F43F6AA9E48E2"
186 "F08CC28870AABCF0F7F2D4A2C2E353DE"
187 "81F7302FAF7C8512"
188 )
189 assert actual["padata"][1]["padata-type"] == "PA-REQ-ENC-PA-REP (149)"
190 assert actual["padata"][1]["padata-value"] == ""
191 assert actual["req-body"]["kdc-options"]["raw"] == 1073741824
192 assert actual["req-body"]["kdc-options"]["flags"] == ["forwardable (1073741824)"]
193 assert actual["req-body"]["cname"]["name-type"] == "NT-PRINCIPAL (1)"
194 assert actual["req-body"]["cname"]["name-string"] == ["vagrant-domain"]
195 assert actual["req-body"]["realm"] == "DOMAIN.LOCAL"
196 assert actual["req-body"]["sname"]["name-type"] == "NT-SRV-INST (2)"
197 assert actual["req-body"]["sname"]["name-string"] == ["krbtgt", "DOMAIN.LOCAL"]
198 assert actual["req-body"]["from"] is None
199 assert actual["req-body"]["till"] == "2020-06-14T07:04:20+00:00"
200 assert actual["req-body"]["rtime"] is None
201 assert actual["req-body"]["nonce"] == 734266074
202 assert actual["req-body"]["etype"] == [
203 "AES256_CTS_HMAC_SHA1_96 (18)",
204 "AES128_CTS_HMAC_SHA1_96 (17)",
205 "DES3_CBC_SHA1 (16)",
206 "RC4_HMAC (23)",
207 ]
208 assert actual["req-body"]["addresses"] is None
209 assert actual["req-body"]["enc-authorization-data"] is None
210 assert actual["req-body"]["additional-tickets"] is None
211
212
213 def test_unpack_krb_tgs_req():
214 data = get_data("krb_tgs_req")
215
216 actual = sp.unpack_token(data)
217 assert actual == data
218
219 actual = sp.unpack_token(data, unwrap=True)
220
221 assert isinstance(actual, kerb.KrbTgsReq)
222 assert actual.PVNO == 5
223 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.tgs_req
224 assert isinstance(actual.padata, list)
225 assert len(actual.padata) == 1
226 assert actual.padata[0].data_type == kerb.KerberosPADataType.tgs_req
227 assert isinstance(actual.padata[0].b_value, bytes)
228
229 pa1_val = actual.padata[0].value
230 assert pa1_val.PVNO == 5
231 assert pa1_val.MESSAGE_TYPE == kerb.KerberosMessageType.ap_req
232 assert pa1_val.ap_options == 0
233 assert isinstance(pa1_val.authenticator.cipher, bytes)
234 assert pa1_val.authenticator.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
235 assert pa1_val.authenticator.kvno is None
236 assert isinstance(pa1_val.ticket.enc_part.cipher, bytes)
237 assert pa1_val.ticket.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
238 assert pa1_val.ticket.enc_part.kvno == 2
239 assert pa1_val.ticket.realm == b"DOMAIN.LOCAL"
240 assert pa1_val.ticket.sname == kerb.PrincipalName(
241 kerb.KerberosPrincipalNameType.srv_inst, [b"krbtgt", b"DOMAIN.LOCAL"]
242 )
243 assert pa1_val.ticket.tkt_vno == 5
244
245 assert actual.req_body.additional_tickets is None
246 assert actual.req_body.addresses is None
247 assert actual.req_body.cname is None
248 assert actual.req_body.enc_authorization_data is None
249 assert actual.req_body.etype == [
250 kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96,
251 kerb.KerberosEncryptionType.aes128_cts_hmac_sha1_96,
252 kerb.KerberosEncryptionType.des3_cbc_sha1,
253 kerb.KerberosEncryptionType.rc4_hmac,
254 ]
255 assert actual.req_body.kdc_options == 1073807360
256 assert actual.req_body.nonce == 333512069
257 assert actual.req_body.postdated_from is None
258 assert actual.req_body.postdated_till == datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
259 assert actual.req_body.realm == b"DOMAIN.LOCAL"
260 assert actual.req_body.rtime is None
261 assert actual.req_body.sname == kerb.PrincipalName(
262 kerb.KerberosPrincipalNameType.srv_hst, [b"HTTP", b"server2019.domain.local"]
263 )
264
265 # Test pyspnego-parse dict.
266 actual = kerb.parse_kerberos_token(actual)
267 assert actual["pvno"] == 5
268 assert actual["msg-type"] == "TGS-REQ (12)"
269 assert isinstance(actual["padata"], list)
270 assert len(actual["padata"]) == 1
271 assert actual["padata"][0]["padata-type"] == "PA-TGS-REQ (1)"
272 assert actual["padata"][0]["padata-value"]["pvno"] == 5
273 assert actual["padata"][0]["padata-value"]["msg-type"] == "AP-REQ (14)"
274 assert actual["padata"][0]["padata-value"]["ap-options"]["raw"] == 0
275 assert actual["padata"][0]["padata-value"]["ap-options"]["flags"] == []
276 assert actual["padata"][0]["padata-value"]["ticket"]["tkt-vno"] == 5
277 assert actual["padata"][0]["padata-value"]["ticket"]["realm"] == "DOMAIN.LOCAL"
278 assert actual["padata"][0]["padata-value"]["ticket"]["sname"]["name-type"] == "NT-SRV-INST (2)"
279 assert actual["padata"][0]["padata-value"]["ticket"]["sname"]["name-string"] == ["krbtgt", "DOMAIN.LOCAL"]
280 assert actual["padata"][0]["padata-value"]["ticket"]["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
281 assert actual["padata"][0]["padata-value"]["ticket"]["enc-part"]["kvno"] == 2
282 assert isinstance(actual["padata"][0]["padata-value"]["ticket"]["enc-part"]["cipher"], str)
283 assert actual["padata"][0]["padata-value"]["authenticator"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
284 assert actual["padata"][0]["padata-value"]["authenticator"]["kvno"] is None
285 assert isinstance(actual["padata"][0]["padata-value"]["authenticator"]["cipher"], str)
286 assert actual["req-body"]["kdc-options"]["raw"] == 1073807360
287 assert actual["req-body"]["kdc-options"]["flags"] == ["forwardable (1073741824)", "canonicalize (65536)"]
288 assert actual["req-body"]["cname"] is None
289 assert actual["req-body"]["realm"] == "DOMAIN.LOCAL"
290 assert actual["req-body"]["sname"]["name-type"] == "NT-SRV-HST (3)"
291 assert actual["req-body"]["sname"]["name-string"] == ["HTTP", "server2019.domain.local"]
292 assert actual["req-body"]["from"] is None
293 assert actual["req-body"]["till"] == "1970-01-01T00:00:00+00:00"
294 assert actual["req-body"]["rtime"] is None
295 assert actual["req-body"]["etype"] == [
296 "AES256_CTS_HMAC_SHA1_96 (18)",
297 "AES128_CTS_HMAC_SHA1_96 (17)",
298 "DES3_CBC_SHA1 (16)",
299 "RC4_HMAC (23)",
300 ]
301 assert actual["req-body"]["addresses"] is None
302 assert actual["req-body"]["enc-authorization-data"] is None
303 assert actual["req-body"]["additional-tickets"] is None
304
305
306 def test_unpack_krb_as_rep():
307 data = get_data("krb_as_rep")
308
309 actual = sp.unpack_token(data)
310 assert actual == data
311
312 actual = sp.unpack_token(data, unwrap=True)
313
314 assert isinstance(actual, kerb.KrbAsRep)
315 assert actual.PVNO == 5
316 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.as_rep
317 assert actual.cname == kerb.PrincipalName(kerb.KerberosPrincipalNameType.principal, [b"vagrant-domain"])
318 assert actual.crealm == b"DOMAIN.LOCAL"
319
320 assert isinstance(actual.enc_part.cipher, bytes)
321 assert actual.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
322 assert actual.enc_part.kvno == 11
323
324 assert isinstance(actual.padata, list)
325 assert len(actual.padata) == 1
326 assert actual.padata[0].data_type == kerb.KerberosPADataType.etype_info2
327 assert (
328 actual.padata[0].b_value == b"\x30\x25\x30\x23\xA0\x03\x02\x01\x12\xA1\x1C\x1B\x1A\x44\x4F\x4D"
329 b"\x41\x49\x4E\x2E\x4C\x4F\x43\x41\x4C\x76\x61\x67\x72\x61\x6E\x74"
330 b"\x2D\x64\x6F\x6D\x61\x69\x6E"
331 )
332 pa1_val = actual.padata[0].value
333 assert isinstance(pa1_val, list)
334 assert len(pa1_val) == 1
335 assert pa1_val[0].etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
336 assert pa1_val[0].salt == b"DOMAIN.LOCALvagrant-domain"
337 assert pa1_val[0].s2kparams is None
338
339 assert isinstance(actual.ticket.enc_part.cipher, bytes)
340 assert actual.ticket.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
341 assert actual.ticket.enc_part.kvno == 2
342 assert actual.ticket.realm == b"DOMAIN.LOCAL"
343 assert actual.ticket.sname == kerb.PrincipalName(
344 kerb.KerberosPrincipalNameType.srv_inst, [b"krbtgt", b"DOMAIN.LOCAL"]
345 )
346 assert actual.ticket.tkt_vno == 5
347
348 # Test pyspnego-parse dict.
349 actual = kerb.parse_kerberos_token(actual)
350 assert actual["pvno"] == 5
351 assert actual["msg-type"] == "AS-REP (11)"
352 assert isinstance(actual["padata"], list)
353 assert len(actual["padata"]) == 1
354 assert actual["padata"][0]["padata-type"] == "PA-ETYPE-INFO2 (19)"
355 assert isinstance(actual["padata"][0]["padata-value"], list)
356 assert len(actual["padata"][0]["padata-value"]) == 1
357 assert actual["padata"][0]["padata-value"][0]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
358 assert actual["padata"][0]["padata-value"][0]["salt"] == "444F4D41494E2E4C4F43414C76616772616E742D646F6D61696E"
359 assert actual["padata"][0]["padata-value"][0]["s2kparams"] is None
360 assert actual["crealm"] == "DOMAIN.LOCAL"
361 assert actual["cname"]["name-type"] == "NT-PRINCIPAL (1)"
362 assert actual["cname"]["name-string"] == ["vagrant-domain"]
363 assert actual["ticket"]["tkt-vno"] == 5
364 assert actual["ticket"]["realm"] == "DOMAIN.LOCAL"
365 assert actual["ticket"]["sname"]["name-type"] == "NT-SRV-INST (2)"
366 assert actual["ticket"]["sname"]["name-string"] == ["krbtgt", "DOMAIN.LOCAL"]
367 assert actual["ticket"]["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
368 assert actual["ticket"]["enc-part"]["kvno"] == 2
369 assert isinstance(actual["ticket"]["enc-part"]["cipher"], str)
370 assert actual["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
371 assert actual["enc-part"]["kvno"] == 11
372 assert isinstance(actual["enc-part"]["cipher"], str)
373
374
375 def test_unpack_krb_tgs_rep():
376 data = get_data("krb_tgs_rep")
377
378 actual = sp.unpack_token(data)
379 assert actual == data
380
381 actual = sp.unpack_token(data, unwrap=True)
382
383 assert isinstance(actual, kerb.KrbTgsRep)
384 assert actual.PVNO == 5
385 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.tgs_rep
386 assert actual.cname == kerb.PrincipalName(kerb.KerberosPrincipalNameType.principal, [b"vagrant-domain"])
387 assert actual.crealm == b"DOMAIN.LOCAL"
388
389 assert isinstance(actual.enc_part.cipher, bytes)
390 assert actual.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
391 assert actual.enc_part.kvno is None
392
393 assert actual.padata is None
394
395 assert isinstance(actual.ticket.enc_part.cipher, bytes)
396 assert actual.ticket.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
397 assert actual.ticket.enc_part.kvno == 6
398 assert actual.ticket.realm == b"DOMAIN.LOCAL"
399 assert actual.ticket.sname == kerb.PrincipalName(
400 kerb.KerberosPrincipalNameType.srv_hst, [b"HTTP", b"server2019.domain.local"]
401 )
402 assert actual.ticket.tkt_vno == 5
403
404 # Test pyspnego-parse dict.
405 actual = kerb.parse_kerberos_token(actual)
406 assert actual["pvno"] == 5
407 assert actual["msg-type"] == "TGS-REP (13)"
408 assert actual["padata"] is None
409 assert actual["crealm"] == "DOMAIN.LOCAL"
410 assert actual["cname"]["name-type"] == "NT-PRINCIPAL (1)"
411 assert actual["cname"]["name-string"] == ["vagrant-domain"]
412 assert actual["ticket"]["tkt-vno"] == 5
413 assert actual["ticket"]["realm"] == "DOMAIN.LOCAL"
414 assert actual["ticket"]["sname"]["name-type"] == "NT-SRV-HST (3)"
415 assert actual["ticket"]["sname"]["name-string"] == ["HTTP", "server2019.domain.local"]
416 assert actual["ticket"]["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
417 assert actual["ticket"]["enc-part"]["kvno"] == 6
418 assert isinstance(actual["ticket"]["enc-part"]["cipher"], str)
419 assert actual["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
420 assert actual["enc-part"]["kvno"] is None
421 assert isinstance(actual["enc-part"]["cipher"], str)
422
423
424 def test_unpack_krb_ap_req():
425 data = get_data("initial_context_token_krb_ap_req")
426
427 actual = sp.unpack_token(data)
428 assert actual == data
429
430 actual = sp.unpack_token(data, unwrap=True)
431
432 assert isinstance(actual, sp.InitialContextToken)
433 assert actual.this_mech == GSSMech.kerberos.value
434
435 actual = actual.token
436
437 assert isinstance(actual, kerb.KrbApReq)
438 assert actual.PVNO == 5
439 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.ap_req
440 assert actual.ap_options == kerb.KerberosAPOptions.mutual_required
441 assert isinstance(actual.authenticator.cipher, bytes)
442 assert actual.authenticator.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
443 assert actual.authenticator.kvno is None
444 assert isinstance(actual.ticket.enc_part.cipher, bytes)
445 assert actual.ticket.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
446 assert actual.ticket.enc_part.kvno == 6
447 assert actual.ticket.realm == b"DOMAIN.LOCAL"
448 assert actual.ticket.sname == kerb.PrincipalName(kerb.KerberosPrincipalNameType.srv_hst, [b"host", b"dc01"])
449 assert actual.ticket.tkt_vno == 5
450
451 # Test pyspnego-parse dict.
452 actual = kerb.parse_kerberos_token(actual)
453 assert actual["pvno"] == 5
454 assert actual["msg-type"] == "AP-REQ (14)"
455 assert actual["ap-options"]["raw"] == 32
456 assert actual["ap-options"]["flags"] == ["mutual-required (32)"]
457 assert actual["ticket"]["tkt-vno"] == 5
458 assert actual["ticket"]["realm"] == "DOMAIN.LOCAL"
459 assert actual["ticket"]["sname"]["name-type"] == "NT-SRV-HST (3)"
460 assert actual["ticket"]["sname"]["name-string"] == ["host", "dc01"]
461 assert actual["ticket"]["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
462 assert actual["ticket"]["enc-part"]["kvno"] == 6
463 assert isinstance(actual["ticket"]["enc-part"]["cipher"], str)
464 assert actual["authenticator"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
465 assert actual["authenticator"]["kvno"] is None
466 assert isinstance(actual["authenticator"]["cipher"], str)
467
468
469 def test_unpack_krb_ap_req_unknown_options():
470 data = get_data("initial_context_token_krb_ap_req")
471 data = data[:40] + b"\x10" + data[41:] # This is where ap-options is set
472
473 actual = sp.unpack_token(data, unwrap=True)
474
475 assert isinstance(actual, sp.InitialContextToken)
476 assert actual.this_mech == GSSMech.kerberos.value
477
478 actual = actual.token
479
480 assert isinstance(actual, kerb.KrbApReq)
481 assert actual.ap_options == 16
482
483
484 def test_unpack_krb_ap_rep():
485 data = get_data("initial_context_token_krb_ap_rep")
486
487 actual = sp.unpack_token(data)
488 assert actual == data
489
490 actual = sp.unpack_token(data, unwrap=True)
491
492 assert isinstance(actual, sp.InitialContextToken)
493 assert actual.this_mech == GSSMech.kerberos.value
494
495 actual = actual.token
496
497 assert isinstance(actual, kerb.KrbApRep)
498 assert actual.PVNO == 5
499 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.ap_rep
500 assert isinstance(actual.enc_part.cipher, bytes)
501 assert actual.enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
502 assert actual.enc_part.kvno is None
503
504 # Test pyspnego-parse dict.
505 actual = kerb.parse_kerberos_token(actual)
506 assert actual["pvno"] == 5
507 assert actual["msg-type"] == "AP-REP (15)"
508 assert actual["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
509 assert actual["enc-part"]["kvno"] is None
510 assert isinstance(actual["enc-part"]["cipher"], str)
511
512
513 def test_unpack_krb_error():
514 data = get_data("krb_error")
515
516 actual = sp.unpack_token(data)
517 assert actual == data
518
519 actual = sp.unpack_token(data, unwrap=True)
520
521 assert isinstance(actual, kerb.KrbError)
522 assert actual.PVNO == 5
523 assert actual.MESSAGE_TYPE == kerb.KerberosMessageType.error
524 assert actual.cname is None
525 assert actual.crealm is None
526 assert actual.ctime is None
527 assert actual.cusec is None
528 assert isinstance(actual.e_data, bytes)
529 assert actual.e_text is None
530 assert actual.error_code == kerb.KerberosErrorCode.preauth_required
531 assert actual.realm == b"DOMAIN.LOCAL"
532 assert actual.sname == kerb.PrincipalName(kerb.KerberosPrincipalNameType.srv_inst, [b"krbtgt", b"DOMAIN.LOCAL"])
533 assert actual.stime == datetime.datetime(2020, 6, 13, 21, 4, 23, tzinfo=datetime.timezone.utc)
534 assert actual.susec == 748591
535
536 actual = kerb.parse_kerberos_token(actual, encoding="utf-8")
537 assert actual["pvno"] == 5
538 assert actual["msg-type"] == "KRB-ERROR (30)"
539 assert actual["ctime"] is None
540 assert actual["cusec"] is None
541 assert actual["stime"] == "2020-06-13T21:04:23+00:00"
542 assert actual["susec"] == 748591
543 assert actual["error-code"] == "KDC_ERR_PREAUTH_REQUIRED (25)"
544 assert actual["crealm"] is None
545 assert actual["cname"] is None
546 assert actual["realm"] == "DOMAIN.LOCAL"
547 assert actual["sname"]["name-type"] == "NT-SRV-INST (2)"
548 assert actual["sname"]["name-string"] == ["krbtgt", "DOMAIN.LOCAL"]
549 assert actual["e-text"] is None
550 assert isinstance(actual["e-data"], str)
551
552
553 def test_padata_unknown_type():
554 value = b"".join(
555 [
556 pack_asn1(TagClass.context_specific, True, 1, pack_asn1_integer(1024)),
557 pack_asn1(TagClass.context_specific, True, 2, pack_asn1_octet_string(b"")),
558 ]
559 )
560 padata = kerb.PAData.unpack(value)
561
562 assert padata.data_type == 1024
563 assert padata.b_value == b""
564 assert padata.value == b""
565
566 actual = kerb.parse_kerberos_token(padata)
567
568 assert isinstance(actual, dict)
569 assert actual["padata-type"] == "UNKNOWN (1024)"
570 assert actual["padata-value"] == ""
571
572
573 def test_req_body_addresses():
574 value = b"".join(
575 [
576 pack_asn1(TagClass.context_specific, True, 0, pack_asn1_bit_string(b"\x00\x00\x00\x00")),
577 pack_asn1(TagClass.context_specific, True, 2, pack_asn1_general_string(b"DOMAIN.LOCAL")),
578 pack_asn1(TagClass.context_specific, True, 7, pack_asn1_integer(1)),
579 pack_asn1(
580 TagClass.context_specific,
581 True,
582 8,
583 pack_asn1_sequence([pack_asn1_integer(kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96)]),
584 ),
585 pack_asn1(
586 TagClass.context_specific,
587 True,
588 9,
589 pack_asn1_sequence(
590 [
591 pack_asn1_sequence(
592 [
593 pack_asn1(
594 TagClass.context_specific,
595 True,
596 0,
597 pack_asn1_integer(kerb.KerberosHostAddressType.ipv4),
598 ),
599 pack_asn1(
600 TagClass.context_specific, True, 1, pack_asn1_octet_string(b"dc01.domain.local")
601 ),
602 ]
603 )
604 ]
605 ),
606 ),
607 ]
608 )
609 req_body = kerb.KdcReqBody.unpack(value)
610
611 assert isinstance(req_body.addresses, list)
612 assert len(req_body.addresses) == 1
613 assert req_body.addresses[0].addr_type == kerb.KerberosHostAddressType.ipv4
614 assert req_body.addresses[0].value == b"dc01.domain.local"
615
616 actual = kerb.parse_kerberos_token(req_body)
617 assert isinstance(actual, dict)
618 assert actual["addresses"][0]["addr-type"] == "IPv4 (2)"
619 assert actual["addresses"][0]["address"] == "dc01.domain.local"
620
621
622 def test_req_body_ticket():
623 ticket = pack_asn1(
624 TagClass.application,
625 True,
626 1,
627 pack_asn1_sequence(
628 [
629 pack_asn1(TagClass.context_specific, True, 0, pack_asn1_integer(5)),
630 pack_asn1(TagClass.context_specific, True, 1, pack_asn1_general_string(b"DOMAIN.LOCAL")),
631 pack_asn1(
632 TagClass.context_specific,
633 True,
634 2,
635 pack_asn1_sequence(
636 [
637 pack_asn1(
638 TagClass.context_specific,
639 True,
640 0,
641 pack_asn1_integer(kerb.KerberosPrincipalNameType.principal),
642 ),
643 pack_asn1(
644 TagClass.context_specific,
645 True,
646 1,
647 pack_asn1_sequence(
648 [
649 pack_asn1_general_string(b"vagrant-domain"),
650 ]
651 ),
652 ),
653 ]
654 ),
655 ),
656 pack_asn1(
657 TagClass.context_specific,
658 True,
659 3,
660 pack_asn1_sequence(
661 [
662 pack_asn1(
663 TagClass.context_specific,
664 True,
665 0,
666 pack_asn1_integer(kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96),
667 ),
668 pack_asn1(TagClass.context_specific, True, 2, pack_asn1_octet_string(b"\x00\x01")),
669 ]
670 ),
671 ),
672 ]
673 ),
674 )
675 value = b"".join(
676 [
677 pack_asn1(TagClass.context_specific, True, 0, pack_asn1_bit_string(b"\x00\x00\x00\x00")),
678 pack_asn1(TagClass.context_specific, True, 2, pack_asn1_general_string(b"DOMAIN.LOCAL")),
679 pack_asn1(TagClass.context_specific, True, 7, pack_asn1_integer(1)),
680 pack_asn1(
681 TagClass.context_specific,
682 True,
683 8,
684 pack_asn1_sequence([pack_asn1_integer(kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96)]),
685 ),
686 pack_asn1(TagClass.context_specific, True, 11, pack_asn1_sequence([ticket])),
687 ]
688 )
689 req_body = kerb.KdcReqBody.unpack(value)
690
691 assert isinstance(req_body.additional_tickets, list)
692 assert len(req_body.additional_tickets) == 1
693 assert req_body.additional_tickets[0].enc_part.cipher == b"\x00\x01"
694 assert req_body.additional_tickets[0].enc_part.etype == kerb.KerberosEncryptionType.aes256_cts_hmac_sha1_96
695 assert req_body.additional_tickets[0].enc_part.kvno is None
696 assert req_body.additional_tickets[0].realm == b"DOMAIN.LOCAL"
697 assert req_body.additional_tickets[0].sname == kerb.PrincipalName(
698 kerb.KerberosPrincipalNameType.principal, [b"vagrant-domain"]
699 )
700 assert req_body.additional_tickets[0].tkt_vno == 5
701
702 actual = kerb.parse_kerberos_token(req_body)
703 assert isinstance(actual, dict)
704 assert actual["additional-tickets"][0]["tkt-vno"] == 5
705 assert actual["additional-tickets"][0]["realm"] == "DOMAIN.LOCAL"
706 assert actual["additional-tickets"][0]["sname"]["name-type"] == "NT-PRINCIPAL (1)"
707 assert actual["additional-tickets"][0]["sname"]["name-string"] == ["vagrant-domain"]
708 assert actual["additional-tickets"][0]["enc-part"]["etype"] == "AES256_CTS_HMAC_SHA1_96 (18)"
709 assert actual["additional-tickets"][0]["enc-part"]["kvno"] is None
710 assert actual["additional-tickets"][0]["enc-part"]["cipher"] == "0001"