Files
API-WINDNAS/env/lib/python3.12/site-packages/spnego/_kerberos.py

1434 lines
55 KiB
Python

# Copyright: (c) 2020, Jordan Borean (@jborean93) <jborean93@gmail.com>
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
"""Kerberos Messages
Various Kerberos message structures that is used by 'python -m spnego' to unpack raw ASN.1 values and print out a
pretty structure for end users. This code is not used in the actual spnego authentication processes and is just used
for debugging purposes.
"""
import base64
import collections
import datetime
import enum
import struct
import typing
from spnego._asn1 import (
ASN1Value,
TagClass,
extract_asn1_tlv,
get_sequence_value,
unpack_asn1,
unpack_asn1_bit_string,
unpack_asn1_general_string,
unpack_asn1_generalized_time,
unpack_asn1_integer,
unpack_asn1_octet_string,
unpack_asn1_sequence,
unpack_asn1_tagged_sequence,
)
from spnego._text import to_text
def _enum_labels(
value: typing.Union[int, str, enum.Enum],
enum_type: typing.Optional[typing.Type] = None,
) -> typing.Dict[int, str]:
"""Gets the human friendly labels of a known enum and what value they map to."""
def get_labels(v: typing.Any) -> typing.Dict[int, str]:
return typing.cast(typing.Dict[int, str], getattr(v, "native_labels", lambda: {})())
return get_labels(enum_type) if enum_type else get_labels(value)
def parse_enum(
value: typing.Union[int, str, enum.Enum],
enum_type: typing.Optional[typing.Type] = None,
) -> str:
"""Parses an IntEnum into a human representative object of that enum."""
enum_name = "UNKNOWN"
if isinstance(value, enum.Enum):
enum_name = value.name
labels = _enum_labels(value, enum_type)
value = value.value if isinstance(value, enum.Enum) else value
for v, name in labels.items():
if value == v:
enum_name = name
break
return "%s (%s)" % (enum_name, value)
def parse_flags(
value: typing.Union[int, enum.IntFlag],
enum_type: typing.Optional[typing.Type] = None,
) -> typing.Dict[str, typing.Any]:
"""Parses an IntFlag into each flag value that is set."""
raw_value = int(value)
flags = []
labels = _enum_labels(value, enum_type)
value = int(value)
for v, name in labels.items():
if value & v == v:
value &= ~v
flags.append("%s (%d)" % (name, v))
if value != 0:
flags.append("UNKNOWN (%d)" % value)
return {
"raw": raw_value,
"flags": flags,
}
def parse_kerberos_token(
token: typing.Union["KerberosV5Msg", "PAData", "PAETypeInfo2", "EncryptedData", "Ticket", "KdcReqBody"],
secret: typing.Optional[str] = None,
encoding: typing.Optional[str] = None,
) -> typing.Union[str, typing.Dict[str, typing.Any]]:
"""Parses a KerberosV5Msg object to a dict."""
text_encoding = encoding if encoding else "utf-8"
def parse_default(value: typing.Any) -> typing.Any:
return value
def parse_datetime(value: datetime.datetime) -> str:
return value.isoformat()
def parse_text(value: bytes) -> str:
return to_text(value, encoding=text_encoding, errors="replace")
def parse_bytes(value: bytes) -> str:
return base64.b16encode(value).decode()
def parse_principal_name(value: PrincipalName) -> typing.Dict[str, typing.Any]:
return {
"name-type": parse_enum(value.name_type),
"name-string": [parse_text(v) for v in value.value],
}
def parse_host_address(value: HostAddress) -> typing.Dict[str, typing.Any]:
return {
"addr-type": parse_enum(value.addr_type),
"address": parse_text(value.value),
}
def parse_token(value: typing.Any) -> typing.Union[str, typing.Dict[str, typing.Any]]:
return parse_kerberos_token(value, secret, text_encoding)
if isinstance(token, bytes):
return parse_bytes(token)
msg = {}
for name, attr_name, attr_type in getattr(token, "PARSE_MAP", {}):
attr_value = getattr(token, attr_name)
parse_args = []
if isinstance(attr_type, tuple):
parse_args.append(attr_type[1])
attr_type = attr_type[0]
parse_func: typing.Callable = { # type: ignore[assignment] # No idea why
ParseType.default: parse_default,
ParseType.enum: parse_enum,
ParseType.flags: parse_flags,
ParseType.datetime: parse_datetime,
ParseType.text: parse_text,
ParseType.bytes: parse_bytes,
ParseType.principal_name: parse_principal_name,
ParseType.host_address: parse_host_address,
ParseType.token: parse_token,
}[attr_type]
if attr_value is None:
parsed_value = None
elif isinstance(attr_value, list):
parsed_value = [parse_func(v, *parse_args) if v is not None else None for v in attr_value]
else:
parsed_value = parse_func(attr_value, *parse_args)
msg[name] = parsed_value
return msg
def unpack_hostname(value: typing.Union[bytes, ASN1Value]) -> "HostAddress":
"""Unpacks an ASN.1 value to a HostAddress."""
s = unpack_asn1_tagged_sequence(value)
name_type = KerberosHostAddressType(get_sequence_value(s, 0, "HostAddress", "addr-type", unpack_asn1_integer))
name = get_sequence_value(s, 1, "HostAddress", "address", unpack_asn1_octet_string)
return HostAddress(name_type, name)
def unpack_principal_name(value: typing.Union[bytes, ASN1Value]) -> "PrincipalName":
"""Unpacks an ASN.1 value to a PrincipalName."""
s = unpack_asn1_tagged_sequence(value)
name_type = KerberosPrincipalNameType(get_sequence_value(s, 0, "PrincipalName", "name-type", unpack_asn1_integer))
name = [
unpack_asn1_general_string(n)
for n in get_sequence_value(s, 1, "PrincipalName", "name-string", unpack_asn1_sequence)
]
return PrincipalName(name_type, name)
HostAddress = collections.namedtuple("HostAddress", ["addr_type", "value"])
"""Kerberos HostAddress and HostAddresses
A Kerberos Host Address ASN.1 definition is defined in `RFC 4120 5.2.5`_::
HostAddress ::= SEQUENCE {
addr-type [0] Int32,
address [1] OCTET STRING
}
Attributes:
addr_type (KerberosHostAddressType): The type of address that was encoded.
value (bytes): The address as a byte string.
.. _RFC 4120 5.2.5:
https://www.rfc-editor.org/rfc/rfc4120#section-5.2.5
"""
PrincipalName = collections.namedtuple("PrincipalName", ["name_type", "value"])
"""Kerberos Realm and PrincipalName
A Kerberos Principal Name ASN.1 definition is defined in `RFC 4120 5.2.2`_::
PrincipalName ::= SEQUENCE {
name-type [0] Int32,
name-string [1] SEQUENCE OF KerberosString
}
Attributes:
name_type (KerberosPrincipalNameType): The type of name the was encoded.
value (List[bytes]): Each component that forms the name.
.. _RFC 4120 5.2.2:
https://www.rfc-editor.org/rfc/rfc4120#section-5.2.2
"""
# https://www.rfc-editor.org/rfc/rfc4120#section-5.5.1 - ap-options
class KerberosAPOptions(enum.IntFlag):
mutual_required = 0x00000020
use_session_key = 0x00000040
reserved = 0x00000080
@classmethod
def native_labels(cls) -> typing.Dict["KerberosAPOptions", str]:
return {
KerberosAPOptions.mutual_required: "mutual-required",
KerberosAPOptions.use_session_key: "use-session-key",
KerberosAPOptions.reserved: "reserved",
}
# https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1 - KDCOptions
class KerberosKDCOptions(enum.IntFlag):
reserved = 0x80000000
forwardable = 0x40000000
forwarded = 0x20000000
proxiable = 0x10000000
proxy = 0x08000000
allow_postdate = 0x04000000
postdated = 0x02000000
unused7 = 0x01000000
renewable = 0x00800000
unused9 = 0x00400000
unused10 = 0x00200000
opt_hardware_auth = 0x00100000
unused12 = 0x00080000
unused13 = 0x00040000
constrained_delegation = 0x00020000
canonicalize = 0x00010000
request_anonymous = 0x00008000
unused17 = 0x00004000
unused18 = 0x00002000
unused19 = 0x00001000
unused20 = 0x00000800
unused21 = 0x00000400
unused22 = 0x00000200
unused23 = 0x00000100
unused24 = 0x00000080
unused25 = 0x00000040
disable_transited_check = 0x00000020
renewable_ok = 0x00000010
enc_tkt_in_skey = 0x00000008
unused29 = 0x00000004
renew = 0x00000002
validate = 0x00000001
@classmethod
def native_labels(cls) -> typing.Dict["KerberosKDCOptions", str]:
return {
KerberosKDCOptions.reserved: "reserved",
KerberosKDCOptions.forwardable: "forwardable",
KerberosKDCOptions.forwarded: "forwarded",
KerberosKDCOptions.proxiable: "proxiable",
KerberosKDCOptions.proxy: "proxy",
KerberosKDCOptions.allow_postdate: "allow-postdate",
KerberosKDCOptions.postdated: "postdated",
KerberosKDCOptions.unused7: "unused7",
KerberosKDCOptions.renewable: "renewable",
KerberosKDCOptions.unused9: "unused9",
KerberosKDCOptions.unused10: "unused10",
KerberosKDCOptions.opt_hardware_auth: "opt-hardware-auth",
KerberosKDCOptions.unused12: "unused12",
KerberosKDCOptions.unused13: "unused13",
KerberosKDCOptions.constrained_delegation: "constrained-delegation",
KerberosKDCOptions.canonicalize: "canonicalize",
KerberosKDCOptions.request_anonymous: "request-anonymous",
KerberosKDCOptions.unused17: "unused17",
KerberosKDCOptions.unused18: "unused18",
KerberosKDCOptions.unused19: "unused19",
KerberosKDCOptions.unused20: "unused20",
KerberosKDCOptions.unused21: "unused21",
KerberosKDCOptions.unused22: "unused22",
KerberosKDCOptions.unused23: "unused23",
KerberosKDCOptions.unused24: "unused24",
KerberosKDCOptions.unused25: "unused25",
KerberosKDCOptions.disable_transited_check: "disable-transited-check",
KerberosKDCOptions.renewable_ok: "renewable-ok",
KerberosKDCOptions.enc_tkt_in_skey: "enc-tkt-in-skey",
KerberosKDCOptions.unused29: "unused29",
KerberosKDCOptions.renew: "renew",
KerberosKDCOptions.validate: "validate",
}
# https://ldapwiki.com/wiki/Kerberos%20Encryption%20Types - etypes
class KerberosEncryptionType(enum.IntEnum):
des_cbc_crc = 0x0001
des_cbc_md4 = 0x0002
des_cbc_md5 = 0x0003
des_cbc_raw = 0x0004
des3_cbc_raw = 0x0006
des3_cbc_sha1 = 0x0010
aes128_cts_hmac_sha1_96 = 0x0011
aes256_cts_hmac_sha1_96 = 0x0012
aes128_cts_hmac_sha256_128 = 0x0013
aes256_cts_hmac_sha384_192 = 0x0014
rc4_hmac = 0x0017
rc4_hmac_exp = 0x0018
camellia128_cts_cmac = 0x0019
camellia256_cts_cmac = 0x001A
@classmethod
def native_labels(cls) -> typing.Dict["KerberosEncryptionType", str]:
return {
KerberosEncryptionType.des_cbc_crc: "DES_CBC_CRC",
KerberosEncryptionType.des_cbc_md4: "DES_CBC_MD4",
KerberosEncryptionType.des_cbc_md5: "DES_CBC_MD5",
KerberosEncryptionType.des_cbc_raw: "DES_CBC_RAW",
KerberosEncryptionType.des3_cbc_raw: "DES3_CBC_RAW",
KerberosEncryptionType.des3_cbc_sha1: "DES3_CBC_SHA1",
KerberosEncryptionType.aes128_cts_hmac_sha1_96: "AES128_CTS_HMAC_SHA1_96",
KerberosEncryptionType.aes256_cts_hmac_sha1_96: "AES256_CTS_HMAC_SHA1_96",
KerberosEncryptionType.aes128_cts_hmac_sha256_128: "AES128_CTS_HMAC_SHA256_128",
KerberosEncryptionType.aes256_cts_hmac_sha384_192: "AES256_CTS_HMAC_SHA384_192",
KerberosEncryptionType.rc4_hmac: "RC4_HMAC",
KerberosEncryptionType.rc4_hmac_exp: "RC4_HMAC_EXP",
KerberosEncryptionType.camellia128_cts_cmac: "CAMELLIA128_CTS_CMAC",
KerberosEncryptionType.camellia256_cts_cmac: "CAMELLIA256_CTS_CMAC",
}
# https://www.rfc-editor.org/rfc/rfc4120#section-7.5.9
class KerberosErrorCode(enum.IntEnum):
none = 0
name_exp = 1
service_exp = 2
bad_pvno = 3
c_old_mast_kvno = 4
s_old_mast_kvno = 5
c_principal_unknown = 6
s_principal_unknown = 7
principal_not_unique = 8
null_key = 9
cannot_postdate = 10
never_valid = 11
policy = 12
badoption = 13
etype_nosupp = 14
sumtype_nosupp = 15
padata_type_nosupp = 16
trtype_nosupp = 17
client_revoked = 18
service_revoked = 19
tgt_revoked = 20
client_notyet = 21
service_notyet = 22
key_expired = 23
preauth_failed = 24
preauth_required = 25
server_nomatch = 26
must_use_user2user = 27
path_not_accepted = 28
kdc_svc_unavailable = 29
ap_bad_integrity = 31
ap_txt_expired = 32
ap_tkt_nyv = 33
ap_repeat = 34
ap_not_use = 35
ap_badmatch = 36
ap_skew = 37
ap_badaddr = 38
ap_badversion = 39
ap_msg_type = 40
ap_modified = 41
ap_badorder = 42
ap_badkeyver = 44
ap_nokey = 45
ap_mut_fail = 46
ap_baddirection = 47
ap_method = 48
ap_badseq = 49
ap_inapp_cksum = 50
ap_path_not_accepted = 51
response_too_big = 52
generic = 60
field_toolong = 61
kdc_client_not_trusted = 62
kdc_not_trusted = 53
kdc_invalid_sig = 64
kdc_key_too_weak = 65
kdc_certificate_mismatch = 66
ap_no_tgt = 67
kdc_wrong_realm = 68
ap_user_to_user_required = 69
kdc_cant_verify_certificate = 70
kdc_invalid_certificate = 71
kdc_revoked_certificate = 72
kdc_revocation_status_unknown = 73
kdc_revocation_status_unavailable = 74
kdc_client_name_mismatch = 75
kdc_name_mismatch = 76
@classmethod
def native_labels(cls) -> typing.Dict["KerberosErrorCode", str]:
return {
KerberosErrorCode.none: "KDC_ERR_NONE",
KerberosErrorCode.name_exp: "KDC_ERR_NAME_EXP",
KerberosErrorCode.service_exp: "KDC_ERR_SERVICE_EXP",
KerberosErrorCode.bad_pvno: "KDC_ERR_BAD_PVNO",
KerberosErrorCode.c_old_mast_kvno: "KDC_ERR_C_OLD_MAST_KVNO",
KerberosErrorCode.s_old_mast_kvno: "KDC_ERR_S_OLD_MAST_KVNO",
KerberosErrorCode.c_principal_unknown: "KDC_ERR_C_PRINCIPAL_UNKNOWN",
KerberosErrorCode.s_principal_unknown: "KDC_ERR_S_PRINCIPAL_UNKNOWN",
KerberosErrorCode.principal_not_unique: "KDC_ERR_PRINCIPAL_NOT_UNIQUE",
KerberosErrorCode.null_key: "KDC_ERR_NULL_KEY",
KerberosErrorCode.cannot_postdate: "KDC_ERR_CANNOT_POSTDATE",
KerberosErrorCode.never_valid: "KDC_ERR_NEVER_VALID",
KerberosErrorCode.policy: "KDC_ERR_POLICY",
KerberosErrorCode.badoption: "KDC_ERR_BADOPTION",
KerberosErrorCode.etype_nosupp: "KDC_ERR_ETYPE_NOSUPP",
KerberosErrorCode.sumtype_nosupp: "KDC_ERR_SUMTYPE_NOSUPP",
KerberosErrorCode.padata_type_nosupp: "KDC_ERR_PADATA_TYPE_NOSUPP",
KerberosErrorCode.trtype_nosupp: "KDC_ERR_TRTYPE_NOSUPP",
KerberosErrorCode.client_revoked: "KDC_ERR_CLIENT_REVOKED",
KerberosErrorCode.service_revoked: "KDC_ERR_SERVICE_REVOKED",
KerberosErrorCode.tgt_revoked: "KDC_ERR_TGT_REVOKED",
KerberosErrorCode.client_notyet: "KDC_ERR_CLIENT_NOTYET",
KerberosErrorCode.service_notyet: "KDC_ERR_SERVICE_NOTYET",
KerberosErrorCode.key_expired: "KDC_ERR_KEY_EXPIRED",
KerberosErrorCode.preauth_failed: "KDC_ERR_PREAUTH_FAILED",
KerberosErrorCode.preauth_required: "KDC_ERR_PREAUTH_REQUIRED",
KerberosErrorCode.server_nomatch: "KDC_ERR_SERVER_NOMATCH",
KerberosErrorCode.must_use_user2user: "KDC_ERR_MUST_USE_USER2USER",
KerberosErrorCode.path_not_accepted: "KDC_ERR_PATH_NOT_ACCEPTED",
KerberosErrorCode.kdc_svc_unavailable: "KDC_ERR_SVC_UNAVAILABLE",
KerberosErrorCode.ap_bad_integrity: "KRB_AP_ERR_BAD_INTEGRITY",
KerberosErrorCode.ap_txt_expired: "KRB_AP_ERR_TKT_EXPIRED",
KerberosErrorCode.ap_tkt_nyv: "KRB_AP_ERR_TKT_NYV",
KerberosErrorCode.ap_repeat: "KRB_AP_ERR_REPEAT",
KerberosErrorCode.ap_not_use: "KRB_AP_ERR_NOT_US",
KerberosErrorCode.ap_badmatch: "KRB_AP_ERR_BADMATCH",
KerberosErrorCode.ap_skew: "KRB_AP_ERR_SKEW",
KerberosErrorCode.ap_badaddr: "KRB_AP_ERR_BADADDR",
KerberosErrorCode.ap_badversion: "KRB_AP_ERR_BADVERSION",
KerberosErrorCode.ap_msg_type: "KRB_AP_ERR_MSG_TYPE",
KerberosErrorCode.ap_modified: "KRB_AP_ERR_MODIFIED",
KerberosErrorCode.ap_badorder: "KRB_AP_ERR_BADORDER",
KerberosErrorCode.ap_badkeyver: "KRB_AP_ERR_BADKEYVER",
KerberosErrorCode.ap_nokey: "KRB_AP_ERR_NOKEY",
KerberosErrorCode.ap_mut_fail: "KRB_AP_ERR_MUT_FAIL",
KerberosErrorCode.ap_baddirection: "KRB_AP_ERR_BADDIRECTION",
KerberosErrorCode.ap_method: "KRB_AP_ERR_METHOD",
KerberosErrorCode.ap_badseq: "KRB_AP_ERR_BADSEQ",
KerberosErrorCode.ap_inapp_cksum: "KRB_AP_ERR_INAPP_CKSUM",
KerberosErrorCode.ap_path_not_accepted: "KRB_AP_PATH_NOT_ACCEPTED",
KerberosErrorCode.response_too_big: "KRB_ERR_RESPONSE_TOO_BIG",
KerberosErrorCode.generic: "KRB_ERR_GENERIC",
KerberosErrorCode.field_toolong: "KRB_ERR_FIELD_TOOLONG",
KerberosErrorCode.kdc_client_not_trusted: "KDC_ERROR_CLIENT_NOT_TRUSTED",
KerberosErrorCode.kdc_not_trusted: "KDC_ERROR_KDC_NOT_TRUSTED",
KerberosErrorCode.kdc_invalid_sig: "KDC_ERROR_INVALID_SIG",
KerberosErrorCode.kdc_key_too_weak: "KDC_ERR_KEY_TOO_WEAK",
KerberosErrorCode.kdc_certificate_mismatch: "KDC_ERR_CERTIFICATE_MISMATCH",
KerberosErrorCode.ap_no_tgt: "KRB_AP_ERR_NO_TGT",
KerberosErrorCode.kdc_wrong_realm: "KDC_ERR_WRONG_REALM",
KerberosErrorCode.ap_user_to_user_required: "KRB_AP_ERR_USER_TO_USER_REQUIRED",
KerberosErrorCode.kdc_cant_verify_certificate: "KDC_ERR_CANT_VERIFY_CERTIFICATE",
KerberosErrorCode.kdc_invalid_certificate: "KDC_ERR_INVALID_CERTIFICATE",
KerberosErrorCode.kdc_revoked_certificate: "KDC_ERR_REVOKED_CERTIFICATE",
KerberosErrorCode.kdc_revocation_status_unknown: "KDC_ERR_REVOCATION_STATUS_UNKNOWN",
KerberosErrorCode.kdc_revocation_status_unavailable: "KDC_ERR_REVOCATION_STATUS_UNAVAILABLE",
KerberosErrorCode.kdc_client_name_mismatch: "KDC_ERR_CLIENT_NAME_MISMATCH",
KerberosErrorCode.kdc_name_mismatch: "KDC_ERR_KDC_NAME_MISMATCH",
}
# https://www.rfc-editor.org/rfc/rfc4120#section-5.10
class KerberosMessageType(enum.IntEnum):
unknown = 0
as_req = 10
as_rep = 11
tgs_req = 12
tgs_rep = 13
ap_req = 14
ap_rep = 15
error = 30
@classmethod
def native_labels(cls) -> typing.Dict["KerberosMessageType", str]:
return {
KerberosMessageType.unknown: "UNKNOWN",
KerberosMessageType.as_req: "AS-REQ",
KerberosMessageType.as_rep: "AS-REP",
KerberosMessageType.tgs_req: "TGS-REQ",
KerberosMessageType.tgs_rep: "TGS-REP",
KerberosMessageType.ap_req: "AP-REQ",
KerberosMessageType.ap_rep: "AP-REP",
KerberosMessageType.error: "KRB-ERROR",
}
# https://www.iana.org/assignments/kerberos-parameters/kerberos-parameters.xhtml
class KerberosPADataType(enum.IntEnum):
tgs_req = 1
enc_timestamp = 2
pw_salt = 3
reserved = 4
enc_unix_time = 5
sandia_secureid = 6
sesame = 7
osf_dce = 8
cybersafe_secureid = 9
afs3_salt = 10
etype_info = 11
sam_challenge = 12
sam_response = 13
pk_as_req_old = 14
pk_as_rep_old = 15
pk_as_req = 16
pk_as_rep = 17
pk_ocsp_response = 18
etype_info2 = 19
use_specified_kvno = 20
svr_referral_info = 20
sam_redirect = 21
get_from_typed_data = 22
td_padata = 22
sam_etype_info = 23
alt_princ = 24
server_referral = 25
sam_challenge2 = 30
sam_response2 = 31
extra_tgt = 41
td_pkinit_cms_certificates = 101
td_krb_principal = 102
td_krb_realm = 103
td_trusted_certifiers = 104
td_certificate_index = 105
td_app_defined_error = 106
td_req_nonce = 107
td_req_seq = 108
td_dh_parameters = 109
td_cms_digest_algorithms = 111
td_cert_digest_algorithms = 112
pac_request = 128
for_user = 128
for_x509_user = 130
for_check_dups = 131
as_checksum = 132
fx_cookie = 133
authentication_set = 134
auth_set_selected = 165
fx_fast = 136
fx_error = 137
encrypted_challenge = 138
otp_challenge = 141
otp_request = 142
otp_confirm = 143
otp_pin_change = 144
epak_as_req = 145
epak_as_rep = 146
pkinit_kx = 147
pku2u_name = 148
enc_pa_rep = 149
as_freshness = 150
spake = 151
kerb_key_list_req = 161
kerb_key_list_rep = 162
supported_etypes = 165
extended_error = 166
pac_options = 167
@classmethod
def native_labels(cls) -> typing.Dict["KerberosPADataType", str]:
return {
KerberosPADataType.tgs_req: "PA-TGS-REQ",
KerberosPADataType.enc_timestamp: "PA-ENC-TIMESTAMP",
KerberosPADataType.pw_salt: "PA-PW-SALT",
KerberosPADataType.reserved: "reserved",
KerberosPADataType.enc_unix_time: "PA-ENC-UNIX-TIME",
KerberosPADataType.sandia_secureid: "PA-SANDIA-SECUREID",
KerberosPADataType.sesame: "PA-SESAME",
KerberosPADataType.osf_dce: "PA-OSF-DCE",
KerberosPADataType.cybersafe_secureid: "PA-CYBERSAFE-SECUREID",
KerberosPADataType.afs3_salt: "PA-AFS3-SALT",
KerberosPADataType.etype_info: "PA-ETYPE-INFO",
KerberosPADataType.sam_challenge: "PA-SAM-CHALLENGE",
KerberosPADataType.sam_response: "PA-SAM-RESPONSE",
KerberosPADataType.pk_as_req_old: "PA-PK-AS-REQ_OLD",
KerberosPADataType.pk_as_rep_old: "PA-PK-AS-REP_OLD",
KerberosPADataType.pk_as_req: "PA-PK-AS-REQ",
KerberosPADataType.pk_as_rep: "PA-PK-AS-REP",
KerberosPADataType.pk_ocsp_response: "PA-PK-OCSP-RESPONSE",
KerberosPADataType.etype_info2: "PA-ETYPE-INFO2",
KerberosPADataType.use_specified_kvno: "PA-USE-SPECIFIED-KVNO or PA-SVR-REFERRAL-INFO",
KerberosPADataType.sam_redirect: "PA-SAM-REDIRECT",
KerberosPADataType.get_from_typed_data: "PA-GET-FROM-TYPED-DATA",
KerberosPADataType.td_padata: "TD-PADATA",
KerberosPADataType.sam_etype_info: "PA-SAM-ETYPE-INFO",
KerberosPADataType.alt_princ: "PA-ALT-PRINC",
KerberosPADataType.server_referral: "PA-SERVER-REFERRAL",
KerberosPADataType.sam_challenge2: "PA-SAM-CHALLENGE2",
KerberosPADataType.sam_response2: "PA-SAM-RESPONSE2",
KerberosPADataType.extra_tgt: "PA-EXTRA-TGT",
KerberosPADataType.td_pkinit_cms_certificates: "TD-PKINIT-CMS-CERTIFICATES",
KerberosPADataType.td_krb_principal: "TD-KRB-PRINCIPAL",
KerberosPADataType.td_krb_realm: "TD-KRB-REALM",
KerberosPADataType.td_trusted_certifiers: "TD-TRUSTED-CERTIFIERS",
KerberosPADataType.td_certificate_index: "TD-CERTIFICATE-INDEX",
KerberosPADataType.td_app_defined_error: "TD-APP-DEFINED-ERROR",
KerberosPADataType.td_req_nonce: "TD-REQ-NONCE",
KerberosPADataType.td_req_seq: "TD-REQ-SEQ",
KerberosPADataType.td_dh_parameters: "TD_DH_PARAMETERS",
KerberosPADataType.td_cms_digest_algorithms: "TD-CMS-DIGEST-ALGORITHMS",
KerberosPADataType.td_cert_digest_algorithms: "TD-CERT-DIGEST-ALGORITHMS",
KerberosPADataType.pac_request: "PA-PAC-REQUEST",
KerberosPADataType.for_user: "PA-FOR_USER",
KerberosPADataType.for_x509_user: "PA-FOR-X509-USER",
KerberosPADataType.for_check_dups: "PA-FOR-CHECK_DUPS",
KerberosPADataType.as_checksum: "PA-AS-CHECKSUM",
KerberosPADataType.fx_cookie: "PA-FX-COOKIE",
KerberosPADataType.authentication_set: "PA-AUTHENTICATION-SET",
KerberosPADataType.auth_set_selected: "PA-AUTH-SET-SELECTED",
KerberosPADataType.fx_fast: "PA-FX-FAST",
KerberosPADataType.fx_error: "PA-FX-ERROR",
KerberosPADataType.encrypted_challenge: "PA-ENCRYPTED-CHALLENGE",
KerberosPADataType.otp_challenge: "PA-OTP-CHALLENGE",
KerberosPADataType.otp_request: "PA-OTP-REQUEST",
KerberosPADataType.otp_confirm: "PA-OTP-CONFIRM",
KerberosPADataType.otp_pin_change: "PA-OTP-PIN-CHANGE",
KerberosPADataType.epak_as_req: "PA-EPAK-AS-REQ",
KerberosPADataType.epak_as_rep: "PA-EPAK-AS-REP",
KerberosPADataType.pkinit_kx: "PA_PKINIT_KX",
KerberosPADataType.pku2u_name: "PA_PKU2U_NAME",
KerberosPADataType.enc_pa_rep: "PA-REQ-ENC-PA-REP",
KerberosPADataType.as_freshness: "PA_AS_FRESHNESS",
KerberosPADataType.spake: "PA-SPAKE",
KerberosPADataType.kerb_key_list_req: "KERB-KEY-LIST-REQ",
KerberosPADataType.kerb_key_list_rep: "KERB-KEY-LIST-REP",
KerberosPADataType.supported_etypes: "PA-SUPPORTED-ETYPES",
KerberosPADataType.extended_error: "PA-EXTENDED_ERROR",
KerberosPADataType.pac_options: "PA-PAC-OPTIONS",
}
# https://www.rfc-editor.org/rfc/rfc4120#section-6.2
class KerberosPrincipalNameType(enum.IntEnum):
unknown = 0
principal = 1
srv_inst = 2
srv_hst = 3
srv_xhst = 4
uid = 5
x500_principal = 6
smtp_name = 7
enterprise = 10
@classmethod
def native_labels(cls) -> typing.Dict["KerberosPrincipalNameType", str]:
return {
KerberosPrincipalNameType.unknown: "NT-UNKNOWN",
KerberosPrincipalNameType.principal: "NT-PRINCIPAL",
KerberosPrincipalNameType.srv_inst: "NT-SRV-INST",
KerberosPrincipalNameType.srv_hst: "NT-SRV-HST",
KerberosPrincipalNameType.srv_xhst: "NT-SRV-XHST",
KerberosPrincipalNameType.uid: "NT-UID",
KerberosPrincipalNameType.x500_principal: "NT-X500-PRINCIPAL",
KerberosPrincipalNameType.smtp_name: "NT-SMTP-NAME",
KerberosPrincipalNameType.enterprise: "NT-ENTERPRISE",
}
# https://www.rfc-editor.org/rfc/rfc4120#section-7.5.3
class KerberosHostAddressType(enum.IntEnum):
ipv4 = 2
directional = 3
chaos_net = 5
xns = 6
iso = 7
decnet_phase_iv = 12
apple_talk_ddp = 16
netbios = 20
ipv6 = 26
@classmethod
def native_labels(cls) -> typing.Dict["KerberosHostAddressType", str]:
return {
KerberosHostAddressType.ipv4: "IPv4",
KerberosHostAddressType.directional: "Directional",
KerberosHostAddressType.chaos_net: "ChaosNet",
KerberosHostAddressType.xns: "XNS",
KerberosHostAddressType.iso: "ISO",
KerberosHostAddressType.decnet_phase_iv: "DECNET Phase IV",
KerberosHostAddressType.apple_talk_ddp: "AppleTalk DDP",
KerberosHostAddressType.netbios: "NetBios",
KerberosHostAddressType.ipv6: "IPv6",
}
class ParseType(enum.IntEnum):
default = 0
enum = 1
flags = 2
datetime = 3
text = 4
bytes = 5
principal_name = 6
host_address = 7
token = 8
class _KerberosMsgType(type):
__registry: typing.Dict[int, typing.Dict[int, "_KerberosMsgType"]] = {}
def __init__(
cls,
*args: typing.Any,
**kwargs: typing.Any,
) -> None:
pvno = getattr(cls, "PVNO", 0)
if pvno not in cls.__registry:
cls.__registry[pvno] = {}
msg_type = getattr(cls, "MESSAGE_TYPE", None)
if msg_type is not None:
cls.__registry[pvno][msg_type] = cls
def __call__(
cls,
sequence: typing.Dict[int, ASN1Value],
) -> "_KerberosMsgType":
# The KrbAsReq msg starts at 1 not 0, so do a check for that.
pvno_idx = 0
if 0 not in sequence:
pvno_idx = 1
pvno = unpack_asn1_integer(sequence[pvno_idx])
message_type = unpack_asn1_integer(sequence[pvno_idx + 1])
new_cls = cls.__registry[pvno].get(message_type, cls)
return super(_KerberosMsgType, new_cls).__call__(sequence)
class KerberosV5Msg(metaclass=_KerberosMsgType):
MESSAGE_TYPE = KerberosMessageType.unknown
PVNO = 5
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
# This is only used if decoding an unknown Kerberos message type.
self.sequence = sequence
@staticmethod
def unpack(value: typing.Union[ASN1Value, bytes]) -> "KerberosV5Msg":
msg_sequence = unpack_asn1_tagged_sequence(value)
return KerberosV5Msg(msg_sequence)
class KrbAsReq(KerberosV5Msg):
"""The KRB_AS_REQ message.
The KRB_AS_REQ message is used when the client wishes to retrieve a the initial ticket for a service. The
KRB_TGS_REQ message is identical except for the tag and msg-type is used when retrieving additional tickets for a
service.
The ASN.1 definition for the KDC-REQ structure is defined in `RFC 4120 5.4.1`_::
KDC-REQ ::= SEQUENCE {
-- NOTE: first tag is [1], not [0]
pvno [1] INTEGER (5) ,
msg-type [2] INTEGER (10 -- AS -- | 12 -- TGS --),
padata [3] SEQUENCE OF PA-DATA OPTIONAL
-- NOTE: not empty --,
req-body [4] KDC-REQ-BODY
}
Args:
sequence: The ASN.1 sequence value as a dict to unpack.
Attributes:
padata (PAData): The pre-authentication data.
req_body (KdcReqBody): The body of the request.
.. _RFC 4120 5.4.1:
https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1
"""
MESSAGE_TYPE = KerberosMessageType.as_req
PARSE_MAP = [
("pvno", "PVNO", ParseType.default),
("msg-type", "MESSAGE_TYPE", ParseType.enum),
("padata", "padata", ParseType.token),
("req-body", "req_body", ParseType.token),
]
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
def unpack_padata(value: typing.Union[ASN1Value, bytes]) -> typing.List:
return [PAData.unpack(p) for p in unpack_asn1_sequence(value)]
self.padata = get_sequence_value(sequence, 3, "KDC-REQ", "pa-data", unpack_padata)
self.req_body = get_sequence_value(sequence, 4, "KDC-REQ", "req-body", KdcReqBody.unpack)
class KrbAsRep(KerberosV5Msg):
"""The KRB_AS_REP message.
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
identical except for the tag and msg-type.
The ASN.1 definition for the KDC-REP structure is defined in `RFC 4120 5.4.2`_::
KDC-REP ::= SEQUENCE {
pvno [0] INTEGER (5),
msg-type [1] INTEGER (11 -- AS -- | 13 -- TGS --),
padata [2] SEQUENCE OF PA-DATA OPTIONAL
-- NOTE: not empty --,
crealm [3] Realm,
cname [4] PrincipalName,
ticket [5] Ticket,
enc-part [6] EncryptedData
-- EncASRepPart or EncTGSRepPart,
-- as appropriate
}
Args:
sequence: The ASN.1 sequence value as a dict to unpack.
Attributes:
padata (PAData): The pre-authentication data.
crealm (bytes): The client realm.
cname (PrincipalName): The client principal name.
ticket (Ticket): The newly issued ticket.
enc_part (EncryptedData): The encrypted part of the message.
.. _RFC 4120 5.4.2:
https://www.rfc-editor.org/rfc/rfc4120#section-5.4.2
"""
MESSAGE_TYPE = KerberosMessageType.as_rep
PARSE_MAP = [
("pvno", "PVNO", ParseType.default),
("msg-type", "MESSAGE_TYPE", ParseType.enum),
("padata", "padata", ParseType.token),
("crealm", "crealm", ParseType.text),
("cname", "cname", ParseType.principal_name),
("ticket", "ticket", ParseType.token),
("enc-part", "enc_part", ParseType.token),
]
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
def unpack_padata(value: typing.Union[ASN1Value, bytes]) -> typing.List:
return [PAData.unpack(p) for p in unpack_asn1_sequence(value)]
self.padata = get_sequence_value(sequence, 2, "KDC-REP", "pa-data", unpack_padata)
self.crealm = get_sequence_value(sequence, 3, "KDC-REP", "crealm", unpack_asn1_general_string)
self.cname = get_sequence_value(sequence, 4, "KDC-REP", "cname", unpack_principal_name)
self.ticket = get_sequence_value(sequence, 5, "KDC-REP", "ticket", Ticket.unpack)
self.enc_part = get_sequence_value(sequence, 6, "KDC-REP", "enc-part", EncryptedData.unpack)
class KrbTgsReq(KrbAsReq):
"""The KRB_TGS_REQ is the same as KRB_AS_REQ but with a different MESSAGE_TYPE."""
MESSAGE_TYPE = KerberosMessageType.tgs_req
class KrbTgsRep(KrbAsRep):
"""The KRB_TGS_REP is the same as KRB_AS_REP but with a different MESSAGE_TYPE."""
MESSAGE_TYPE = KerberosMessageType.tgs_rep
class KrbApReq(KerberosV5Msg):
"""The KRB_AP_REQ message.
The KRB_AP_REQ message contains is used to authenticate the initiator to an acceptor.
The ASN.1 definition for the KRB_AP_REQ structure is defined in `RFC 4120 5.5.1`_::
AP-REQ ::= [APPLICATION 14] SEQUENCE {
pvno [0] INTEGER (5),
msg-type [1] INTEGER (14),
ap-options [2] APOptions,
ticket [3] Ticket,
authenticator [4] EncryptedData -- Authenticator
}
Args:
sequence: The ASN.1 sequence value as a dict to unpack.
Attributes:
ap_options (KerberosAPOptions): Options related to the AP request.
ticket (Ticket): The ticket authenticating the client to the server.
authenticator (EncryptedData): The encrypted authenticator.
.. _RFC 4120 5.5.1:
https://www.rfc-editor.org/rfc/rfc4120#section-5.5.1
"""
MESSAGE_TYPE = KerberosMessageType.ap_req
PARSE_MAP = [
("pvno", "PVNO", ParseType.default),
("msg-type", "MESSAGE_TYPE", ParseType.enum),
("ap-options", "ap_options", ParseType.flags),
("ticket", "ticket", ParseType.token),
("authenticator", "authenticator", ParseType.token),
]
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
raw_ap_options = get_sequence_value(sequence, 2, "AP-REQ", "ap-options", unpack_asn1_bit_string)
ap_options = KerberosAPOptions(struct.unpack("<I", raw_ap_options)[0])
self.ap_options = ap_options
self.ticket = get_sequence_value(sequence, 3, "AP-REQ", "ticket", Ticket.unpack)
self.authenticator = get_sequence_value(sequence, 4, "AP-REQ", "authenticator", EncryptedData.unpack)
class KrbApRep(KerberosV5Msg):
"""The KRB_AP_REP message.
The KRB_AP_REP is a response to an application request `KRB_AP_REQ`.
The ASN.1 definition for the KRB_AP_REP structure is defined in `RFC 4120 5.5.2`_::
AP-REP ::= [APPLICATION 15] SEQUENCE {
pvno [0] INTEGER (5),
msg-type [1] INTEGER (15),
enc-part [2] EncryptedData -- EncAPRepPart
}
Args:
sequence: The ASN.1 sequence value as a dict to unpack.
Attributes:
enc_part (EncryptedData): The encrypted authenticator.
.. _RFC 4120 5.5.2:
https://www.rfc-editor.org/rfc/rfc4120#section-5.5.2
"""
MESSAGE_TYPE = KerberosMessageType.ap_rep
PARSE_MAP = [
("pvno", "PVNO", ParseType.default),
("msg-type", "MESSAGE_TYPE", ParseType.enum),
("enc-part", "enc_part", ParseType.token),
]
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
self.enc_part = get_sequence_value(sequence, 2, "AP-REP", "enc-part", EncryptedData.unpack)
class KrbError(KerberosV5Msg):
"""The KRB_ERROR message.
The KRB_ERROR is a message sent in the occurrence of an error.
The ASN.1 definition for the KRB_ERROR structure is defined in `RFC 4120 5.9.1`_::
KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
pvno [0] INTEGER (5),
msg-type [1] INTEGER (30),
ctime [2] KerberosTime OPTIONAL,
cusec [3] Microseconds OPTIONAL,
stime [4] KerberosTime,
susec [5] Microseconds,
error-code [6] Int32,
crealm [7] Realm OPTIONAL,
cname [8] PrincipalName OPTIONAL,
realm [9] Realm -- service realm --,
sname [10] PrincipalName -- service name --,
e-text [11] KerberosString OPTIONAL,
e-data [12] OCTET STRING OPTIONAL
}
Args:
sequence: The ASN.1 sequence value as a dict to unpack.
Attributes:
ctime (datetime.datetime): The current time on the client's host.
cusec (int): The microsecond part of the client's timestamp.
stime (datetime.datetime): The current time of the server.
susec (int): The microsecond part of the server's timestamp.
error_code (KerberosErrorCode): THe error code returned by the kerberos when a request fails.
crealm (bytes): The realm that issues a ticket.
cname (PrincipalName): The principal name in the ticket.
realm (bytes): The service realm.
sname (PrincipalName): The service name.
e_text (bytes): Additional text to explain the error code.
e_data (bytes): Additional data about the error.
.. _RFC 4120 5.9.1:
https://www.rfc-editor.org/rfc/rfc4120#section-5.9.1
"""
MESSAGE_TYPE = KerberosMessageType.error
PARSE_MAP = [
("pvno", "PVNO", ParseType.default),
("msg-type", "MESSAGE_TYPE", ParseType.enum),
("ctime", "ctime", ParseType.datetime),
("cusec", "cusec", ParseType.default),
("stime", "stime", ParseType.datetime),
("susec", "susec", ParseType.default),
("error-code", "error_code", ParseType.enum),
("crealm", "crealm", ParseType.text),
("cname", "cname", ParseType.principal_name),
("realm", "realm", ParseType.text),
("sname", "sname", ParseType.principal_name),
("e-text", "e_text", ParseType.text),
("e-data", "e_data", ParseType.bytes),
]
def __init__(self, sequence: typing.Dict[int, ASN1Value]) -> None:
self.ctime = get_sequence_value(sequence, 2, "KRB-ERROR", "ctime", unpack_asn1_generalized_time)
self.cusec = get_sequence_value(sequence, 3, "KRB-ERROR", "cusec", unpack_asn1_integer)
self.stime = get_sequence_value(sequence, 4, "KRB-ERROR", "stime", unpack_asn1_generalized_time)
self.susec = get_sequence_value(sequence, 5, "KRB-ERROR", "susec", unpack_asn1_integer)
self.error_code = KerberosErrorCode(
get_sequence_value(sequence, 6, "KRB-ERROR", "error-code", unpack_asn1_integer)
)
self.crealm = get_sequence_value(sequence, 7, "KRB-ERROR", "crealm", unpack_asn1_general_string)
self.cname = get_sequence_value(sequence, 8, "KRB-ERROR", "cname", unpack_principal_name)
self.realm = get_sequence_value(sequence, 9, "KRB-ERROR", "realm", unpack_asn1_general_string)
self.sname = get_sequence_value(sequence, 10, "KRB-ERROR", "realm", unpack_principal_name)
self.e_text = get_sequence_value(sequence, 11, "KRB-ERROR", "e-text", unpack_asn1_general_string)
self.e_data = get_sequence_value(sequence, 12, "KRB-ERROR", "e-data", unpack_asn1_octet_string)
class PAData:
"""Kerberos PA-DATA.
The ASN.1 definition for the PA-DATA structure is defined in `RFC 4120 5.2.7`_::
PA-DATA ::= SEQUENCE {
-- NOTE: first tag is [1], not [0]
padata-type [1] Int32,
padata-value [2] OCTET STRING -- might be encoded AP-REQ
}
Args:
data_type: Indicates the type of data the value represents.
value: The PAData value, usually the DER encoding of another message.
Attributes:
data_type (Union[int, KerberosPADataType]): See args.
b_value (bytes): The raw bytes of padata-value, use `value` to get a structured object of these bytes if
available.
.. RFC 4120 5.2.7:
https://www.rfc-editor.org/rfc/rfc4120#section-5.2.7
"""
PARSE_MAP = [
("padata-type", "data_type", ParseType.enum),
("padata-value", "value", ParseType.token),
]
def __init__(self, data_type: typing.Union[int, KerberosPADataType], value: bytes) -> None:
self.data_type = data_type
self.b_value = value
@property
def value(self) -> typing.Any:
if self.data_type == KerberosPADataType.tgs_req:
# Special edge case for this PA type due to how the messages require the data in unpack
return KrbTgsReq.unpack(unpack_asn1(unpack_asn1(self.b_value)[0].b_data)[0])
data_type_map = {
int(KerberosPADataType.enc_timestamp): (EncryptedData.unpack, False),
int(KerberosPADataType.etype_info2): (PAETypeInfo2.unpack, True),
}
if self.data_type in data_type_map:
unpack_func, is_sequence = data_type_map[int(self.data_type)]
b_value = unpack_asn1(self.b_value)[0]
if is_sequence:
# Is a SEQUENCE OF (list of entries).
return [unpack_func(v) for v in unpack_asn1_sequence(b_value)]
else:
return unpack_func(b_value.b_data)
else:
return self.b_value
@staticmethod
def unpack(value: typing.Union[ASN1Value, bytes]) -> "PAData":
sequence = unpack_asn1_tagged_sequence(value)
def unpack_data_type(value: typing.Union[ASN1Value, bytes]) -> typing.Union[KerberosPADataType, int]:
int_val = unpack_asn1_integer(value)
try:
return KerberosPADataType(int_val)
except ValueError:
return int_val
data_type = get_sequence_value(sequence, 1, "PA-DATA", "padata-type", unpack_data_type)
pa_value = get_sequence_value(sequence, 2, "PA-DATA", "padata-value", unpack_asn1_octet_string)
return PAData(data_type, pa_value)
class PAETypeInfo2:
"""Kerberos PA-ETYPE-INFO2 container.
The ASN.1 definition for the PA-ETYPE-INFO2 structure is defined in `RFC 4120 5.2.7.5`_::
ETYPE-INFO2-ENTRY ::= SEQUENCE {
etype [0] Int32,
salt [1] KerberosString OPTIONAL,
s2kparams [2] OCTET STRING OPTIONAL
}
Args:
etype: The etype that defines the cipher used.
salt: The used in the cipher associated with the cryptosystem.
s2kparams: Extra params to be interpreted by the cipher associated with the cryptosystem.
Attributes:
etype (KerberosEncryptionType): See args.
salt (Optional[bytes]): See args.
s2kparams (Optional[bytes]): See args.
.. RFC 4120 5.2.7.5:
https://www.rfc-editor.org/rfc/rfc4120#section-5.2.7.5
"""
PARSE_MAP = [
("etype", "etype", ParseType.enum),
("salt", "salt", ParseType.bytes),
("s2kparams", "s2kparams", ParseType.bytes),
]
def __init__(
self,
etype: KerberosEncryptionType,
salt: typing.Optional[bytes],
s2kparams: typing.Optional[bytes],
) -> None:
self.etype = etype
self.salt = salt
self.s2kparams = s2kparams
@staticmethod
def unpack(value: typing.Union[ASN1Value, bytes]) -> "PAETypeInfo2":
sequence = unpack_asn1_tagged_sequence(value)
etype = KerberosEncryptionType(get_sequence_value(sequence, 0, "PA-ETYPE-INFO2", "etype", unpack_asn1_integer))
salt = get_sequence_value(sequence, 1, "ETYPE-INFO2-ENTRY", "salt", unpack_asn1_general_string)
s2kparams = get_sequence_value(sequence, 2, "ETYPE-INFO2-ENTRY", "s2kparams", unpack_asn1_octet_string)
return PAETypeInfo2(etype, salt, s2kparams)
class EncryptedData:
"""Kerberos EncryptedData container.
The ASN.1 definition for the EncryptedData structure is defined in `RFC 4120 5.2.9`_::
EncryptedData ::= SEQUENCE {
etype [0] Int32 -- EncryptionType --,
kvno [1] UInt32 OPTIONAL,
cipher [2] OCTET STRING -- ciphertext
}
Args:
etype: The encryption algorithm that was used to encipher the cipher.
kvno: The version number of the key under which data is encrypted. It is only present in messages encrypted
under long lasting keys.
cipher: The enciphered text.
Attributes:
etype (KerberosEncryptionType): See args.
kvno (Optional[int]): See args.
cipher (bytes): See args.
.. RFC 4120 5.2.9:
https://www.rfc-editor.org/rfc/rfc4120#section-5.2.9
"""
PARSE_MAP = [
("etype", "etype", ParseType.enum),
("kvno", "kvno", ParseType.default),
("cipher", "cipher", ParseType.bytes),
]
def __init__(self, etype: KerberosEncryptionType, kvno: typing.Optional[int], cipher: bytes) -> None:
self.etype = etype
self.kvno = kvno
self.cipher = cipher
@staticmethod
def unpack(value: typing.Union[bytes, ASN1Value]) -> "EncryptedData":
sequence = unpack_asn1_tagged_sequence(value)
etype = KerberosEncryptionType(get_sequence_value(sequence, 0, "EncryptedData", "etype", unpack_asn1_integer))
kvno = get_sequence_value(sequence, 1, "EncryptedData", "kvno", unpack_asn1_integer)
cipher = get_sequence_value(sequence, 2, "EncryptedData", "cipher", unpack_asn1_octet_string)
return EncryptedData(etype, kvno, cipher)
class Ticket:
"""Kerberos Ticket.
The ASN.1 definition for the Ticket structure is defined in `RFC 4120 5.3`_::
Ticket ::= [APPLICATION 1] SEQUENCE {
tkt-vno [0] INTEGER (5),
realm [1] Realm,
sname [2] PrincipalName,
enc-part [3] EncryptedData -- EncTicketPart
}
Args:
tkt_vno: The version number for the ticket format.
realm: The realm that issued a ticket.
sname: All the name components of the server's identity.
enc_part: The encrypted part of the ticket, it is encrypted in the key shared by Kerberos and the end server.
Attributes:
tkt_vno (int): See args.
realm (bytes): See args.
sname (List[PrincipalName]): See args.
enc_part (EncryptedData): See args.
.. _RFC 4120 5.3:
https://www.rfc-editor.org/rfc/rfc4120#section-5.3
"""
PARSE_MAP = [
("tkt-vno", "tkt_vno", ParseType.default),
("realm", "realm", ParseType.text),
("sname", "sname", ParseType.principal_name),
("enc-part", "enc_part", ParseType.token),
]
def __init__(
self,
tkt_vno: int,
realm: bytes,
sname: typing.List[PrincipalName],
enc_part: EncryptedData,
) -> None:
self.tkt_vno = tkt_vno
self.realm = realm
self.sname = sname
self.enc_part = enc_part
@staticmethod
def unpack(value: typing.Union[ASN1Value, bytes]) -> "Ticket":
b_data = extract_asn1_tlv(value, TagClass.application, 1)
sequence = unpack_asn1_tagged_sequence(unpack_asn1(b_data)[0])
tkt_vno = get_sequence_value(sequence, 0, "Ticket", "tkt-vno", unpack_asn1_integer)
realm = get_sequence_value(sequence, 1, "Ticket", "realm", unpack_asn1_general_string)
sname = get_sequence_value(sequence, 2, "Ticket", "sname", unpack_principal_name)
enc_part = get_sequence_value(sequence, 3, "Ticket", "enc-part", EncryptedData.unpack)
return Ticket(tkt_vno, realm, sname, enc_part)
class KdcReqBody:
"""The KRB_AS_REQ message.
The KRB_AS_REQ message is used when the client wishes to retrieve a the initial ticket for a service. The
KRB_TGS_REQ message is identical except for the tag and msg-type is used when retrieving additional tickets for a
service.
The ASN.1 definition for the KDC-REQ structure is defined in `RFC 4120 5.4.1`_::
KDC-REQ-BODY ::= SEQUENCE {
kdc-options [0] KDCOptions,
cname [1] PrincipalName OPTIONAL
-- Used only in AS-REQ --,
realm [2] Realm
-- Server's realm
-- Also client's in AS-REQ --,
sname [3] PrincipalName OPTIONAL,
from [4] KerberosTime OPTIONAL,
till [5] KerberosTime,
rtime [6] KerberosTime OPTIONAL,
nonce [7] UInt32,
etype [8] SEQUENCE OF Int32 -- EncryptionType
-- in preference order --,
addresses [9] HostAddresses OPTIONAL,
enc-authorization-data [10] EncryptedData OPTIONAL
-- AuthorizationData --,
additional-tickets [11] SEQUENCE OF Ticket OPTIONAL
-- NOTE: not empty
}
Args:
kdc_options: Flags desired by the client and other behaviour desired.
cname: The client name.
realm: The realm part of the server's principal.
sname: The service name.
postdated_from: When the requested ticket is to be posted from.
postdated_till: The expiration date requested by the client.
rtime: The requested renew-till time.
nonce: Random number generated by the client.
etype: The desired encryption algorithm to be used in priority order.
addresses: Addresses from which the requested ticket is to be valid.
enc_authorization_data: Encrypted authorization data.
additional_tickets: Additional tickets to be optionally included in a request.
Attributes:
kdc_options (int): See args.
cname (Optional[PrincipalName]): See args.
realm (bytes): See args.
sname (PrincipalName): See args.
postdated_from (Optional[datetime.datetime]): See args.
postdated_till (datetime.datetime): See args.
rtime (Optional[datetime.datetime]): See args.
nonce (int): See args.
etype (List[KerberosEncryptionType]): See args.
addresses (Optional[List[HostAddress]]): See args.
enc_authorization_data (Optional[EncryptedData]): See args.
additional_tickets (Optional[Ticket]): See args.
.. _RFC 4120 5.4.1:
https://www.rfc-editor.org/rfc/rfc4120#section-5.4.1
"""
PARSE_MAP = [
("kdc-options", "kdc_options", (ParseType.flags, KerberosKDCOptions)),
("cname", "cname", ParseType.principal_name),
("realm", "realm", ParseType.text),
("sname", "sname", ParseType.principal_name),
("from", "postdated_from", ParseType.datetime),
("till", "postdated_till", ParseType.datetime),
("rtime", "rtime", ParseType.datetime),
("nonce", "nonce", ParseType.default),
("etype", "etype", ParseType.enum),
("addresses", "addresses", ParseType.host_address),
("enc-authorization-data", "enc_authorization_data", ParseType.token),
("additional-tickets", "additional_tickets", ParseType.token),
]
def __init__(
self,
kdc_options: int,
cname: typing.Optional[PrincipalName],
realm: bytes,
sname: PrincipalName,
postdated_from: typing.Optional[datetime.datetime],
postdated_till: datetime.datetime,
rtime: typing.Optional[datetime.datetime],
nonce: int,
etype: typing.List[KerberosEncryptionType],
addresses: typing.Optional[typing.List[HostAddress]],
enc_authorization_data: typing.Optional[EncryptedData],
additional_tickets: typing.Optional[typing.List[Ticket]],
) -> None:
self.kdc_options = kdc_options
self.cname = cname
self.realm = realm
self.sname = sname
self.postdated_from = postdated_from
self.postdated_till = postdated_till
self.rtime = rtime
self.nonce = nonce
self.etype = etype
self.addresses = addresses
self.enc_authorization_data = enc_authorization_data
self.additional_tickets = additional_tickets
@staticmethod
def unpack(value: typing.Union[ASN1Value, bytes]) -> "KdcReqBody":
sequence = unpack_asn1_tagged_sequence(value)
def unpack_kdc_options(value: typing.Union[ASN1Value, bytes]) -> int:
b_data = unpack_asn1_bit_string(value)
return struct.unpack(">I", b_data)[0]
def unpack_etype(value: typing.Union[ASN1Value, bytes]) -> typing.List[KerberosEncryptionType]:
return [KerberosEncryptionType(unpack_asn1_integer(e)) for e in unpack_asn1_sequence(value)]
def unpack_addresses(value: typing.Union[ASN1Value, bytes]) -> typing.List[HostAddress]:
return [unpack_hostname(h) for h in unpack_asn1_sequence(value)]
def unpack_ticket(value: typing.Union[ASN1Value, bytes]) -> typing.List[Ticket]:
return [Ticket.unpack(t) for t in unpack_asn1_sequence(value)]
kdc_options = get_sequence_value(sequence, 0, "KDC-REQ-BODY", "kdc-options", unpack_kdc_options)
cname = get_sequence_value(sequence, 1, "KDC-REQ-BODY", "cname", unpack_principal_name)
realm = get_sequence_value(sequence, 2, "KDC-REQ-BODY", "realm", unpack_asn1_general_string)
sname = get_sequence_value(sequence, 3, "KDC-REQ-BODY", "sname", unpack_principal_name)
postdated_from = get_sequence_value(sequence, 4, "KDC-REQ-BODY", "from", unpack_asn1_generalized_time)
postdated_till = get_sequence_value(sequence, 5, "KDC-REQ-BODY", "till", unpack_asn1_generalized_time)
rtime = get_sequence_value(sequence, 6, "KDC-REQ-BODY", "rtime", unpack_asn1_generalized_time)
nonce = get_sequence_value(sequence, 7, "KDC-REQ-BODY", "nonce", unpack_asn1_integer)
etype = get_sequence_value(sequence, 8, "KDC-REQ-BODY", "etype", unpack_etype)
addresses = get_sequence_value(sequence, 9, "KDC-REQ-BODY", "addresses", unpack_addresses)
enc_auth_data = get_sequence_value(sequence, 10, "KDC-REQ-BODY", "enc-authorization-data", EncryptedData.unpack)
additional_tickets = get_sequence_value(sequence, 11, "KDC-REQ-BODY", "additional-tickets", unpack_ticket)
return KdcReqBody(
kdc_options,
cname,
realm,
sname,
postdated_from,
postdated_till,
rtime,
nonce,
etype,
addresses,
enc_auth_data,
additional_tickets,
)