Debian Codegraph @

src/spnego/_kerberos.py

raw
1 # Copyright: (c) 2020, Jordan Borean (@jborean93) <[email protected]>
2 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
3
4 """Kerberos Messages
5
6 Various Kerberos message structures that is used by 'python -m spnego' to unpack raw ASN.1 values and print out a
7 pretty structure for end users. This code is not used in the actual spnego authentication processes and is just used
8 for debugging purposes.
9 """
10
11 import base64
12 import collections
13 import datetime
14 import enum
15 import struct
16 import typing
17
18 from spnego._asn1 import (
19 ASN1Value,
20 TagClass,
21 extract_asn1_tlv,
22 get_sequence_value,
23 unpack_asn1,
24 unpack_asn1_bit_string,
25 unpack_asn1_general_string,
26 unpack_asn1_generalized_time,
27 unpack_asn1_integer,
28 unpack_asn1_octet_string,
29 unpack_asn1_sequence,
30 unpack_asn1_tagged_sequence,
31 )
32 from spnego._text import to_text
33
34
35 def _enum_labels(
36 value: typing.Union[int, str, enum.Enum],
37 enum_type: typing.Optional[typing.Type] = None,
38 ) -> typing.Dict[int, str]:
39 """Gets the human friendly labels of a known enum and what value they map to."""
40
41 def get_labels(v: typing.Any) -> typing.Dict[int, str]:
42 return typing.cast(typing.Dict[int, str], getattr(v, "native_labels", lambda: {})())
43
44 return get_labels(enum_type) if enum_type else get_labels(value)
45
46
47 def parse_enum(
48 value: typing.Union[int, str, enum.Enum],
49 enum_type: typing.Optional[typing.Type] = None,
50 ) -> str:
51 """Parses an IntEnum into a human representative object of that enum."""
52 enum_name = "UNKNOWN"
53 if isinstance(value, enum.Enum):
54 enum_name = value.name
55
56 labels = _enum_labels(value, enum_type)
57 value = value.value if isinstance(value, enum.Enum) else value
58
59 for v, name in labels.items():
60 if value == v:
61 enum_name = name
62 break
63
64 return "%s (%s)" % (enum_name, value)
65
66
67 def parse_flags(
68 value: typing.Union[int, enum.IntFlag],
69 enum_type: typing.Optional[typing.Type] = None,
70 ) -> typing.Dict[str, typing.Any]:
71 """Parses an IntFlag into each flag value that is set."""
72 raw_value = int(value)
73 flags = []
74
75 labels = _enum_labels(value, enum_type)
76 value = int(value)
77
78 for v, name in labels.items():
79 if value & v == v:
80 value &= ~v
81 flags.append("%s (%d)" % (name, v))
82
83 if value != 0:
84 flags.append("UNKNOWN (%d)" % value)
85
86 return {
87 "raw": raw_value,
88 "flags": flags,
89 }
90
91
92 def parse_kerberos_token(
93 token: typing.Union["KerberosV5Msg", "PAData", "PAETypeInfo2", "EncryptedData", "Ticket", "KdcReqBody"],
94 secret: typing.Optional[str] = None,
95 encoding: typing.Optional[str] = None,
96 ) -> typing.Union[str, typing.Dict[str, typing.Any]]:
97 """Parses a KerberosV5Msg object to a dict."""
98 text_encoding = encoding if encoding else "utf-8"
99
100 def parse_default(value: typing.Any) -> typing.Any:
101 return value
102
103 def parse_datetime(value: datetime.datetime) -> str:
104 return value.isoformat()
105
106 def parse_text(value: bytes) -> str:
107 return to_text(value, encoding=text_encoding, errors="replace")
108
109 def parse_bytes(value: bytes) -> str:
110 return base64.b16encode(value).decode()
111
112 def parse_principal_name(value: PrincipalName) -> typing.Dict[str, typing.Any]:
113 return {
114 "name-type": parse_enum(value.name_type),
115 "name-string": [parse_text(v) for v in value.value],
116 }
117
118 def parse_host_address(value: HostAddress) -> typing.Dict[str, typing.Any]:
119 return {
120 "addr-type": parse_enum(value.addr_type),
121 "address": parse_text(value.value),
122 }
123
124 def parse_token(value: typing.Any) -> typing.Union[str, typing.Dict[str, typing.Any]]:
125 return parse_kerberos_token(value, secret, text_encoding)
126
127 if isinstance(token, bytes):
128 return parse_bytes(token)
129
130 msg = {}
131 for name, attr_name, attr_type in getattr(token, "PARSE_MAP", {}):
132 attr_value = getattr(token, attr_name)
133
134 parse_args = []
135 if isinstance(attr_type, tuple):
136 parse_args.append(attr_type[1])
137 attr_type = attr_type[0]
138
139 parse_func: typing.Callable = { # type: ignore[assignment] # No idea why
140 ParseType.default: parse_default,
141 ParseType.enum: parse_enum,
142 ParseType.flags: parse_flags,
143 ParseType.datetime: parse_datetime,
144 ParseType.text: parse_text,
145 ParseType.bytes: parse_bytes,
146 ParseType.principal_name: parse_principal_name,
147 ParseType.host_address: parse_host_address,
148 ParseType.token: parse_token,
149 }[attr_type]
150
151 if attr_value is None:
152 parsed_value = None
153
154 elif isinstance(attr_value, list):
155 parsed_value = [parse_func(v, *parse_args) if v is not None else None for v in attr_value]
156
157 else:
158 parsed_value = parse_func(attr_value, *parse_args)
159
160 msg[name] = parsed_value
161
162 return msg
163
164
165 def unpack_hostname(value: typing.Union[bytes, ASN1Value]) -> "HostAddress":
166 """Unpacks an ASN.1 value to a HostAddress."""
167 s = unpack_asn1_tagged_sequence(value)
168
169 name_type = KerberosHostAddressType(get_sequence_value(s, 0, "HostAddress", "addr-type", unpack_asn1_integer))
170 name = get_sequence_value(s, 1, "HostAddress", "address", unpack_asn1_octet_string)
171
172 return HostAddress(name_type, name)
173
174
175 def unpack_principal_name(value: typing.Union[bytes, ASN1Value]) -> "PrincipalName":
176 """Unpacks an ASN.1 value to a PrincipalName."""
177 s = unpack_asn1_tagged_sequence(value)
178
179 name_type = KerberosPrincipalNameType(get_sequence_value(s, 0, "PrincipalName", "name-type", unpack_asn1_integer))
180 name = [
181 unpack_asn1_general_string(n)
182 for n in get_sequence_value(s, 1, "PrincipalName", "name-string", unpack_asn1_sequence)
183 ]
184
185 return PrincipalName(name_type, name)
186
187
188 HostAddress = collections.namedtuple("HostAddress", ["addr_type", "value"])
189 """Kerberos HostAddress and HostAddresses
190
191 A Kerberos Host Address ASN.1 definition is defined in `RFC 4120 5.2.5`_::
192
193 HostAddress ::= SEQUENCE {
194 addr-type [0] Int32,
195 address [1] OCTET STRING
196 }
197
198 Attributes:
199 addr_type (KerberosHostAddressType): The type of address that was encoded.
200 value (bytes): The address as a byte string.
201
202 .. _RFC 4120 5.2.5:
203 https://www.rfc-editor.org/rfc/rfc4120#section-5.2.5
204 """
205
206 PrincipalName = collections.namedtuple("PrincipalName", ["name_type", "value"])
207 """Kerberos Realm and PrincipalName
208
209 A Kerberos Principal Name ASN.1 definition is defined in `RFC 4120 5.2.2`_::
210
211 PrincipalName ::= SEQUENCE {
212 name-type [0] Int32,
213 name-string [1] SEQUENCE OF KerberosString
214 }
215
216 Attributes:
217 name_type (KerberosPrincipalNameType): The type of name the was encoded.
218 value (List[bytes]): Each component that forms the name.
219
220 .. _RFC 4120 5.2.2:
221 https://www.rfc-editor.org/rfc/rfc4120#section-5.2.2
222 """
223
224
225 # https://www.rfc-editor.org/rfc/rfc4120#section-5.5.1 - ap-options
226 class KerberosAPOptions(enum.IntFlag):
227 mutual_required = 0x00000020
228 use_session_key = 0x00000040
229 reserved = 0x00000080
230
231 @classmethod
232 def native_labels(cls) -> typing.Dict["KerberosAPOptions", str]:
233 return {
234 KerberosAPOptions.mutual_required: "mutual-required",
235 KerberosAPOptions.use_session_key: "use-session-key",
236 KerberosAPOptions.reserved: "reserved",
237 }
238
239
240 # https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1 - KDCOptions
241 class KerberosKDCOptions(enum.IntFlag):
242 reserved = 0x80000000
243 forwardable = 0x40000000
244 forwarded = 0x20000000
245 proxiable = 0x10000000
246 proxy = 0x08000000
247 allow_postdate = 0x04000000
248 postdated = 0x02000000
249 unused7 = 0x01000000
250 renewable = 0x00800000
251 unused9 = 0x00400000
252 unused10 = 0x00200000
253 opt_hardware_auth = 0x00100000
254 unused12 = 0x00080000
255 unused13 = 0x00040000
256 constrained_delegation = 0x00020000
257 canonicalize = 0x00010000
258 request_anonymous = 0x00008000
259 unused17 = 0x00004000
260 unused18 = 0x00002000
261 unused19 = 0x00001000
262 unused20 = 0x00000800
263 unused21 = 0x00000400
264 unused22 = 0x00000200
265 unused23 = 0x00000100
266 unused24 = 0x00000080
267 unused25 = 0x00000040
268 disable_transited_check = 0x00000020
269 renewable_ok = 0x00000010
270 enc_tkt_in_skey = 0x00000008
271 unused29 = 0x00000004
272 renew = 0x00000002
273 validate = 0x00000001
274
275 @classmethod
276 def native_labels(cls) -> typing.Dict["KerberosKDCOptions", str]:
277 return {
278 KerberosKDCOptions.reserved: "reserved",
279 KerberosKDCOptions.forwardable: "forwardable",
280 KerberosKDCOptions.forwarded: "forwarded",
281 KerberosKDCOptions.proxiable: "proxiable",
282 KerberosKDCOptions.proxy: "proxy",
283 KerberosKDCOptions.allow_postdate: "allow-postdate",
284 KerberosKDCOptions.postdated: "postdated",
285 KerberosKDCOptions.unused7: "unused7",
286 KerberosKDCOptions.renewable: "renewable",
287 KerberosKDCOptions.unused9: "unused9",
288 KerberosKDCOptions.unused10: "unused10",
289 KerberosKDCOptions.opt_hardware_auth: "opt-hardware-auth",
290 KerberosKDCOptions.unused12: "unused12",
291 KerberosKDCOptions.unused13: "unused13",
292 KerberosKDCOptions.constrained_delegation: "constrained-delegation",
293 KerberosKDCOptions.canonicalize: "canonicalize",
294 KerberosKDCOptions.request_anonymous: "request-anonymous",
295 KerberosKDCOptions.unused17: "unused17",
296 KerberosKDCOptions.unused18: "unused18",
297 KerberosKDCOptions.unused19: "unused19",
298 KerberosKDCOptions.unused20: "unused20",
299 KerberosKDCOptions.unused21: "unused21",
300 KerberosKDCOptions.unused22: "unused22",
301 KerberosKDCOptions.unused23: "unused23",
302 KerberosKDCOptions.unused24: "unused24",
303 KerberosKDCOptions.unused25: "unused25",
304 KerberosKDCOptions.disable_transited_check: "disable-transited-check",
305 KerberosKDCOptions.renewable_ok: "renewable-ok",
306 KerberosKDCOptions.enc_tkt_in_skey: "enc-tkt-in-skey",
307 KerberosKDCOptions.unused29: "unused29",
308 KerberosKDCOptions.renew: "renew",
309 KerberosKDCOptions.validate: "validate",
310 }
311
312
313 # https://ldapwiki.com/wiki/Kerberos%20Encryption%20Types - etypes
314 class KerberosEncryptionType(enum.IntEnum):
315 des_cbc_crc = 0x0001
316 des_cbc_md4 = 0x0002
317 des_cbc_md5 = 0x0003
318 des_cbc_raw = 0x0004
319 des3_cbc_raw = 0x0006
320 des3_cbc_sha1 = 0x0010
321 aes128_cts_hmac_sha1_96 = 0x0011
322 aes256_cts_hmac_sha1_96 = 0x0012
323 aes128_cts_hmac_sha256_128 = 0x0013
324 aes256_cts_hmac_sha384_192 = 0x0014
325 rc4_hmac = 0x0017
326 rc4_hmac_exp = 0x0018
327 camellia128_cts_cmac = 0x0019
328 camellia256_cts_cmac = 0x001A
329
330 @classmethod
331 def native_labels(cls) -> typing.Dict["KerberosEncryptionType", str]:
332 return {
333 KerberosEncryptionType.des_cbc_crc: "DES_CBC_CRC",
334 KerberosEncryptionType.des_cbc_md4: "DES_CBC_MD4",
335 KerberosEncryptionType.des_cbc_md5: "DES_CBC_MD5",
336 KerberosEncryptionType.des_cbc_raw: "DES_CBC_RAW",
337 KerberosEncryptionType.des3_cbc_raw: "DES3_CBC_RAW",
338 KerberosEncryptionType.des3_cbc_sha1: "DES3_CBC_SHA1",
339 KerberosEncryptionType.aes128_cts_hmac_sha1_96: "AES128_CTS_HMAC_SHA1_96",
340 KerberosEncryptionType.aes256_cts_hmac_sha1_96: "AES256_CTS_HMAC_SHA1_96",
341 KerberosEncryptionType.aes128_cts_hmac_sha256_128: "AES128_CTS_HMAC_SHA256_128",
342 KerberosEncryptionType.aes256_cts_hmac_sha384_192: "AES256_CTS_HMAC_SHA384_192",
343 KerberosEncryptionType.rc4_hmac: "RC4_HMAC",
344 KerberosEncryptionType.rc4_hmac_exp: "RC4_HMAC_EXP",
345 KerberosEncryptionType.camellia128_cts_cmac: "CAMELLIA128_CTS_CMAC",
346 KerberosEncryptionType.camellia256_cts_cmac: "CAMELLIA256_CTS_CMAC",
347 }
348
349
350 # https://www.rfc-editor.org/rfc/rfc4120#section-7.5.9
351 class KerberosErrorCode(enum.IntEnum):
352 none = 0
353 name_exp = 1
354 service_exp = 2
355 bad_pvno = 3
356 c_old_mast_kvno = 4
357 s_old_mast_kvno = 5
358 c_principal_unknown = 6
359 s_principal_unknown = 7
360 principal_not_unique = 8
361 null_key = 9
362 cannot_postdate = 10
363 never_valid = 11
364 policy = 12
365 badoption = 13
366 etype_nosupp = 14
367 sumtype_nosupp = 15
368 padata_type_nosupp = 16
369 trtype_nosupp = 17
370 client_revoked = 18
371 service_revoked = 19
372 tgt_revoked = 20
373 client_notyet = 21
374 service_notyet = 22
375 key_expired = 23
376 preauth_failed = 24
377 preauth_required = 25
378 server_nomatch = 26
379 must_use_user2user = 27
380 path_not_accepted = 28
381 kdc_svc_unavailable = 29
382 ap_bad_integrity = 31
383 ap_txt_expired = 32
384 ap_tkt_nyv = 33
385 ap_repeat = 34
386 ap_not_use = 35
387 ap_badmatch = 36
388 ap_skew = 37
389 ap_badaddr = 38
390 ap_badversion = 39
391 ap_msg_type = 40
392 ap_modified = 41
393 ap_badorder = 42
394 ap_badkeyver = 44
395 ap_nokey = 45
396 ap_mut_fail = 46
397 ap_baddirection = 47
398 ap_method = 48
399 ap_badseq = 49
400 ap_inapp_cksum = 50
401 ap_path_not_accepted = 51
402 response_too_big = 52
403 generic = 60
404 field_toolong = 61
405 kdc_client_not_trusted = 62
406 kdc_not_trusted = 53
407 kdc_invalid_sig = 64
408 kdc_key_too_weak = 65
409 kdc_certificate_mismatch = 66
410 ap_no_tgt = 67
411 kdc_wrong_realm = 68
412 ap_user_to_user_required = 69
413 kdc_cant_verify_certificate = 70
414 kdc_invalid_certificate = 71
415 kdc_revoked_certificate = 72
416 kdc_revocation_status_unknown = 73
417 kdc_revocation_status_unavailable = 74
418 kdc_client_name_mismatch = 75
419 kdc_name_mismatch = 76
420
421 @classmethod
422 def native_labels(cls) -> typing.Dict["KerberosErrorCode", str]:
423 return {
424 KerberosErrorCode.none: "KDC_ERR_NONE",
425 KerberosErrorCode.name_exp: "KDC_ERR_NAME_EXP",
426 KerberosErrorCode.service_exp: "KDC_ERR_SERVICE_EXP",
427 KerberosErrorCode.bad_pvno: "KDC_ERR_BAD_PVNO",
428 KerberosErrorCode.c_old_mast_kvno: "KDC_ERR_C_OLD_MAST_KVNO",
429 KerberosErrorCode.s_old_mast_kvno: "KDC_ERR_S_OLD_MAST_KVNO",
430 KerberosErrorCode.c_principal_unknown: "KDC_ERR_C_PRINCIPAL_UNKNOWN",
431 KerberosErrorCode.s_principal_unknown: "KDC_ERR_S_PRINCIPAL_UNKNOWN",
432 KerberosErrorCode.principal_not_unique: "KDC_ERR_PRINCIPAL_NOT_UNIQUE",
433 KerberosErrorCode.null_key: "KDC_ERR_NULL_KEY",
434 KerberosErrorCode.cannot_postdate: "KDC_ERR_CANNOT_POSTDATE",
435 KerberosErrorCode.never_valid: "KDC_ERR_NEVER_VALID",
436 KerberosErrorCode.policy: "KDC_ERR_POLICY",
437 KerberosErrorCode.badoption: "KDC_ERR_BADOPTION",
438 KerberosErrorCode.etype_nosupp: "KDC_ERR_ETYPE_NOSUPP",
439 KerberosErrorCode.sumtype_nosupp: "KDC_ERR_SUMTYPE_NOSUPP",
440 KerberosErrorCode.padata_type_nosupp: "KDC_ERR_PADATA_TYPE_NOSUPP",
441 KerberosErrorCode.trtype_nosupp: "KDC_ERR_TRTYPE_NOSUPP",
442 KerberosErrorCode.client_revoked: "KDC_ERR_CLIENT_REVOKED",
443 KerberosErrorCode.service_revoked: "KDC_ERR_SERVICE_REVOKED",
444 KerberosErrorCode.tgt_revoked: "KDC_ERR_TGT_REVOKED",
445 KerberosErrorCode.client_notyet: "KDC_ERR_CLIENT_NOTYET",
446 KerberosErrorCode.service_notyet: "KDC_ERR_SERVICE_NOTYET",
447 KerberosErrorCode.key_expired: "KDC_ERR_KEY_EXPIRED",
448 KerberosErrorCode.preauth_failed: "KDC_ERR_PREAUTH_FAILED",
449 KerberosErrorCode.preauth_required: "KDC_ERR_PREAUTH_REQUIRED",
450 KerberosErrorCode.server_nomatch: "KDC_ERR_SERVER_NOMATCH",
451 KerberosErrorCode.must_use_user2user: "KDC_ERR_MUST_USE_USER2USER",
452 KerberosErrorCode.path_not_accepted: "KDC_ERR_PATH_NOT_ACCEPTED",
453 KerberosErrorCode.kdc_svc_unavailable: "KDC_ERR_SVC_UNAVAILABLE",
454 KerberosErrorCode.ap_bad_integrity: "KRB_AP_ERR_BAD_INTEGRITY",
455 KerberosErrorCode.ap_txt_expired: "KRB_AP_ERR_TKT_EXPIRED",
456 KerberosErrorCode.ap_tkt_nyv: "KRB_AP_ERR_TKT_NYV",
457 KerberosErrorCode.ap_repeat: "KRB_AP_ERR_REPEAT",
458 KerberosErrorCode.ap_not_use: "KRB_AP_ERR_NOT_US",
459 KerberosErrorCode.ap_badmatch: "KRB_AP_ERR_BADMATCH",
460 KerberosErrorCode.ap_skew: "KRB_AP_ERR_SKEW",
461 KerberosErrorCode.ap_badaddr: "KRB_AP_ERR_BADADDR",
462 KerberosErrorCode.ap_badversion: "KRB_AP_ERR_BADVERSION",
463 KerberosErrorCode.ap_msg_type: "KRB_AP_ERR_MSG_TYPE",
464 KerberosErrorCode.ap_modified: "KRB_AP_ERR_MODIFIED",
465 KerberosErrorCode.ap_badorder: "KRB_AP_ERR_BADORDER",
466 KerberosErrorCode.ap_badkeyver: "KRB_AP_ERR_BADKEYVER",
467 KerberosErrorCode.ap_nokey: "KRB_AP_ERR_NOKEY",
468 KerberosErrorCode.ap_mut_fail: "KRB_AP_ERR_MUT_FAIL",
469 KerberosErrorCode.ap_baddirection: "KRB_AP_ERR_BADDIRECTION",
470 KerberosErrorCode.ap_method: "KRB_AP_ERR_METHOD",
471 KerberosErrorCode.ap_badseq: "KRB_AP_ERR_BADSEQ",
472 KerberosErrorCode.ap_inapp_cksum: "KRB_AP_ERR_INAPP_CKSUM",
473 KerberosErrorCode.ap_path_not_accepted: "KRB_AP_PATH_NOT_ACCEPTED",
474 KerberosErrorCode.response_too_big: "KRB_ERR_RESPONSE_TOO_BIG",
475 KerberosErrorCode.generic: "KRB_ERR_GENERIC",
476 KerberosErrorCode.field_toolong: "KRB_ERR_FIELD_TOOLONG",
477 KerberosErrorCode.kdc_client_not_trusted: "KDC_ERROR_CLIENT_NOT_TRUSTED",
478 KerberosErrorCode.kdc_not_trusted: "KDC_ERROR_KDC_NOT_TRUSTED",
479 KerberosErrorCode.kdc_invalid_sig: "KDC_ERROR_INVALID_SIG",
480 KerberosErrorCode.kdc_key_too_weak: "KDC_ERR_KEY_TOO_WEAK",
481 KerberosErrorCode.kdc_certificate_mismatch: "KDC_ERR_CERTIFICATE_MISMATCH",
482 KerberosErrorCode.ap_no_tgt: "KRB_AP_ERR_NO_TGT",
483 KerberosErrorCode.kdc_wrong_realm: "KDC_ERR_WRONG_REALM",
484 KerberosErrorCode.ap_user_to_user_required: "KRB_AP_ERR_USER_TO_USER_REQUIRED",
485 KerberosErrorCode.kdc_cant_verify_certificate: "KDC_ERR_CANT_VERIFY_CERTIFICATE",
486 KerberosErrorCode.kdc_invalid_certificate: "KDC_ERR_INVALID_CERTIFICATE",
487 KerberosErrorCode.kdc_revoked_certificate: "KDC_ERR_REVOKED_CERTIFICATE",
488 KerberosErrorCode.kdc_revocation_status_unknown: "KDC_ERR_REVOCATION_STATUS_UNKNOWN",
489 KerberosErrorCode.kdc_revocation_status_unavailable: "KDC_ERR_REVOCATION_STATUS_UNAVAILABLE",
490 KerberosErrorCode.kdc_client_name_mismatch: "KDC_ERR_CLIENT_NAME_MISMATCH",
491 KerberosErrorCode.kdc_name_mismatch: "KDC_ERR_KDC_NAME_MISMATCH",
492 }
493
494
495 # https://www.rfc-editor.org/rfc/rfc4120#section-5.10
496 class KerberosMessageType(enum.IntEnum):
497 unknown = 0
498 as_req = 10
499 as_rep = 11
500 tgs_req = 12
501 tgs_rep = 13
502 ap_req = 14
503 ap_rep = 15
504 error = 30
505
506 @classmethod
507 def native_labels(cls) -> typing.Dict["KerberosMessageType", str]:
508 return {
509 KerberosMessageType.unknown: "UNKNOWN",
510 KerberosMessageType.as_req: "AS-REQ",
511 KerberosMessageType.as_rep: "AS-REP",
512 KerberosMessageType.tgs_req: "TGS-REQ",
513 KerberosMessageType.tgs_rep: "TGS-REP",
514 KerberosMessageType.ap_req: "AP-REQ",
515 KerberosMessageType.ap_rep: "AP-REP",
516 KerberosMessageType.error: "KRB-ERROR",
517 }
518
519
520 # https://www.iana.org/assignments/kerberos-parameters/kerberos-parameters.xhtml
521 class KerberosPADataType(enum.IntEnum):
522 tgs_req = 1
523 enc_timestamp = 2
524 pw_salt = 3
525 reserved = 4
526 enc_unix_time = 5
527 sandia_secureid = 6
528 sesame = 7
529 osf_dce = 8
530 cybersafe_secureid = 9
531 afs3_salt = 10
532 etype_info = 11
533 sam_challenge = 12
534 sam_response = 13
535 pk_as_req_old = 14
536 pk_as_rep_old = 15
537 pk_as_req = 16
538 pk_as_rep = 17
539 pk_ocsp_response = 18
540 etype_info2 = 19
541 use_specified_kvno = 20
542 svr_referral_info = 20
543 sam_redirect = 21
544 get_from_typed_data = 22
545 td_padata = 22
546 sam_etype_info = 23
547 alt_princ = 24
548 server_referral = 25
549 sam_challenge2 = 30
550 sam_response2 = 31
551 extra_tgt = 41
552 td_pkinit_cms_certificates = 101
553 td_krb_principal = 102
554 td_krb_realm = 103
555 td_trusted_certifiers = 104
556 td_certificate_index = 105
557 td_app_defined_error = 106
558 td_req_nonce = 107
559 td_req_seq = 108
560 td_dh_parameters = 109
561 td_cms_digest_algorithms = 111
562 td_cert_digest_algorithms = 112
563 pac_request = 128
564 for_user = 128
565 for_x509_user = 130
566 for_check_dups = 131
567 as_checksum = 132
568 fx_cookie = 133
569 authentication_set = 134
570 auth_set_selected = 165
571 fx_fast = 136
572 fx_error = 137
573 encrypted_challenge = 138
574 otp_challenge = 141
575 otp_request = 142
576 otp_confirm = 143
577 otp_pin_change = 144
578 epak_as_req = 145
579 epak_as_rep = 146
580 pkinit_kx = 147
581 pku2u_name = 148
582 enc_pa_rep = 149
583 as_freshness = 150
584 spake = 151
585 kerb_key_list_req = 161
586 kerb_key_list_rep = 162
587 supported_etypes = 165
588 extended_error = 166
589 pac_options = 167
590
591 @classmethod
592 def native_labels(cls) -> typing.Dict["KerberosPADataType", str]:
593 return {
594 KerberosPADataType.tgs_req: "PA-TGS-REQ",
595 KerberosPADataType.enc_timestamp: "PA-ENC-TIMESTAMP",
596 KerberosPADataType.pw_salt: "PA-PW-SALT",
597 KerberosPADataType.reserved: "reserved",
598 KerberosPADataType.enc_unix_time: "PA-ENC-UNIX-TIME",
599 KerberosPADataType.sandia_secureid: "PA-SANDIA-SECUREID",
600 KerberosPADataType.sesame: "PA-SESAME",
601 KerberosPADataType.osf_dce: "PA-OSF-DCE",
602 KerberosPADataType.cybersafe_secureid: "PA-CYBERSAFE-SECUREID",
603 KerberosPADataType.afs3_salt: "PA-AFS3-SALT",
604 KerberosPADataType.etype_info: "PA-ETYPE-INFO",
605 KerberosPADataType.sam_challenge: "PA-SAM-CHALLENGE",
606 KerberosPADataType.sam_response: "PA-SAM-RESPONSE",
607 KerberosPADataType.pk_as_req_old: "PA-PK-AS-REQ_OLD",
608 KerberosPADataType.pk_as_rep_old: "PA-PK-AS-REP_OLD",
609 KerberosPADataType.pk_as_req: "PA-PK-AS-REQ",
610 KerberosPADataType.pk_as_rep: "PA-PK-AS-REP",
611 KerberosPADataType.pk_ocsp_response: "PA-PK-OCSP-RESPONSE",
612 KerberosPADataType.etype_info2: "PA-ETYPE-INFO2",
613 KerberosPADataType.use_specified_kvno: "PA-USE-SPECIFIED-KVNO or PA-SVR-REFERRAL-INFO",
614 KerberosPADataType.sam_redirect: "PA-SAM-REDIRECT",
615 KerberosPADataType.get_from_typed_data: "PA-GET-FROM-TYPED-DATA",
616 KerberosPADataType.td_padata: "TD-PADATA",
617 KerberosPADataType.sam_etype_info: "PA-SAM-ETYPE-INFO",
618 KerberosPADataType.alt_princ: "PA-ALT-PRINC",
619 KerberosPADataType.server_referral: "PA-SERVER-REFERRAL",
620 KerberosPADataType.sam_challenge2: "PA-SAM-CHALLENGE2",
621 KerberosPADataType.sam_response2: "PA-SAM-RESPONSE2",
622 KerberosPADataType.extra_tgt: "PA-EXTRA-TGT",
623 KerberosPADataType.td_pkinit_cms_certificates: "TD-PKINIT-CMS-CERTIFICATES",
624 KerberosPADataType.td_krb_principal: "TD-KRB-PRINCIPAL",
625 KerberosPADataType.td_krb_realm: "TD-KRB-REALM",
626 KerberosPADataType.td_trusted_certifiers: "TD-TRUSTED-CERTIFIERS",
627 KerberosPADataType.td_certificate_index: "TD-CERTIFICATE-INDEX",
628 KerberosPADataType.td_app_defined_error: "TD-APP-DEFINED-ERROR",
629 KerberosPADataType.td_req_nonce: "TD-REQ-NONCE",
630 KerberosPADataType.td_req_seq: "TD-REQ-SEQ",
631 KerberosPADataType.td_dh_parameters: "TD_DH_PARAMETERS",
632 KerberosPADataType.td_cms_digest_algorithms: "TD-CMS-DIGEST-ALGORITHMS",
633 KerberosPADataType.td_cert_digest_algorithms: "TD-CERT-DIGEST-ALGORITHMS",
634 KerberosPADataType.pac_request: "PA-PAC-REQUEST",
635 KerberosPADataType.for_user: "PA-FOR_USER",
636 KerberosPADataType.for_x509_user: "PA-FOR-X509-USER",
637 KerberosPADataType.for_check_dups: "PA-FOR-CHECK_DUPS",
638 KerberosPADataType.as_checksum: "PA-AS-CHECKSUM",
639 KerberosPADataType.fx_cookie: "PA-FX-COOKIE",
640 KerberosPADataType.authentication_set: "PA-AUTHENTICATION-SET",
641 KerberosPADataType.auth_set_selected: "PA-AUTH-SET-SELECTED",
642 KerberosPADataType.fx_fast: "PA-FX-FAST",
643 KerberosPADataType.fx_error: "PA-FX-ERROR",
644 KerberosPADataType.encrypted_challenge: "PA-ENCRYPTED-CHALLENGE",
645 KerberosPADataType.otp_challenge: "PA-OTP-CHALLENGE",
646 KerberosPADataType.otp_request: "PA-OTP-REQUEST",
647 KerberosPADataType.otp_confirm: "PA-OTP-CONFIRM",
648 KerberosPADataType.otp_pin_change: "PA-OTP-PIN-CHANGE",
649 KerberosPADataType.epak_as_req: "PA-EPAK-AS-REQ",
650 KerberosPADataType.epak_as_rep: "PA-EPAK-AS-REP",
651 KerberosPADataType.pkinit_kx: "PA_PKINIT_KX",
652 KerberosPADataType.pku2u_name: "PA_PKU2U_NAME",
653 KerberosPADataType.enc_pa_rep: "PA-REQ-ENC-PA-REP",
654 KerberosPADataType.as_freshness: "PA_AS_FRESHNESS",
655 KerberosPADataType.spake: "PA-SPAKE",
656 KerberosPADataType.kerb_key_list_req: "KERB-KEY-LIST-REQ",
657 KerberosPADataType.kerb_key_list_rep: "KERB-KEY-LIST-REP",
658 KerberosPADataType.supported_etypes: "PA-SUPPORTED-ETYPES",
659 KerberosPADataType.extended_error: "PA-EXTENDED_ERROR",
660 KerberosPADataType.pac_options: "PA-PAC-OPTIONS",
661 }
662
663
664 # https://www.rfc-editor.org/rfc/rfc4120#section-6.2
665 class KerberosPrincipalNameType(enum.IntEnum):
666 unknown = 0
667 principal = 1
668 srv_inst = 2
669 srv_hst = 3
670 srv_xhst = 4
671 uid = 5
672 x500_principal = 6
673 smtp_name = 7
674 enterprise = 10
675
676 @classmethod
677 def native_labels(cls) -> typing.Dict["KerberosPrincipalNameType", str]:
678 return {
679 KerberosPrincipalNameType.unknown: "NT-UNKNOWN",
680 KerberosPrincipalNameType.principal: "NT-PRINCIPAL",
681 KerberosPrincipalNameType.srv_inst: "NT-SRV-INST",
682 KerberosPrincipalNameType.srv_hst: "NT-SRV-HST",
683 KerberosPrincipalNameType.srv_xhst: "NT-SRV-XHST",
684 KerberosPrincipalNameType.uid: "NT-UID",
685 KerberosPrincipalNameType.x500_principal: "NT-X500-PRINCIPAL",
686 KerberosPrincipalNameType.smtp_name: "NT-SMTP-NAME",
687 KerberosPrincipalNameType.enterprise: "NT-ENTERPRISE",
688 }
689
690
691 # https://www.rfc-editor.org/rfc/rfc4120#section-7.5.3
692 class KerberosHostAddressType(enum.IntEnum):
693 ipv4 = 2
694 directional = 3
695 chaos_net = 5
696 xns = 6
697 iso = 7
698 decnet_phase_iv = 12
699 apple_talk_ddp = 16
700 netbios = 20
701 ipv6 = 26
702
703 @classmethod
704 def native_labels(cls) -> typing.Dict["KerberosHostAddressType", str]:
705 return {
706 KerberosHostAddressType.ipv4: "IPv4",
707 KerberosHostAddressType.directional: "Directional",
708 KerberosHostAddressType.chaos_net: "ChaosNet",
709 KerberosHostAddressType.xns: "XNS",
710 KerberosHostAddressType.iso: "ISO",
711 KerberosHostAddressType.decnet_phase_iv: "DECNET Phase IV",
712 KerberosHostAddressType.apple_talk_ddp: "AppleTalk DDP",
713 KerberosHostAddressType.netbios: "NetBios",
714 KerberosHostAddressType.ipv6: "IPv6",
715 }
716
717
718 class ParseType(enum.IntEnum):
719 default = 0
720 enum = 1
721 flags = 2
722 datetime = 3
723 text = 4
724 bytes = 5
725 principal_name = 6
726 host_address = 7
727 token = 8
728
729
730 class _KerberosMsgType(type):
731 __registry: typing.Dict[int, typing.Dict[int, "_KerberosMsgType"]] = {}
732
733 def __init__(
734 cls,
735 *args: typing.Any,
736 **kwargs: typing.Any,
737 ) -> None:
738 pvno = getattr(cls, "PVNO", 0)
739
740 if pvno not in cls.__registry:
741 cls.__registry[pvno] = {}
742
743 msg_type = getattr(cls, "MESSAGE_TYPE", None)
744 if msg_type is not None:
745 cls.__registry[pvno][msg_type] = cls
746
747 def __call__(
748 cls,
749 sequence: typing.Dict[int, ASN1Value],
750 ) -> "_KerberosMsgType":
751 # The KrbAsReq msg starts at 1 not 0, so do a check for that.
752 pvno_idx = 0
753 if 0 not in sequence:
754 pvno_idx = 1
755
756 pvno = unpack_asn1_integer(sequence[pvno_idx])
757 message_type = unpack_asn1_integer(sequence[pvno_idx + 1])
758 new_cls = cls.__registry[pvno].get(message_type, cls)
759 return super(_KerberosMsgType, new_cls).__call__(sequence)
760
761
762 class KerberosV5Msg(metaclass=_KerberosMsgType):
763
764 MESSAGE_TYPE = KerberosMessageType.unknown
765 PVNO = 5
766
767 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
768 # This is only used if decoding an unknown Kerberos message type.
769 self.sequence = sequence
770
771 @staticmethod
772 def unpack(value: typing.Union[ASN1Value, bytes]) -> "KerberosV5Msg":
773 msg_sequence = unpack_asn1_tagged_sequence(value)
774 return KerberosV5Msg(msg_sequence)
775
776
777 class KrbAsReq(KerberosV5Msg):
778 """The KRB_AS_REQ message.
779
780 The KRB_AS_REQ message is used when the client wishes to retrieve a the initial ticket for a service. The
781 KRB_TGS_REQ message is identical except for the tag and msg-type is used when retrieving additional tickets for a
782 service.
783
784 The ASN.1 definition for the KDC-REQ structure is defined in `RFC 4120 5.4.1`_::
785
786 KDC-REQ ::= SEQUENCE {
787 -- NOTE: first tag is [1], not [0]
788 pvno [1] INTEGER (5) ,
789 msg-type [2] INTEGER (10 -- AS -- | 12 -- TGS --),
790 padata [3] SEQUENCE OF PA-DATA OPTIONAL
791 -- NOTE: not empty --,
792 req-body [4] KDC-REQ-BODY
793 }
794
795 Args:
796 sequence: The ASN.1 sequence value as a dict to unpack.
797
798 Attributes:
799 padata (PAData): The pre-authentication data.
800 req_body (KdcReqBody): The body of the request.
801
802 .. _RFC 4120 5.4.1:
803 https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1
804 """
805
806 MESSAGE_TYPE = KerberosMessageType.as_req
807
808 PARSE_MAP = [
809 ("pvno", "PVNO", ParseType.default),
810 ("msg-type", "MESSAGE_TYPE", ParseType.enum),
811 ("padata", "padata", ParseType.token),
812 ("req-body", "req_body", ParseType.token),
813 ]
814
815 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
816 def unpack_padata(value: typing.Union[ASN1Value, bytes]) -> typing.List:
817 return [PAData.unpack(p) for p in unpack_asn1_sequence(value)]
818
819 self.padata = get_sequence_value(sequence, 3, "KDC-REQ", "pa-data", unpack_padata)
820 self.req_body = get_sequence_value(sequence, 4, "KDC-REQ", "req-body", KdcReqBody.unpack)
821
822
823 class KrbAsRep(KerberosV5Msg):
824 """The KRB_AS_REP message.
825
826 The KRB_AS_REP message is used for a reply from the KDC to a KRB_AS_REQ message. The KRB_TGS_REP message is
827 identical except for the tag and msg-type.
828
829 The ASN.1 definition for the KDC-REP structure is defined in `RFC 4120 5.4.2`_::
830
831 KDC-REP ::= SEQUENCE {
832 pvno [0] INTEGER (5),
833 msg-type [1] INTEGER (11 -- AS -- | 13 -- TGS --),
834 padata [2] SEQUENCE OF PA-DATA OPTIONAL
835 -- NOTE: not empty --,
836 crealm [3] Realm,
837 cname [4] PrincipalName,
838 ticket [5] Ticket,
839 enc-part [6] EncryptedData
840 -- EncASRepPart or EncTGSRepPart,
841 -- as appropriate
842 }
843
844 Args:
845 sequence: The ASN.1 sequence value as a dict to unpack.
846
847 Attributes:
848 padata (PAData): The pre-authentication data.
849 crealm (bytes): The client realm.
850 cname (PrincipalName): The client principal name.
851 ticket (Ticket): The newly issued ticket.
852 enc_part (EncryptedData): The encrypted part of the message.
853
854 .. _RFC 4120 5.4.2:
855 https://www.rfc-editor.org/rfc/rfc4120#section-5.4.2
856 """
857
858 MESSAGE_TYPE = KerberosMessageType.as_rep
859
860 PARSE_MAP = [
861 ("pvno", "PVNO", ParseType.default),
862 ("msg-type", "MESSAGE_TYPE", ParseType.enum),
863 ("padata", "padata", ParseType.token),
864 ("crealm", "crealm", ParseType.text),
865 ("cname", "cname", ParseType.principal_name),
866 ("ticket", "ticket", ParseType.token),
867 ("enc-part", "enc_part", ParseType.token),
868 ]
869
870 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
871 def unpack_padata(value: typing.Union[ASN1Value, bytes]) -> typing.List:
872 return [PAData.unpack(p) for p in unpack_asn1_sequence(value)]
873
874 self.padata = get_sequence_value(sequence, 2, "KDC-REP", "pa-data", unpack_padata)
875 self.crealm = get_sequence_value(sequence, 3, "KDC-REP", "crealm", unpack_asn1_general_string)
876 self.cname = get_sequence_value(sequence, 4, "KDC-REP", "cname", unpack_principal_name)
877 self.ticket = get_sequence_value(sequence, 5, "KDC-REP", "ticket", Ticket.unpack)
878 self.enc_part = get_sequence_value(sequence, 6, "KDC-REP", "enc-part", EncryptedData.unpack)
879
880
881 class KrbTgsReq(KrbAsReq):
882 """The KRB_TGS_REQ is the same as KRB_AS_REQ but with a different MESSAGE_TYPE."""
883
884 MESSAGE_TYPE = KerberosMessageType.tgs_req
885
886
887 class KrbTgsRep(KrbAsRep):
888 """The KRB_TGS_REP is the same as KRB_AS_REP but with a different MESSAGE_TYPE."""
889
890 MESSAGE_TYPE = KerberosMessageType.tgs_rep
891
892
893 class KrbApReq(KerberosV5Msg):
894 """The KRB_AP_REQ message.
895
896 The KRB_AP_REQ message contains is used to authenticate the initiator to an acceptor.
897
898 The ASN.1 definition for the KRB_AP_REQ structure is defined in `RFC 4120 5.5.1`_::
899
900 AP-REQ ::= [APPLICATION 14] SEQUENCE {
901 pvno [0] INTEGER (5),
902 msg-type [1] INTEGER (14),
903 ap-options [2] APOptions,
904 ticket [3] Ticket,
905 authenticator [4] EncryptedData -- Authenticator
906 }
907
908 Args:
909 sequence: The ASN.1 sequence value as a dict to unpack.
910
911 Attributes:
912 ap_options (KerberosAPOptions): Options related to the AP request.
913 ticket (Ticket): The ticket authenticating the client to the server.
914 authenticator (EncryptedData): The encrypted authenticator.
915
916 .. _RFC 4120 5.5.1:
917 https://www.rfc-editor.org/rfc/rfc4120#section-5.5.1
918 """
919
920 MESSAGE_TYPE = KerberosMessageType.ap_req
921
922 PARSE_MAP = [
923 ("pvno", "PVNO", ParseType.default),
924 ("msg-type", "MESSAGE_TYPE", ParseType.enum),
925 ("ap-options", "ap_options", ParseType.flags),
926 ("ticket", "ticket", ParseType.token),
927 ("authenticator", "authenticator", ParseType.token),
928 ]
929
930 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
931 raw_ap_options = get_sequence_value(sequence, 2, "AP-REQ", "ap-options", unpack_asn1_bit_string)
932 ap_options = KerberosAPOptions(struct.unpack("<I", raw_ap_options)[0])
933
934 self.ap_options = ap_options
935 self.ticket = get_sequence_value(sequence, 3, "AP-REQ", "ticket", Ticket.unpack)
936 self.authenticator = get_sequence_value(sequence, 4, "AP-REQ", "authenticator", EncryptedData.unpack)
937
938
939 class KrbApRep(KerberosV5Msg):
940 """The KRB_AP_REP message.
941
942 The KRB_AP_REP is a response to an application request `KRB_AP_REQ`.
943
944 The ASN.1 definition for the KRB_AP_REP structure is defined in `RFC 4120 5.5.2`_::
945
946 AP-REP ::= [APPLICATION 15] SEQUENCE {
947 pvno [0] INTEGER (5),
948 msg-type [1] INTEGER (15),
949 enc-part [2] EncryptedData -- EncAPRepPart
950 }
951
952 Args:
953 sequence: The ASN.1 sequence value as a dict to unpack.
954
955 Attributes:
956 enc_part (EncryptedData): The encrypted authenticator.
957
958 .. _RFC 4120 5.5.2:
959 https://www.rfc-editor.org/rfc/rfc4120#section-5.5.2
960 """
961
962 MESSAGE_TYPE = KerberosMessageType.ap_rep
963
964 PARSE_MAP = [
965 ("pvno", "PVNO", ParseType.default),
966 ("msg-type", "MESSAGE_TYPE", ParseType.enum),
967 ("enc-part", "enc_part", ParseType.token),
968 ]
969
970 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
971 self.enc_part = get_sequence_value(sequence, 2, "AP-REP", "enc-part", EncryptedData.unpack)
972
973
974 class KrbError(KerberosV5Msg):
975 """The KRB_ERROR message.
976
977 The KRB_ERROR is a message sent in the occurrence of an error.
978
979 The ASN.1 definition for the KRB_ERROR structure is defined in `RFC 4120 5.9.1`_::
980
981 KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
982 pvno [0] INTEGER (5),
983 msg-type [1] INTEGER (30),
984 ctime [2] KerberosTime OPTIONAL,
985 cusec [3] Microseconds OPTIONAL,
986 stime [4] KerberosTime,
987 susec [5] Microseconds,
988 error-code [6] Int32,
989 crealm [7] Realm OPTIONAL,
990 cname [8] PrincipalName OPTIONAL,
991 realm [9] Realm -- service realm --,
992 sname [10] PrincipalName -- service name --,
993 e-text [11] KerberosString OPTIONAL,
994 e-data [12] OCTET STRING OPTIONAL
995 }
996
997 Args:
998 sequence: The ASN.1 sequence value as a dict to unpack.
999
1000 Attributes:
1001 ctime (datetime.datetime): The current time on the client's host.
1002 cusec (int): The microsecond part of the client's timestamp.
1003 stime (datetime.datetime): The current time of the server.
1004 susec (int): The microsecond part of the server's timestamp.
1005 error_code (KerberosErrorCode): THe error code returned by the kerberos when a request fails.
1006 crealm (bytes): The realm that issues a ticket.
1007 cname (PrincipalName): The principal name in the ticket.
1008 realm (bytes): The service realm.
1009 sname (PrincipalName): The service name.
1010 e_text (bytes): Additional text to explain the error code.
1011 e_data (bytes): Additional data about the error.
1012
1013 .. _RFC 4120 5.9.1:
1014 https://www.rfc-editor.org/rfc/rfc4120#section-5.9.1
1015 """
1016
1017 MESSAGE_TYPE = KerberosMessageType.error
1018
1019 PARSE_MAP = [
1020 ("pvno", "PVNO", ParseType.default),
1021 ("msg-type", "MESSAGE_TYPE", ParseType.enum),
1022 ("ctime", "ctime", ParseType.datetime),
1023 ("cusec", "cusec", ParseType.default),
1024 ("stime", "stime", ParseType.datetime),
1025 ("susec", "susec", ParseType.default),
1026 ("error-code", "error_code", ParseType.enum),
1027 ("crealm", "crealm", ParseType.text),
1028 ("cname", "cname", ParseType.principal_name),
1029 ("realm", "realm", ParseType.text),
1030 ("sname", "sname", ParseType.principal_name),
1031 ("e-text", "e_text", ParseType.text),
1032 ("e-data", "e_data", ParseType.bytes),
1033 ]
1034
1035 def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
1036 self.ctime = get_sequence_value(sequence, 2, "KRB-ERROR", "ctime", unpack_asn1_generalized_time)
1037 self.cusec = get_sequence_value(sequence, 3, "KRB-ERROR", "cusec", unpack_asn1_integer)
1038 self.stime = get_sequence_value(sequence, 4, "KRB-ERROR", "stime", unpack_asn1_generalized_time)
1039 self.susec = get_sequence_value(sequence, 5, "KRB-ERROR", "susec", unpack_asn1_integer)
1040 self.error_code = KerberosErrorCode(
1041 get_sequence_value(sequence, 6, "KRB-ERROR", "error-code", unpack_asn1_integer)
1042 )
1043 self.crealm = get_sequence_value(sequence, 7, "KRB-ERROR", "crealm", unpack_asn1_general_string)
1044 self.cname = get_sequence_value(sequence, 8, "KRB-ERROR", "cname", unpack_principal_name)
1045 self.realm = get_sequence_value(sequence, 9, "KRB-ERROR", "realm", unpack_asn1_general_string)
1046 self.sname = get_sequence_value(sequence, 10, "KRB-ERROR", "realm", unpack_principal_name)
1047 self.e_text = get_sequence_value(sequence, 11, "KRB-ERROR", "e-text", unpack_asn1_general_string)
1048 self.e_data = get_sequence_value(sequence, 12, "KRB-ERROR", "e-data", unpack_asn1_octet_string)
1049
1050
1051 class PAData:
1052 """Kerberos PA-DATA.
1053
1054 The ASN.1 definition for the PA-DATA structure is defined in `RFC 4120 5.2.7`_::
1055
1056 PA-DATA ::= SEQUENCE {
1057 -- NOTE: first tag is [1], not [0]
1058 padata-type [1] Int32,
1059 padata-value [2] OCTET STRING -- might be encoded AP-REQ
1060 }
1061
1062 Args:
1063 data_type: Indicates the type of data the value represents.
1064 value: The PAData value, usually the DER encoding of another message.
1065
1066 Attributes:
1067 data_type (Union[int, KerberosPADataType]): See args.
1068 b_value (bytes): The raw bytes of padata-value, use `value` to get a structured object of these bytes if
1069 available.
1070
1071 .. RFC 4120 5.2.7:
1072 https://www.rfc-editor.org/rfc/rfc4120#section-5.2.7
1073 """
1074
1075 PARSE_MAP = [
1076 ("padata-type", "data_type", ParseType.enum),
1077 ("padata-value", "value", ParseType.token),
1078 ]
1079
1080 def __init__(self, data_type: typing.Union[int, KerberosPADataType], value: bytes) -> None:
1081 self.data_type = data_type
1082 self.b_value = value
1083
1084 @property
1085 def value(self) -> typing.Any:
1086 if self.data_type == KerberosPADataType.tgs_req:
1087 # Special edge case for this PA type due to how the messages require the data in unpack
1088 return KrbTgsReq.unpack(unpack_asn1(unpack_asn1(self.b_value)[0].b_data)[0])
1089
1090 data_type_map = {
1091 int(KerberosPADataType.enc_timestamp): (EncryptedData.unpack, False),
1092 int(KerberosPADataType.etype_info2): (PAETypeInfo2.unpack, True),
1093 }
1094
1095 if self.data_type in data_type_map:
1096 unpack_func, is_sequence = data_type_map[int(self.data_type)]
1097 b_value = unpack_asn1(self.b_value)[0]
1098 if is_sequence:
1099 # Is a SEQUENCE OF (list of entries).
1100 return [unpack_func(v) for v in unpack_asn1_sequence(b_value)]
1101
1102 else:
1103 return unpack_func(b_value.b_data)
1104
1105 else:
1106 return self.b_value
1107
1108 @staticmethod
1109 def unpack(value: typing.Union[ASN1Value, bytes]) -> "PAData":
1110 sequence = unpack_asn1_tagged_sequence(value)
1111
1112 def unpack_data_type(value: typing.Union[ASN1Value, bytes]) -> typing.Union[KerberosPADataType, int]:
1113 int_val = unpack_asn1_integer(value)
1114
1115 try:
1116 return KerberosPADataType(int_val)
1117 except ValueError:
1118 return int_val
1119
1120 data_type = get_sequence_value(sequence, 1, "PA-DATA", "padata-type", unpack_data_type)
1121 pa_value = get_sequence_value(sequence, 2, "PA-DATA", "padata-value", unpack_asn1_octet_string)
1122
1123 return PAData(data_type, pa_value)
1124
1125
1126 class PAETypeInfo2:
1127 """Kerberos PA-ETYPE-INFO2 container.
1128
1129 The ASN.1 definition for the PA-ETYPE-INFO2 structure is defined in `RFC 4120 5.2.7.5`_::
1130
1131 ETYPE-INFO2-ENTRY ::= SEQUENCE {
1132 etype [0] Int32,
1133 salt [1] KerberosString OPTIONAL,
1134 s2kparams [2] OCTET STRING OPTIONAL
1135 }
1136
1137 Args:
1138 etype: The etype that defines the cipher used.
1139 salt: The used in the cipher associated with the cryptosystem.
1140 s2kparams: Extra params to be interpreted by the cipher associated with the cryptosystem.
1141
1142 Attributes:
1143 etype (KerberosEncryptionType): See args.
1144 salt (Optional[bytes]): See args.
1145 s2kparams (Optional[bytes]): See args.
1146
1147 .. RFC 4120 5.2.7.5:
1148 https://www.rfc-editor.org/rfc/rfc4120#section-5.2.7.5
1149 """
1150
1151 PARSE_MAP = [
1152 ("etype", "etype", ParseType.enum),
1153 ("salt", "salt", ParseType.bytes),
1154 ("s2kparams", "s2kparams", ParseType.bytes),
1155 ]
1156
1157 def __init__(
1158 self,
1159 etype: KerberosEncryptionType,
1160 salt: typing.Optional[bytes],
1161 s2kparams: typing.Optional[bytes],
1162 ) -> None:
1163 self.etype = etype
1164 self.salt = salt
1165 self.s2kparams = s2kparams
1166
1167 @staticmethod
1168 def unpack(value: typing.Union[ASN1Value, bytes]) -> "PAETypeInfo2":
1169 sequence = unpack_asn1_tagged_sequence(value)
1170
1171 etype = KerberosEncryptionType(get_sequence_value(sequence, 0, "PA-ETYPE-INFO2", "etype", unpack_asn1_integer))
1172 salt = get_sequence_value(sequence, 1, "ETYPE-INFO2-ENTRY", "salt", unpack_asn1_general_string)
1173 s2kparams = get_sequence_value(sequence, 2, "ETYPE-INFO2-ENTRY", "s2kparams", unpack_asn1_octet_string)
1174
1175 return PAETypeInfo2(etype, salt, s2kparams)
1176
1177
1178 class EncryptedData:
1179 """Kerberos EncryptedData container.
1180
1181 The ASN.1 definition for the EncryptedData structure is defined in `RFC 4120 5.2.9`_::
1182
1183 EncryptedData ::= SEQUENCE {
1184 etype [0] Int32 -- EncryptionType --,
1185 kvno [1] UInt32 OPTIONAL,
1186 cipher [2] OCTET STRING -- ciphertext
1187 }
1188
1189 Args:
1190 etype: The encryption algorithm that was used to encipher the cipher.
1191 kvno: The version number of the key under which data is encrypted. It is only present in messages encrypted
1192 under long lasting keys.
1193 cipher: The enciphered text.
1194
1195 Attributes:
1196 etype (KerberosEncryptionType): See args.
1197 kvno (Optional[int]): See args.
1198 cipher (bytes): See args.
1199
1200 .. RFC 4120 5.2.9:
1201 https://www.rfc-editor.org/rfc/rfc4120#section-5.2.9
1202 """
1203
1204 PARSE_MAP = [
1205 ("etype", "etype", ParseType.enum),
1206 ("kvno", "kvno", ParseType.default),
1207 ("cipher", "cipher", ParseType.bytes),
1208 ]
1209
1210 def __init__(self, etype: KerberosEncryptionType, kvno: typing.Optional[int], cipher: bytes) -> None:
1211 self.etype = etype
1212 self.kvno = kvno
1213 self.cipher = cipher
1214
1215 @staticmethod
1216 def unpack(value: typing.Union[bytes, ASN1Value]) -> "EncryptedData":
1217 sequence = unpack_asn1_tagged_sequence(value)
1218
1219 etype = KerberosEncryptionType(get_sequence_value(sequence, 0, "EncryptedData", "etype", unpack_asn1_integer))
1220 kvno = get_sequence_value(sequence, 1, "EncryptedData", "kvno", unpack_asn1_integer)
1221 cipher = get_sequence_value(sequence, 2, "EncryptedData", "cipher", unpack_asn1_octet_string)
1222
1223 return EncryptedData(etype, kvno, cipher)
1224
1225
1226 class Ticket:
1227 """Kerberos Ticket.
1228
1229 The ASN.1 definition for the Ticket structure is defined in `RFC 4120 5.3`_::
1230
1231 Ticket ::= [APPLICATION 1] SEQUENCE {
1232 tkt-vno [0] INTEGER (5),
1233 realm [1] Realm,
1234 sname [2] PrincipalName,
1235 enc-part [3] EncryptedData -- EncTicketPart
1236 }
1237
1238 Args:
1239 tkt_vno: The version number for the ticket format.
1240 realm: The realm that issued a ticket.
1241 sname: All the name components of the server's identity.
1242 enc_part: The encrypted part of the ticket, it is encrypted in the key shared by Kerberos and the end server.
1243
1244 Attributes:
1245 tkt_vno (int): See args.
1246 realm (bytes): See args.
1247 sname (List[PrincipalName]): See args.
1248 enc_part (EncryptedData): See args.
1249
1250 .. _RFC 4120 5.3:
1251 https://www.rfc-editor.org/rfc/rfc4120#section-5.3
1252 """
1253
1254 PARSE_MAP = [
1255 ("tkt-vno", "tkt_vno", ParseType.default),
1256 ("realm", "realm", ParseType.text),
1257 ("sname", "sname", ParseType.principal_name),
1258 ("enc-part", "enc_part", ParseType.token),
1259 ]
1260
1261 def __init__(
1262 self,
1263 tkt_vno: int,
1264 realm: bytes,
1265 sname: typing.List[PrincipalName],
1266 enc_part: EncryptedData,
1267 ) -> None:
1268 self.tkt_vno = tkt_vno
1269 self.realm = realm
1270 self.sname = sname
1271 self.enc_part = enc_part
1272
1273 @staticmethod
1274 def unpack(value: typing.Union[ASN1Value, bytes]) -> "Ticket":
1275 b_data = extract_asn1_tlv(value, TagClass.application, 1)
1276 sequence = unpack_asn1_tagged_sequence(unpack_asn1(b_data)[0])
1277
1278 tkt_vno = get_sequence_value(sequence, 0, "Ticket", "tkt-vno", unpack_asn1_integer)
1279 realm = get_sequence_value(sequence, 1, "Ticket", "realm", unpack_asn1_general_string)
1280 sname = get_sequence_value(sequence, 2, "Ticket", "sname", unpack_principal_name)
1281 enc_part = get_sequence_value(sequence, 3, "Ticket", "enc-part", EncryptedData.unpack)
1282
1283 return Ticket(tkt_vno, realm, sname, enc_part)
1284
1285
1286 class KdcReqBody:
1287 """The KRB_AS_REQ message.
1288
1289 The KRB_AS_REQ message is used when the client wishes to retrieve a the initial ticket for a service. The
1290 KRB_TGS_REQ message is identical except for the tag and msg-type is used when retrieving additional tickets for a
1291 service.
1292
1293 The ASN.1 definition for the KDC-REQ structure is defined in `RFC 4120 5.4.1`_::
1294
1295 KDC-REQ-BODY ::= SEQUENCE {
1296 kdc-options [0] KDCOptions,
1297 cname [1] PrincipalName OPTIONAL
1298 -- Used only in AS-REQ --,
1299 realm [2] Realm
1300 -- Server's realm
1301 -- Also client's in AS-REQ --,
1302 sname [3] PrincipalName OPTIONAL,
1303 from [4] KerberosTime OPTIONAL,
1304 till [5] KerberosTime,
1305 rtime [6] KerberosTime OPTIONAL,
1306 nonce [7] UInt32,
1307 etype [8] SEQUENCE OF Int32 -- EncryptionType
1308 -- in preference order --,
1309 addresses [9] HostAddresses OPTIONAL,
1310 enc-authorization-data [10] EncryptedData OPTIONAL
1311 -- AuthorizationData --,
1312 additional-tickets [11] SEQUENCE OF Ticket OPTIONAL
1313 -- NOTE: not empty
1314 }
1315
1316 Args:
1317 kdc_options: Flags desired by the client and other behaviour desired.
1318 cname: The client name.
1319 realm: The realm part of the server's principal.
1320 sname: The service name.
1321 postdated_from: When the requested ticket is to be posted from.
1322 postdated_till: The expiration date requested by the client.
1323 rtime: The requested renew-till time.
1324 nonce: Random number generated by the client.
1325 etype: The desired encryption algorithm to be used in priority order.
1326 addresses: Addresses from which the requested ticket is to be valid.
1327 enc_authorization_data: Encrypted authorization data.
1328 additional_tickets: Additional tickets to be optionally included in a request.
1329
1330 Attributes:
1331 kdc_options (int): See args.
1332 cname (Optional[PrincipalName]): See args.
1333 realm (bytes): See args.
1334 sname (PrincipalName): See args.
1335 postdated_from (Optional[datetime.datetime]): See args.
1336 postdated_till (datetime.datetime): See args.
1337 rtime (Optional[datetime.datetime]): See args.
1338 nonce (int): See args.
1339 etype (List[KerberosEncryptionType]): See args.
1340 addresses (Optional[List[HostAddress]]): See args.
1341 enc_authorization_data (Optional[EncryptedData]): See args.
1342 additional_tickets (Optional[Ticket]): See args.
1343
1344 .. _RFC 4120 5.4.1:
1345 https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1
1346 """
1347
1348 PARSE_MAP = [
1349 ("kdc-options", "kdc_options", (ParseType.flags, KerberosKDCOptions)),
1350 ("cname", "cname", ParseType.principal_name),
1351 ("realm", "realm", ParseType.text),
1352 ("sname", "sname", ParseType.principal_name),
1353 ("from", "postdated_from", ParseType.datetime),
1354 ("till", "postdated_till", ParseType.datetime),
1355 ("rtime", "rtime", ParseType.datetime),
1356 ("nonce", "nonce", ParseType.default),
1357 ("etype", "etype", ParseType.enum),
1358 ("addresses", "addresses", ParseType.host_address),
1359 ("enc-authorization-data", "enc_authorization_data", ParseType.token),
1360 ("additional-tickets", "additional_tickets", ParseType.token),
1361 ]
1362
1363 def __init__(
1364 self,
1365 kdc_options: int,
1366 cname: typing.Optional[PrincipalName],
1367 realm: bytes,
1368 sname: PrincipalName,
1369 postdated_from: typing.Optional[datetime.datetime],
1370 postdated_till: datetime.datetime,
1371 rtime: typing.Optional[datetime.datetime],
1372 nonce: int,
1373 etype: typing.List[KerberosEncryptionType],
1374 addresses: typing.Optional[typing.List[HostAddress]],
1375 enc_authorization_data: typing.Optional[EncryptedData],
1376 additional_tickets: typing.Optional[typing.List[Ticket]],
1377 ) -> None:
1378 self.kdc_options = kdc_options
1379 self.cname = cname
1380 self.realm = realm
1381 self.sname = sname
1382 self.postdated_from = postdated_from
1383 self.postdated_till = postdated_till
1384 self.rtime = rtime
1385 self.nonce = nonce
1386 self.etype = etype
1387 self.addresses = addresses
1388 self.enc_authorization_data = enc_authorization_data
1389 self.additional_tickets = additional_tickets
1390
1391 @staticmethod
1392 def unpack(value: typing.Union[ASN1Value, bytes]) -> "KdcReqBody":
1393 sequence = unpack_asn1_tagged_sequence(value)
1394
1395 def unpack_kdc_options(value: typing.Union[ASN1Value, bytes]) -> int:
1396 b_data = unpack_asn1_bit_string(value)
1397 return struct.unpack(">I", b_data)[0]
1398
1399 def unpack_etype(value: typing.Union[ASN1Value, bytes]) -> typing.List[KerberosEncryptionType]:
1400 return [KerberosEncryptionType(unpack_asn1_integer(e)) for e in unpack_asn1_sequence(value)]
1401
1402 def unpack_addresses(value: typing.Union[ASN1Value, bytes]) -> typing.List[HostAddress]:
1403 return [unpack_hostname(h) for h in unpack_asn1_sequence(value)]
1404
1405 def unpack_ticket(value: typing.Union[ASN1Value, bytes]) -> typing.List[Ticket]:
1406 return [Ticket.unpack(t) for t in unpack_asn1_sequence(value)]
1407
1408 kdc_options = get_sequence_value(sequence, 0, "KDC-REQ-BODY", "kdc-options", unpack_kdc_options)
1409 cname = get_sequence_value(sequence, 1, "KDC-REQ-BODY", "cname", unpack_principal_name)
1410 realm = get_sequence_value(sequence, 2, "KDC-REQ-BODY", "realm", unpack_asn1_general_string)
1411 sname = get_sequence_value(sequence, 3, "KDC-REQ-BODY", "sname", unpack_principal_name)
1412 postdated_from = get_sequence_value(sequence, 4, "KDC-REQ-BODY", "from", unpack_asn1_generalized_time)
1413 postdated_till = get_sequence_value(sequence, 5, "KDC-REQ-BODY", "till", unpack_asn1_generalized_time)
1414 rtime = get_sequence_value(sequence, 6, "KDC-REQ-BODY", "rtime", unpack_asn1_generalized_time)
1415 nonce = get_sequence_value(sequence, 7, "KDC-REQ-BODY", "nonce", unpack_asn1_integer)
1416 etype = get_sequence_value(sequence, 8, "KDC-REQ-BODY", "etype", unpack_etype)
1417 addresses = get_sequence_value(sequence, 9, "KDC-REQ-BODY", "addresses", unpack_addresses)
1418 enc_auth_data = get_sequence_value(sequence, 10, "KDC-REQ-BODY", "enc-authorization-data", EncryptedData.unpack)
1419 additional_tickets = get_sequence_value(sequence, 11, "KDC-REQ-BODY", "additional-tickets", unpack_ticket)
1420
1421 return KdcReqBody(
1422 kdc_options,
1423 cname,
1424 realm,
1425 sname,
1426 postdated_from,
1427 postdated_till,
1428 rtime,
1429 nonce,
1430 etype,
1431 addresses,
1432 enc_auth_data,
1433 additional_tickets,
1434 )