| 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 |
) |