Estructura inicial funcional con documentación en el README.md de la FastAPI
This commit is contained in:
926
env/lib/python3.12/site-packages/spnego/__main__.py
vendored
Normal file
926
env/lib/python3.12/site-packages/spnego/__main__.py
vendored
Normal file
@@ -0,0 +1,926 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
# PYTHON_ARGCOMPLETE_OK
|
||||
|
||||
# Copyright: (c) 2020 Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||||
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||||
|
||||
"""
|
||||
Script that can be used to parse a Negotiate token and output a human readable structure. You can pass in an actual
|
||||
SPNEGO token or just a raw Kerberos or NTLM token, the script should be smart enough to detect the structure of the
|
||||
input.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import os.path
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import typing
|
||||
|
||||
from spnego._asn1 import (
|
||||
unpack_asn1,
|
||||
unpack_asn1_object_identifier,
|
||||
unpack_asn1_sequence,
|
||||
)
|
||||
from spnego._context import GSSMech
|
||||
from spnego._kerberos import (
|
||||
KerberosV5Msg,
|
||||
parse_enum,
|
||||
parse_flags,
|
||||
parse_kerberos_token,
|
||||
)
|
||||
from spnego._ntlm_raw.crypto import hmac_md5, ntowfv1, ntowfv2, rc4k
|
||||
from spnego._ntlm_raw.messages import (
|
||||
Authenticate,
|
||||
AvId,
|
||||
Challenge,
|
||||
Negotiate,
|
||||
NegotiateFlags,
|
||||
NTClientChallengeV2,
|
||||
TargetInfo,
|
||||
Version,
|
||||
)
|
||||
from spnego._spnego import InitialContextToken, NegTokenInit, NegTokenResp, unpack_token
|
||||
from spnego._text import to_bytes
|
||||
from spnego._tls_struct import (
|
||||
DistinguishedNameType,
|
||||
TlsCipherSuite,
|
||||
TlsClientCertificateType,
|
||||
TlsCompressionMethod,
|
||||
TlsContentType,
|
||||
TlsECCurveType,
|
||||
TlsECPointFormat,
|
||||
TlsExtensionType,
|
||||
TlsHandshakeMessageType,
|
||||
TlsProtocolVersion,
|
||||
TlsPskKeyExchangeMode,
|
||||
TlsServerNameType,
|
||||
TlsSignatureScheme,
|
||||
TlsSupportedGroup,
|
||||
)
|
||||
|
||||
HAS_ARGCOMPLETE = False
|
||||
try:
|
||||
import argcomplete
|
||||
|
||||
HAS_ARGCOMPLETE = True
|
||||
except ImportError: # pragma: nocover
|
||||
pass
|
||||
|
||||
|
||||
HAS_YAML = False
|
||||
try:
|
||||
from ruamel import yaml
|
||||
|
||||
HAS_YAML = True
|
||||
except ImportError: # pragma: nocover
|
||||
pass
|
||||
|
||||
|
||||
def _parse_ntlm_version(
|
||||
version: typing.Optional[Version],
|
||||
) -> typing.Optional[typing.Dict[str, typing.Union[int, str]]]:
|
||||
if not version:
|
||||
return None
|
||||
|
||||
return {
|
||||
"Major": version.major,
|
||||
"Minor": version.minor,
|
||||
"Build": version.build,
|
||||
"Reserved": base64.b16encode(version.reserved).decode(),
|
||||
"NTLMRevision": version.revision,
|
||||
}
|
||||
|
||||
|
||||
def _parse_ntlm_target_info(
|
||||
target_info: typing.Optional[TargetInfo],
|
||||
) -> typing.Optional[typing.List[typing.Dict[str, typing.Any]]]:
|
||||
if target_info is None:
|
||||
return None
|
||||
|
||||
text_values = [
|
||||
AvId.nb_computer_name,
|
||||
AvId.nb_domain_name,
|
||||
AvId.dns_computer_name,
|
||||
AvId.dns_domain_name,
|
||||
AvId.dns_tree_name,
|
||||
AvId.target_name,
|
||||
]
|
||||
|
||||
info = []
|
||||
for av_id, raw_value in target_info.items():
|
||||
if av_id == AvId.eol:
|
||||
value = None
|
||||
elif av_id in text_values:
|
||||
value = raw_value
|
||||
elif av_id == AvId.flags:
|
||||
value = parse_flags(raw_value)
|
||||
elif av_id == AvId.timestamp:
|
||||
value = str(raw_value)
|
||||
elif av_id == AvId.single_host:
|
||||
value = {
|
||||
"Size": raw_value.size,
|
||||
"Z4": raw_value.z4,
|
||||
"CustomData": base64.b16encode(raw_value.custom_data).decode(),
|
||||
"MachineId": base64.b16encode(raw_value.machine_id).decode(),
|
||||
}
|
||||
else:
|
||||
value = base64.b16encode(raw_value).decode()
|
||||
|
||||
info.append({"AvId": parse_enum(av_id), "Value": value})
|
||||
|
||||
return info
|
||||
|
||||
|
||||
def _parse_ntlm_negotiate(data: Negotiate) -> typing.Dict[str, typing.Any]:
|
||||
b_data = data.pack()
|
||||
|
||||
msg = {
|
||||
"NegotiateFlags": parse_flags(data.flags, enum_type=NegotiateFlags),
|
||||
"DomainNameFields": {
|
||||
"Len": struct.unpack("<H", b_data[16:18])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[18:20])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[20:24])[0],
|
||||
},
|
||||
"WorkstationFields": {
|
||||
"Len": struct.unpack("<H", b_data[24:26])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[26:28])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[28:32])[0],
|
||||
},
|
||||
"Version": _parse_ntlm_version(data.version),
|
||||
"Payload": {
|
||||
"DomainName": data.domain_name,
|
||||
"Workstation": data.workstation,
|
||||
},
|
||||
}
|
||||
|
||||
return msg
|
||||
|
||||
|
||||
def _parse_ntlm_challenge(data: Challenge) -> typing.Dict[str, typing.Any]:
|
||||
b_data = data.pack()
|
||||
|
||||
msg = {
|
||||
"TargetNameFields": {
|
||||
"Len": struct.unpack("<H", b_data[12:14])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[14:16])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[16:20])[0],
|
||||
},
|
||||
"NegotiateFlags": parse_flags(data.flags, enum_type=NegotiateFlags),
|
||||
"ServerChallenge": base64.b16encode(b_data[24:32]).decode(),
|
||||
"Reserved": base64.b16encode(b_data[32:40]).decode(),
|
||||
"TargetInfoFields": {
|
||||
"Len": struct.unpack("<H", b_data[40:42])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[42:44])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[44:48])[0],
|
||||
},
|
||||
"Version": _parse_ntlm_version(data.version),
|
||||
"Payload": {
|
||||
"TargetName": data.target_name,
|
||||
"TargetInfo": _parse_ntlm_target_info(data.target_info),
|
||||
},
|
||||
}
|
||||
|
||||
return msg
|
||||
|
||||
|
||||
def _parse_ntlm_authenticate(data: Authenticate, password: typing.Optional[str]) -> typing.Dict[str, typing.Any]:
|
||||
b_data = data.pack()
|
||||
|
||||
msg: typing.Dict[str, typing.Any] = {
|
||||
"LmChallengeResponseFields": {
|
||||
"Len": struct.unpack("<H", b_data[12:14])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[14:16])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[16:20])[0],
|
||||
},
|
||||
"NtChallengeResponseFields": {
|
||||
"Len": struct.unpack("<H", b_data[20:22])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[22:24])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[24:28])[0],
|
||||
},
|
||||
"DomainNameFields": {
|
||||
"Len": struct.unpack("<H", b_data[28:30])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[30:32])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[32:36])[0],
|
||||
},
|
||||
"UserNameFields": {
|
||||
"Len": struct.unpack("<H", b_data[36:38])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[38:40])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[40:44])[0],
|
||||
},
|
||||
"WorkstationFields": {
|
||||
"Len": struct.unpack("<H", b_data[44:46])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[46:48])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[48:52])[0],
|
||||
},
|
||||
"EncryptedRandomSessionKeyFields": {
|
||||
"Len": struct.unpack("<H", b_data[52:54])[0],
|
||||
"MaxLen": struct.unpack("<H", b_data[54:56])[0],
|
||||
"BufferOffset": struct.unpack("<I", b_data[56:60])[0],
|
||||
},
|
||||
"NegotiateFlags": parse_flags(data.flags, enum_type=NegotiateFlags),
|
||||
"Version": _parse_ntlm_version(data.version),
|
||||
"MIC": base64.b16encode(data.mic).decode() if data.mic else None,
|
||||
"Payload": {
|
||||
"LmChallengeResponse": None,
|
||||
"NtChallengeResponse": None,
|
||||
"DomainName": data.domain_name,
|
||||
"UserName": data.user_name,
|
||||
"Workstation": data.workstation,
|
||||
"EncryptedRandomSessionKey": None,
|
||||
},
|
||||
}
|
||||
|
||||
key_exchange_key = None
|
||||
lm_response_data = data.lm_challenge_response
|
||||
nt_response_data = data.nt_challenge_response
|
||||
|
||||
if lm_response_data:
|
||||
lm_response: typing.Dict[str, typing.Any] = {
|
||||
"ResponseType": None,
|
||||
"LMProofStr": None,
|
||||
}
|
||||
|
||||
if not nt_response_data or len(nt_response_data) == 24:
|
||||
lm_response["ResponseType"] = "LMv1"
|
||||
lm_response["LMProofStr"] = base64.b16encode(lm_response_data).decode()
|
||||
|
||||
else:
|
||||
lm_response["ResponseType"] = "LMv2"
|
||||
lm_response["LMProofStr"] = base64.b16encode(lm_response_data[:16]).decode()
|
||||
lm_response["ChallengeFromClient"] = base64.b16encode(lm_response_data[16:]).decode()
|
||||
|
||||
msg["Payload"]["LmChallengeResponse"] = lm_response
|
||||
|
||||
if nt_response_data:
|
||||
nt_response: typing.Dict[str, typing.Any] = {
|
||||
"ResponseType": None,
|
||||
"NTProofStr": None,
|
||||
}
|
||||
|
||||
if len(nt_response_data) == 24:
|
||||
nt_response["ResponseType"] = "NTLMv1"
|
||||
nt_response["NTProofStr"] = base64.b16encode(nt_response_data).decode()
|
||||
|
||||
# TODO: need to get a sane way to include the server challenge for ESS KXKEY.
|
||||
# if password and lm_response_data:
|
||||
# session_base_key = hashlib.new('md4', ntowfv1(password)).digest()
|
||||
# lmowf = lmowfv1(password)
|
||||
# if data.flags & NegotiateFlags.extended_session_security == 0:
|
||||
# key_exchange_key = kxkey(data.flags, session_base_key, lmowf, lm_response_data, b"")
|
||||
|
||||
else:
|
||||
nt_proof_str = nt_response_data[:16]
|
||||
nt_response["ResponseType"] = "NTLMv2"
|
||||
nt_response["NTProofStr"] = base64.b16encode(nt_proof_str).decode()
|
||||
|
||||
challenge = NTClientChallengeV2.unpack(nt_response_data[16:])
|
||||
b_challenge = nt_response_data[16:]
|
||||
|
||||
nt_response["ClientChallenge"] = {
|
||||
"RespType": challenge.resp_type,
|
||||
"HiRespType": challenge.hi_resp_type,
|
||||
"Reserved1": struct.unpack("<H", b_challenge[2:4])[0],
|
||||
"Reserved2": struct.unpack("<I", b_challenge[4:8])[0],
|
||||
"TimeStamp": str(challenge.time_stamp),
|
||||
"ChallengeFromClient": base64.b16encode(challenge.challenge_from_client).decode(),
|
||||
"Reserved3": struct.unpack("<I", b_challenge[24:28])[0],
|
||||
"AvPairs": _parse_ntlm_target_info(challenge.av_pairs),
|
||||
"Reserved4": struct.unpack("<I", b_challenge[-4:])[0],
|
||||
}
|
||||
|
||||
if password:
|
||||
response_key_nt = ntowfv2(msg["Payload"]["UserName"], ntowfv1(password), msg["Payload"]["DomainName"])
|
||||
key_exchange_key = hmac_md5(response_key_nt, nt_proof_str)
|
||||
|
||||
msg["Payload"]["NtChallengeResponse"] = nt_response
|
||||
|
||||
if data.encrypted_random_session_key:
|
||||
msg["Payload"]["EncryptedRandomSessionKey"] = base64.b16encode(data.encrypted_random_session_key).decode()
|
||||
|
||||
if data.flags & NegotiateFlags.key_exch and (data.flags & NegotiateFlags.sign or data.flags & NegotiateFlags.seal):
|
||||
session_key = None
|
||||
if key_exchange_key:
|
||||
session_key = rc4k(key_exchange_key, typing.cast(bytes, data.encrypted_random_session_key))
|
||||
|
||||
else:
|
||||
session_key = key_exchange_key
|
||||
|
||||
msg["SessionKey"] = base64.b16encode(session_key).decode() if session_key else "Failed to derive"
|
||||
|
||||
return msg
|
||||
|
||||
|
||||
def _parse_spnego_init(
|
||||
data: NegTokenInit,
|
||||
secret: typing.Optional[str] = None,
|
||||
encoding: typing.Optional[str] = None,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
mech_types = [parse_enum(m, enum_type=GSSMech) for m in data.mech_types] if data.mech_types else None
|
||||
|
||||
mech_token = None
|
||||
if data.mech_token:
|
||||
mech_token = parse_token(data.mech_token, secret=secret, encoding=encoding)
|
||||
|
||||
encoding = encoding or "utf-8"
|
||||
|
||||
msg = {
|
||||
"mechTypes": mech_types,
|
||||
"reqFlags": parse_flags(data.req_flags) if data.req_flags is not None else None,
|
||||
"mechToken": mech_token,
|
||||
"mechListMIC": base64.b16encode(data.mech_list_mic).decode() if data.mech_list_mic is not None else None,
|
||||
}
|
||||
|
||||
if data.hint_name or data.hint_address:
|
||||
# This is a NegTokenInit2 structure.
|
||||
msg["negHints"] = {
|
||||
"hintName": data.hint_name.decode(encoding) if data.hint_name else None,
|
||||
"hintAddress": data.hint_address.decode(encoding) if data.hint_address else None,
|
||||
}
|
||||
|
||||
return msg
|
||||
|
||||
|
||||
def _parse_spnego_resp(
|
||||
data: NegTokenResp,
|
||||
secret: typing.Optional[str] = None,
|
||||
encoding: typing.Optional[str] = None,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
supported_mech = parse_enum(data.supported_mech, enum_type=GSSMech) if data.supported_mech else None
|
||||
|
||||
response_token = None
|
||||
if data.response_token:
|
||||
response_token = parse_token(data.response_token, secret=secret, encoding=encoding)
|
||||
|
||||
msg = {
|
||||
"negState": parse_enum(data.neg_state) if data.neg_state is not None else None,
|
||||
"supportedMech": supported_mech,
|
||||
"responseToken": response_token,
|
||||
"mechListMIC": base64.b16encode(data.mech_list_mic).decode() if data.mech_list_mic is not None else None,
|
||||
}
|
||||
return msg
|
||||
|
||||
|
||||
def _parse_tls_handshake_client_hello(
|
||||
view: memoryview,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
protocol_version = TlsProtocolVersion(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
random = view[:32]
|
||||
view = view[32:]
|
||||
|
||||
session_id_len = struct.unpack("B", view[:1])[0]
|
||||
view = view[1:]
|
||||
|
||||
session_id = view[:session_id_len]
|
||||
view = view[session_id_len:]
|
||||
|
||||
cipher_suites_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
cipher_suites_view = view[:cipher_suites_len]
|
||||
view = view[cipher_suites_len:]
|
||||
|
||||
cipher_suites = []
|
||||
while cipher_suites_view:
|
||||
cs = TlsCipherSuite(struct.unpack(">H", cipher_suites_view[:2])[0])
|
||||
cipher_suites.append(f"{cs.name} - 0x{cs.value:04X}")
|
||||
cipher_suites_view = cipher_suites_view[2:]
|
||||
|
||||
compression_methods_len = struct.unpack("B", view[:1])[0]
|
||||
view = view[1:]
|
||||
compression_methods_view = view[:compression_methods_len]
|
||||
view = view[compression_methods_len:]
|
||||
|
||||
compression_methods = []
|
||||
while compression_methods_view:
|
||||
cm = TlsCompressionMethod(struct.unpack("B", compression_methods_view[:1])[0])
|
||||
compression_methods.append(parse_enum(cm))
|
||||
compression_methods_view = compression_methods_view[1:]
|
||||
|
||||
extensions_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
extensions_view = view[:extensions_len]
|
||||
view = view[extensions_len:]
|
||||
extensions = _parse_tls_extensions(extensions_view, True)
|
||||
|
||||
return {
|
||||
"ProtocolVersion": parse_enum(protocol_version),
|
||||
"Random": base64.b16encode(random).decode(),
|
||||
"SessionID": base64.b16encode(session_id).decode(),
|
||||
"CipherSuites": cipher_suites,
|
||||
"CompressionMethods": compression_methods,
|
||||
"Extensions": extensions,
|
||||
}
|
||||
|
||||
|
||||
def _parse_tls_handshake_server_hello(
|
||||
view: memoryview,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
protocol_version = TlsProtocolVersion(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
random = view[:32]
|
||||
view = view[32:]
|
||||
|
||||
session_id_len = struct.unpack("B", view[:1])[0]
|
||||
view = view[1:]
|
||||
|
||||
session_id = view[:session_id_len]
|
||||
view = view[session_id_len:]
|
||||
|
||||
cipher_suite = TlsCipherSuite(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
compression_method = TlsCompressionMethod(struct.unpack("B", view[:1])[0])
|
||||
view = view[1:]
|
||||
|
||||
extensions_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
extensions_view = view[:extensions_len]
|
||||
view = view[extensions_len:]
|
||||
extensions = _parse_tls_extensions(extensions_view, False)
|
||||
|
||||
return {
|
||||
"ProtocolVersion": parse_enum(protocol_version),
|
||||
"Random": base64.b16encode(random).decode(),
|
||||
"SessionID": base64.b16encode(session_id).decode(),
|
||||
"CipherSuite": f"{cipher_suite.name} - 0x{cipher_suite.value:04X}",
|
||||
"CompressionMethod": parse_enum(compression_method),
|
||||
"Extensions": extensions,
|
||||
}
|
||||
|
||||
|
||||
def _parse_tls_handshake_certificate_request(
|
||||
view: memoryview,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
cert_types_len = struct.unpack("B", view[:1])[0]
|
||||
view = view[1:]
|
||||
cert_types_view = view[:cert_types_len]
|
||||
view = view[cert_types_len:]
|
||||
|
||||
cert_types = []
|
||||
while cert_types_view:
|
||||
ct = TlsClientCertificateType(struct.unpack("B", cert_types_view[:1])[0])
|
||||
cert_types.append(parse_enum(ct))
|
||||
cert_types_view = cert_types_view[1:]
|
||||
|
||||
sig_algos_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
sig_algos_view = view[:sig_algos_len]
|
||||
view = view[sig_algos_len:]
|
||||
|
||||
sig_algos = []
|
||||
while sig_algos_view:
|
||||
algo = TlsSignatureScheme(struct.unpack(">H", sig_algos_view[:2])[0])
|
||||
sig_algos.append(parse_enum(algo))
|
||||
sig_algos_view = sig_algos_view[2:]
|
||||
|
||||
dn_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
dn_view = view[:dn_len]
|
||||
view = view[dn_len:]
|
||||
|
||||
dns = []
|
||||
while dn_view:
|
||||
entry_len = struct.unpack(">H", dn_view[:2])[0]
|
||||
dn_view = dn_view[2:]
|
||||
entry_view = dn_view[:entry_len]
|
||||
dn_view = dn_view[entry_len:]
|
||||
|
||||
for dn_entry in unpack_asn1_sequence(entry_view):
|
||||
for dn_set in unpack_asn1_sequence(dn_entry):
|
||||
dn_data = unpack_asn1(dn_set.b_data)[0]
|
||||
dn_oid, dn_str = unpack_asn1_sequence(dn_data)
|
||||
oid = DistinguishedNameType(unpack_asn1_object_identifier(dn_oid))
|
||||
|
||||
dns.append(
|
||||
{
|
||||
"OID": parse_enum(oid),
|
||||
"Value": dn_str.b_data.tobytes().decode("utf-8"),
|
||||
}
|
||||
)
|
||||
|
||||
return {
|
||||
"CertificateTypes": cert_types,
|
||||
"SignatureAlgorithms": sig_algos,
|
||||
"CertificateAuthorities": dns,
|
||||
}
|
||||
|
||||
|
||||
def _parse_tls_handshake_server_key_exchange(
|
||||
view: memoryview,
|
||||
protocol_version: TlsProtocolVersion,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
curve_type = TlsECCurveType(struct.unpack("B", view[:1])[0])
|
||||
view = view[1:]
|
||||
|
||||
curve = TlsSupportedGroup(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
pubkey_len = struct.unpack("B", view[:1])[0]
|
||||
view = view[1:]
|
||||
|
||||
pubkey = view[:pubkey_len].tobytes()
|
||||
view = view[pubkey_len:]
|
||||
|
||||
signature_algo = None
|
||||
if protocol_version >= TlsProtocolVersion.tls1_2:
|
||||
signature_algo = TlsSignatureScheme(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
signature_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
|
||||
signature = view[:signature_len].tobytes()
|
||||
|
||||
return {
|
||||
"CurveType": parse_enum(curve_type),
|
||||
"Curve": parse_enum(curve),
|
||||
"PublicKey": base64.b16encode(pubkey).decode(),
|
||||
"SignatureAlgorithm": parse_enum(signature_algo) if signature_algo else None,
|
||||
"Signature": base64.b16encode(signature).decode(),
|
||||
}
|
||||
|
||||
|
||||
def _parse_tls_extensions(
|
||||
view: memoryview,
|
||||
is_client_hello: bool,
|
||||
) -> typing.List[typing.Dict[str, typing.Any]]:
|
||||
extensions = []
|
||||
|
||||
while view:
|
||||
ext_type = TlsExtensionType(struct.unpack(">H", view[:2])[0])
|
||||
view = view[2:]
|
||||
|
||||
ext_len = struct.unpack(">H", view[:2])[0]
|
||||
view = view[2:]
|
||||
|
||||
ext_data = view[:ext_len]
|
||||
view = view[ext_len:]
|
||||
|
||||
data: typing.Any = None
|
||||
if ext_len == 0:
|
||||
data = None
|
||||
|
||||
elif ext_type == TlsExtensionType.server_name:
|
||||
data_len = struct.unpack(">H", ext_data[:2])[0]
|
||||
data_view = ext_data[2 : 2 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
name_type = TlsServerNameType(struct.unpack("B", data_view[:1])[0])
|
||||
name_len = struct.unpack(">H", data_view[1:3])[0]
|
||||
name = data_view[3 : 3 + name_len].tobytes().decode("utf-8")
|
||||
data.append(
|
||||
{
|
||||
"Type": parse_enum(name_type),
|
||||
"Name": name,
|
||||
}
|
||||
)
|
||||
data_view = data_view[3 + name_len :]
|
||||
|
||||
elif ext_type == TlsExtensionType.ec_point_formats:
|
||||
data_len = struct.unpack("B", ext_data[:1])[0]
|
||||
data_view = ext_data[1 : 1 + data_len]
|
||||
data = [parse_enum(TlsECPointFormat(b)) for b in list(data_view)]
|
||||
|
||||
elif ext_type == TlsExtensionType.supported_groups:
|
||||
data_len = struct.unpack(">H", ext_data[:2])[0]
|
||||
data_view = ext_data[2 : 2 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
data.append(parse_enum(TlsSupportedGroup(struct.unpack(">H", data_view[:2])[0])))
|
||||
data_view = data_view[2:]
|
||||
|
||||
elif ext_type == TlsExtensionType.application_layer_protocol_negotiation:
|
||||
data_len = struct.unpack(">H", ext_data[:2])[0]
|
||||
data_view = ext_data[2 : 2 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
alpn_len = struct.unpack("B", data_view[:1])[0]
|
||||
data_view = data_view[1:]
|
||||
data.append(data_view[:alpn_len].tobytes().decode())
|
||||
data_view = data_view[alpn_len:]
|
||||
|
||||
elif ext_type == TlsExtensionType.session_ticket:
|
||||
data = base64.b16encode(ext_data.tobytes()).decode()
|
||||
|
||||
elif ext_type == TlsExtensionType.signature_algorithms:
|
||||
data_len = struct.unpack(">H", ext_data[:2])[0]
|
||||
data_view = ext_data[2 : 2 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
data.append(parse_enum(TlsSignatureScheme(struct.unpack(">H", data_view[:2])[0])))
|
||||
data_view = data_view[2:]
|
||||
|
||||
elif ext_type == TlsExtensionType.supported_versions:
|
||||
if is_client_hello:
|
||||
data_len = struct.unpack("B", ext_data[:1])[0]
|
||||
data_view = ext_data[1 : 1 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
data.append(parse_enum(TlsProtocolVersion(struct.unpack(">H", data_view[:2])[0])))
|
||||
data_view = data_view[2:]
|
||||
|
||||
else:
|
||||
data = parse_enum(TlsProtocolVersion(struct.unpack(">H", ext_data[:2])[0]))
|
||||
|
||||
elif ext_type == TlsExtensionType.psk_key_exchange_modes:
|
||||
data_len = struct.unpack("B", ext_data[:1])[0]
|
||||
data_view = ext_data[1 : 1 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
data.append(parse_enum(TlsPskKeyExchangeMode(struct.unpack("B", data_view[:1])[0])))
|
||||
data_view = data_view[1:]
|
||||
|
||||
elif ext_type == TlsExtensionType.key_share:
|
||||
if is_client_hello:
|
||||
data_len = struct.unpack(">H", ext_data[:2])[0]
|
||||
data_view = ext_data[2 : 2 + data_len]
|
||||
data = []
|
||||
while data_view:
|
||||
key_share_group = TlsSupportedGroup(struct.unpack(">H", data_view[:2])[0])
|
||||
key_exchange_len = struct.unpack(">H", data_view[2:4])[0]
|
||||
key_exchange = data_view[4 : 4 + key_exchange_len].tobytes()
|
||||
|
||||
data.append(
|
||||
{
|
||||
"Group": parse_enum(key_share_group),
|
||||
"Key": base64.b16encode(key_exchange).decode(),
|
||||
}
|
||||
)
|
||||
data_view = data_view[4 + key_exchange_len :]
|
||||
else:
|
||||
key_share_group = TlsSupportedGroup(struct.unpack(">H", ext_data[:2])[0])
|
||||
key_exchange_len = struct.unpack(">H", ext_data[2:4])[0]
|
||||
key_exchange = ext_data[4 : 4 + key_exchange_len].tobytes()
|
||||
data = {
|
||||
"Group": parse_enum(key_share_group),
|
||||
"Key": base64.b16encode(key_exchange).decode(),
|
||||
}
|
||||
|
||||
formated_data = {
|
||||
"ExtensionType": parse_enum(ext_type),
|
||||
}
|
||||
if data is not None:
|
||||
formated_data["Data"] = data
|
||||
if data is not None or ext_data:
|
||||
formated_data["RawData"] = base64.b16encode(ext_data).decode()
|
||||
extensions.append(formated_data)
|
||||
|
||||
return extensions
|
||||
|
||||
|
||||
def main(args: typing.List[str]) -> None:
|
||||
"""Main program entry point."""
|
||||
parsed_args = parse_args(args)
|
||||
|
||||
if parsed_args.token:
|
||||
b_data = to_bytes(parsed_args.token)
|
||||
else:
|
||||
if parsed_args.file:
|
||||
file_path = os.path.abspath(os.path.expanduser(os.path.expandvars(parsed_args.file)))
|
||||
b_file_path = to_bytes(file_path)
|
||||
if not os.path.exists(b_file_path):
|
||||
raise ValueError("Cannot find file at path '%s'" % file_path)
|
||||
|
||||
with open(b_file_path, mode="rb") as fd:
|
||||
b_data = fd.read()
|
||||
else:
|
||||
b_data = sys.stdin.buffer.read()
|
||||
|
||||
if re.match(b"^[a-fA-F0-9\\s]+$", b_data):
|
||||
# Input data was a hex string.
|
||||
b_data = base64.b16decode(re.sub(b"[\\s]", b"", b_data.strip().upper()))
|
||||
if re.match(b"^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$", b_data):
|
||||
# Input data was a base64 string.
|
||||
b_data = base64.b64decode(b_data.strip())
|
||||
|
||||
token_info: typing.Union[typing.List, typing.Dict]
|
||||
if re.match(b"[\x00|\x14|\x15|\x16|\x17]\x03[\x01|\x02|\x03]", b_data):
|
||||
token_info = parse_tls_token(b_data)
|
||||
else:
|
||||
token_info = parse_token(b_data, secret=parsed_args.secret, encoding=parsed_args.encoding)
|
||||
|
||||
if parsed_args.output_format == "yaml" and HAS_YAML:
|
||||
y = yaml.YAML()
|
||||
y.default_flow_style = False
|
||||
y.dump(token_info, sys.stdout)
|
||||
else:
|
||||
print(json.dumps(token_info, indent=4))
|
||||
|
||||
|
||||
def parse_args(args: typing.List[str]) -> argparse.Namespace:
|
||||
"""Parse and return args."""
|
||||
parser = argparse.ArgumentParser(description="Parse Microsoft authentication tokens into a human readable format.")
|
||||
|
||||
data = parser.add_mutually_exclusive_group()
|
||||
|
||||
data.add_argument(
|
||||
"-t", "--token", dest="token", help="Raw base64 encoded or hex string token as a command line argument."
|
||||
)
|
||||
|
||||
data.add_argument(
|
||||
"-f",
|
||||
"--file",
|
||||
default="",
|
||||
dest="file",
|
||||
help="Path to file that contains raw bytes, base64, or hex string of token to parse, Defaults to reading from "
|
||||
"stdin if neither -t or -f is specified.",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--encoding",
|
||||
dest="encoding",
|
||||
help="The encoding to use when trying to decode text fields from bytes in tokens that don't have a negotiated "
|
||||
"encoding. This defaults to 'windows-1252' for NTLM tokens and 'utf-8' for Kerberos/SPNEGO tokens.",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--format",
|
||||
"--output-format",
|
||||
choices=["json", "yaml"],
|
||||
default="json",
|
||||
dest="output_format",
|
||||
type=lambda s: s.lower(),
|
||||
help="Set the output format of the token, default is (json). Using yaml requires the ruamel.yaml Python "
|
||||
"library to be installed pip install pyspnego[yaml].",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--secret",
|
||||
"--password",
|
||||
dest="secret",
|
||||
default=None,
|
||||
help="Optional info that is the secret information for a protocol that can be used to decrypt encrypted "
|
||||
"fields and/or derive the unique session key in the exchange. This is currently only supported by NTLM "
|
||||
"tokens to generate the session key.",
|
||||
)
|
||||
|
||||
if HAS_ARGCOMPLETE:
|
||||
argcomplete.autocomplete(parser)
|
||||
|
||||
parsed_args = parser.parse_args(args)
|
||||
|
||||
if parsed_args.output_format == "yaml" and not HAS_YAML:
|
||||
raise ValueError("Cannot output as yaml as ruamel.yaml is not installed.")
|
||||
|
||||
return parsed_args
|
||||
|
||||
|
||||
def parse_token(
|
||||
b_data: bytes,
|
||||
secret: typing.Optional[str] = None,
|
||||
encoding: typing.Optional[str] = None,
|
||||
mech: typing.Optional[typing.Union[str, GSSMech]] = None,
|
||||
) -> typing.Dict[str, typing.Any]:
|
||||
"""
|
||||
:param b_data: A byte string of the token to parse. This can be a NTLM or GSSAPI (SPNEGO/Kerberos) token.
|
||||
:param secret: The secret data used to decrypt fields and/or derive session keys.
|
||||
:param encoding: The encoding to use for token fields that represent text. This is only used for fields where there
|
||||
is no negotiation for the encoding of that particular field. Defaults to 'windows-1252' for NTLM and 'utf-8'
|
||||
for Kerberos.
|
||||
:return: A dict containing the parsed token data.
|
||||
"""
|
||||
gss_mech: typing.Optional[GSSMech] = None
|
||||
if mech and not isinstance(mech, GSSMech):
|
||||
gss_mech = GSSMech.from_oid(mech)
|
||||
|
||||
try:
|
||||
token = unpack_token(b_data, mech=gss_mech, unwrap=True, encoding=encoding)
|
||||
except Exception as e:
|
||||
return {
|
||||
"MessageType": "Unknown - Failed to parse see Data for more details.",
|
||||
"Data": "Failed to parse token: %s" % str(e),
|
||||
"RawData": base64.b16encode(b_data).decode(),
|
||||
}
|
||||
|
||||
msg_type = "Unknown"
|
||||
data: typing.Union[str, typing.Dict[str, typing.Any]] = "Failed to parse SPNEGO token due to unknown mech type"
|
||||
|
||||
# SPNEGO messages.
|
||||
if isinstance(token, InitialContextToken):
|
||||
msg_type = "SPNEGO InitialContextToken"
|
||||
data = {
|
||||
"thisMech": parse_enum(token.this_mech, enum_type=GSSMech),
|
||||
"innerContextToken": parse_token(
|
||||
token.inner_context_token, mech=token.this_mech, secret=secret, encoding=encoding
|
||||
),
|
||||
}
|
||||
|
||||
elif isinstance(token, NegTokenInit):
|
||||
data = _parse_spnego_init(token, secret, encoding)
|
||||
if "negHints" in data:
|
||||
msg_type = "SPNEGO NegTokenInit2"
|
||||
|
||||
else:
|
||||
msg_type = "SPNEGO NegTokenInit"
|
||||
|
||||
elif isinstance(token, NegTokenResp):
|
||||
msg_type = "SPNEGO NegTokenResp"
|
||||
data = _parse_spnego_resp(token, secret, encoding)
|
||||
|
||||
# NTLM messages.
|
||||
elif isinstance(token, (Negotiate, Challenge, Authenticate)):
|
||||
msg_type = parse_enum(token.MESSAGE_TYPE)
|
||||
|
||||
if isinstance(token, Negotiate):
|
||||
data = _parse_ntlm_negotiate(token)
|
||||
|
||||
elif isinstance(token, Challenge):
|
||||
data = _parse_ntlm_challenge(token)
|
||||
|
||||
else:
|
||||
data = _parse_ntlm_authenticate(token, secret)
|
||||
|
||||
# Kerberos messages.
|
||||
elif isinstance(token, KerberosV5Msg):
|
||||
msg_type = parse_enum(token.MESSAGE_TYPE)
|
||||
data = parse_kerberos_token(token, secret, encoding)
|
||||
|
||||
return {
|
||||
"MessageType": msg_type,
|
||||
"Data": data,
|
||||
"RawData": base64.b16encode(b_data).decode(),
|
||||
}
|
||||
|
||||
|
||||
def parse_tls_token(
|
||||
b_data: bytes,
|
||||
) -> typing.List[typing.Dict[str, typing.Any]]:
|
||||
"""
|
||||
:param b_data: A byte string of the TLS token to parse.
|
||||
:return: A dict containing the parsed TLS token data.
|
||||
"""
|
||||
view = memoryview(b_data)
|
||||
|
||||
res = []
|
||||
while view:
|
||||
content_type = TlsContentType(struct.unpack("B", view[:1])[0])
|
||||
protocol_version = TlsProtocolVersion(struct.unpack(">H", view[1:3])[0])
|
||||
token_length = struct.unpack(">H", view[3:5])[0]
|
||||
token_view = view[5 : 5 + token_length]
|
||||
|
||||
data: typing.Optional[typing.List[typing.Dict[str, typing.Any]]] = None
|
||||
if content_type == TlsContentType.handshake:
|
||||
data = []
|
||||
|
||||
while token_view:
|
||||
handshake_type = TlsHandshakeMessageType(struct.unpack("B", token_view[:1])[0])
|
||||
message_len = struct.unpack(">L", b"\x00" + token_view[1:4])[0]
|
||||
handshake_view = token_view[4 : 4 + message_len]
|
||||
|
||||
handshake_data: typing.Optional[typing.Dict[str, typing.Any]] = None
|
||||
if handshake_type == TlsHandshakeMessageType.client_hello:
|
||||
handshake_data = _parse_tls_handshake_client_hello(handshake_view)
|
||||
|
||||
elif handshake_type == TlsHandshakeMessageType.server_hello:
|
||||
handshake_data = _parse_tls_handshake_server_hello(handshake_view)
|
||||
|
||||
elif handshake_type == TlsHandshakeMessageType.certificate:
|
||||
cert_len = struct.unpack(">I", b"\x00" + handshake_view[:3])[0]
|
||||
handshake_data = {
|
||||
"Certificate": base64.b16encode(handshake_view[3 : 3 + cert_len].tobytes()).decode(),
|
||||
}
|
||||
|
||||
elif handshake_type == TlsHandshakeMessageType.certificate_request:
|
||||
handshake_data = _parse_tls_handshake_certificate_request(handshake_view)
|
||||
|
||||
elif handshake_type == TlsHandshakeMessageType.server_key_exchange:
|
||||
handshake_data = _parse_tls_handshake_server_key_exchange(handshake_view, protocol_version)
|
||||
|
||||
elif handshake_type == TlsHandshakeMessageType.client_key_exchange:
|
||||
key_len = struct.unpack("B", handshake_view[:1])[0]
|
||||
handshake_data = {
|
||||
"PublicKey": base64.b16encode(handshake_view[1 : 1 + key_len].tobytes()).decode(),
|
||||
}
|
||||
|
||||
formatted_handshake_data: typing.Dict[str, typing.Any] = {
|
||||
"HandshakeType": parse_enum(handshake_type),
|
||||
}
|
||||
if handshake_data is not None:
|
||||
formatted_handshake_data["Data"] = handshake_data
|
||||
formatted_handshake_data["RawData"] = base64.b16encode(token_view[: 4 + message_len].tobytes()).decode()
|
||||
data.append(formatted_handshake_data)
|
||||
token_view = token_view[4 + message_len :]
|
||||
|
||||
formatted_data: typing.Dict[str, typing.Any] = {
|
||||
"ContentType": parse_enum(content_type),
|
||||
"ProtocolVersion": parse_enum(protocol_version),
|
||||
}
|
||||
if data is not None:
|
||||
formatted_data["Data"] = data
|
||||
|
||||
formatted_data["RawData"] = base64.b16encode(view[: 5 + token_length].tobytes()).decode()
|
||||
|
||||
res.append(formatted_data)
|
||||
view = view[5 + token_length :]
|
||||
|
||||
return res
|
||||
|
||||
|
||||
if __name__ == "__main__": # pragma: nocover
|
||||
main(sys.argv[1:])
|
||||
Reference in New Issue
Block a user