ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
"""
ARES Linux Active Directory Binary Parsing & IPC Engine
Pure standard-library Python binary parsers for:
- Samba TDB & SSSD LDB database records (offline hash & credential extraction)
- Kerberos ccache v4 binary structures (/tmp, /run/user)
- Kerberos keytab binary files (/etc/krb5.keytab, version 0x0502)
- Next-Gen KCM (Kerberos Credential Manager) IPC Unix socket client
- Pure Python ASN.1 DER KRB-CRED (.kirbi) bi-directional encoder/decoder
100% subprocess-free (execve evasion) and zero external C-extension dependencies.
"""
from __future__ import annotations
import io
import os
import socket
import struct
import time
from typing import Any
# ─────────────────────────────────────────────────────────────────────────────
# 1. Samba TDB & SSSD LDB Binary Parser
# ─────────────────────────────────────────────────────────────────────────────
TDB_MAGIC_BIG = 0x2601196D
TDB_MAGIC_LITTLE = 0x6D190126
TDB_DEAD_MAGIC_BIG = 0x26011999
TDB_DEAD_MAGIC_LITTLE = 0x99190126
class TDBParser:
"""
Pure Python parser for Samba Trivial Database (TDB) and SSSD LDB files.
Reads database records without locking or invoking external binaries.
"""
@classmethod
def parse_records(cls, data: bytes) -> list[tuple[bytes, bytes]]:
"""
Traverses TDB binary data and returns all active (key, value) pairs.
Uses both structural record header traversal and fallback boundary scanning.
"""
if len(data) < 24:
return []
# Detect endianness directly from magic bytes
if data[:4] in (b"\x26\x01\x19\x6d", b"\x26\x01\x19\x99"):
endian = ">"
elif data[:4] in (b"\x6d\x19\x01\x26", b"\x99\x19\x01\x26"):
endian = "<"
else:
endian = "<"
records: list[tuple[bytes, bytes]] = []
seen_keys: set[bytes] = set()
offset = 0
while offset + 24 <= len(data):
try:
rec_magic = struct.unpack(f"{endian}I", data[offset + 20 : offset + 24])[0]
except struct.error:
break
if rec_magic in (TDB_MAGIC_BIG, TDB_MAGIC_LITTLE):
try:
next_rec, rec_len, key_len, data_len, full_hash, _ = struct.unpack(
f"{endian}IIIIII", data[offset : offset + 24]
)
except struct.error:
offset += 4
continue
if 0 < key_len < 65536 and 0 <= data_len < 20_000_000:
if offset + 24 + key_len + data_len <= len(data):
key = data[offset + 24 : offset + 24 + key_len]
val = data[offset + 24 + key_len : offset + 24 + key_len + data_len]
if key and key not in seen_keys:
seen_keys.add(key)
records.append((key, val))
if rec_len >= key_len + data_len:
offset += (24 + rec_len + 3) & ~3
continue
offset += 4
# Fallback heuristic: search for key markers if header traversal produced minimal records
if not records:
cls._heuristic_scan(data, records, seen_keys)
return records
@classmethod
def _heuristic_scan(
cls,
data: bytes,
records: list[tuple[bytes, bytes]],
seen_keys: set[bytes],
) -> None:
"""Fallback scanner for string-oriented Samba and SSSD keys."""
markers = [b"SECRETS/", b"name=", b"dn: ", b"cn="]
for marker in markers:
idx = 0
while True:
idx = data.find(marker, idx)
if idx == -1:
break
# Scan backwards for key length if possible or extract delimited key
end_line = data.find(b"\x00", idx)
if end_line != -1 and end_line - idx < 256:
key = data[idx:end_line]
# Estimate value: scan after null byte up to next null or record boundary
val_start = end_line + 1
val_end = data.find(b"\x00\x00", val_start)
if val_end == -1:
val_end = min(val_start + 1024, len(data))
val = data[val_start:val_end]
if key not in seen_keys:
seen_keys.add(key)
records.append((key, val))
idx += 1
def parse_sssd_ldb_entry(record_data: bytes) -> dict[str, Any]:
"""
Parses LDIF-style SSSD LDB entry payload into structured user attributes.
Extracts cached passwords ($6$, $1$, $y$), PAC buffers, and group memberships.
"""
entry: dict[str, Any] = {
"attributes": {},
"hashes": [],
"groups": [],
"is_domain_admin": False,
}
try:
text = record_data.decode("utf-8", errors="replace")
except Exception:
text = record_data.decode("latin-1", errors="replace")
for line in text.splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
if ":" in line:
key, _, val = line.partition(":")
key = key.strip().lower()
val = val.strip()
if key not in entry["attributes"]:
entry["attributes"][key] = val
if key in ("userpassword", "cachedpassword", "passwordhash"):
if val.startswith(("$6$", "$1$", "$y$", "$5$")):
entry["hashes"].append(val)
elif key == "memberof":
entry["groups"].append(val)
val_upper = val.upper()
if (
"DOMAIN ADMINS" in val_upper
or "ENTERPRISE ADMINS" in val_upper
or "ADMINISTRATORS" in val_upper
or "SUDO" in val_upper
or "WHEEL" in val_upper
):
entry["is_domain_admin"] = True
return entry
# ─────────────────────────────────────────────────────────────────────────────
# 2. Kerberos ccache v4 Binary Parser & Builder
# ─────────────────────────────────────────────────────────────────────────────
class CcacheParser:
"""
Pure Python parser and builder for Kerberos Credential Cache (ccache) v4 binary format.
Format version: 0x0504 (big-endian).
"""
@classmethod
def parse(
cls,
data: bytes,
include_expired: bool = False,
now: int | None = None,
) -> tuple[str | None, list[dict[str, Any]]]:
if now is None:
now = int(time.time())
if len(data) < 4:
return None, []
version = struct.unpack(">H", data[0:2])[0]
if version != 0x0504:
return None, []
offset = 2
header_len = struct.unpack(">H", data[offset : offset + 2])[0]
offset += 2 + header_len
default_principal, offset = cls._read_principal(data, offset)
if default_principal is None:
return None, []
tickets: list[dict[str, Any]] = []
while offset < len(data):
cred, next_offset = cls._read_credential(data, offset)
if cred is None or next_offset <= offset:
break
offset = next_offset
is_expired = cred["endtime"] < now
if is_expired and not include_expired:
continue
cred["is_expired"] = is_expired
cred["is_tgt"] = "krbtgt" in cred["server"]
cred["endtime_str"] = time.strftime(
"%Y-%m-%d %H:%M:%S UTC",
time.gmtime(cred["endtime"]),
)
tickets.append(cred)
return default_principal, tickets
@classmethod
def _read_string(cls, data: bytes, offset: int) -> tuple[str | None, int]:
if offset + 4 > len(data):
return None, offset
length = struct.unpack(">I", data[offset : offset + 4])[0]
offset += 4
if offset + length > len(data):
return None, offset
raw = data[offset : offset + length]
offset += length
return raw.decode("latin-1", errors="replace"), offset
@classmethod
def _read_principal(cls, data: bytes, offset: int) -> tuple[str | None, int]:
if offset + 8 > len(data):
return None, offset
name_type, num_components = struct.unpack(">II", data[offset : offset + 8])
offset += 8
realm, offset = cls._read_string(data, offset)
if realm is None:
return None, offset
components: list[str] = []
for _ in range(num_components):
comp, offset = cls._read_string(data, offset)
if comp is None:
return None, offset
components.append(comp)
full_principal = "/".join(components) + "@" + realm
return full_principal, offset
@classmethod
def _read_credential(cls, data: bytes, offset: int) -> tuple[dict[str, Any] | None, int]:
start = offset
client, offset = cls._read_principal(data, offset)
if client is None:
return None, start
server, offset = cls._read_principal(data, offset)
if server is None:
return None, start
# Keyblock
if offset + 6 > len(data):
return None, start
keytype, keylen = struct.unpack(">HI", data[offset : offset + 6])
offset += 6
if offset + keylen > len(data):
return None, start
keydata = data[offset : offset + keylen]
offset += keylen
# Timestamps
if offset + 16 > len(data):
return None, start
authtime, starttime, endtime, renew_till = struct.unpack(">IIII", data[offset : offset + 16])
offset += 16
# is_skey (1) + flags (4)
if offset + 5 > len(data):
return None, start
is_skey, flags = struct.unpack(">BI", data[offset : offset + 5])
offset += 5
# Addresses
if offset + 4 > len(data):
return None, start
num_addresses = struct.unpack(">I", data[offset : offset + 4])[0]
offset += 4
for _ in range(num_addresses):
if offset + 6 > len(data):
return None, start
_, addr_len = struct.unpack(">HI", data[offset : offset + 6])
offset += 6 + addr_len
# Authdata
if offset + 4 > len(data):
return None, start
num_authdata = struct.unpack(">I", data[offset : offset + 4])[0]
offset += 4
for _ in range(num_authdata):
if offset + 6 > len(data):
return None, start
_, ad_len = struct.unpack(">HI", data[offset : offset + 6])
offset += 6 + ad_len
# Ticket payload
if offset + 4 > len(data):
return None, start
ticket_len = struct.unpack(">I", data[offset : offset + 4])[0]
offset += 4
if offset + ticket_len > len(data):
return None, start
ticket_bytes = data[offset : offset + ticket_len]
offset += ticket_len
# Second ticket
if offset + 4 > len(data):
return None, start
second_len = struct.unpack(">I", data[offset : offset + 4])[0]
offset += 4 + second_len
return {
"client": client,
"server": server,
"keytype": keytype,
"keydata": keydata.hex(),
"authtime": authtime,
"starttime": starttime,
"endtime": endtime,
"renew_till": renew_till,
"flags": flags,
"is_skey": is_skey,
"ticket_bytes": ticket_bytes,
"ticket_len": ticket_len,
}, offset
def build_ccache_v4(default_principal: str, tickets: list[dict[str, Any]]) -> bytes:
"""
Serializes a principal name and list of ticket dictionaries into a standard
Kerberos ccache v4 binary stream.
"""
buf = io.BytesIO()
# Version 0x0504 + 0 header length
buf.write(struct.pack(">HH", 0x0504, 0))
def write_principal(p_str: str) -> None:
if "@" in p_str:
comps_str, realm = p_str.split("@", 1)
else:
comps_str, realm = p_str, ""
comps = comps_str.split("/") if comps_str else []
buf.write(struct.pack(">II", 1, len(comps)))
realm_bytes = realm.encode("latin-1")
buf.write(struct.pack(">I", len(realm_bytes)) + realm_bytes)
for c in comps:
cb = c.encode("latin-1")
buf.write(struct.pack(">I", len(cb)) + cb)
write_principal(default_principal)
for t in tickets:
write_principal(t["client"])
write_principal(t["server"])
keydata = bytes.fromhex(t.get("keydata", ""))
buf.write(struct.pack(">HI", int(t.get("keytype", 18)), len(keydata)) + keydata)
buf.write(
struct.pack(
">IIIIBI",
int(t.get("authtime", 0)),
int(t.get("starttime", 0)),
int(t.get("endtime", 0)),
int(t.get("renew_till", 0)),
int(t.get("is_skey", 0)),
int(t.get("flags", 0x40810000)),
)
)
# Addresses (0) + Authdata (0)
buf.write(struct.pack(">II", 0, 0))
# Ticket payload
ticket_bytes = t.get("ticket_bytes", b"")
buf.write(struct.pack(">I", len(ticket_bytes)) + ticket_bytes)
# Second ticket (0)
buf.write(struct.pack(">I", 0))
return buf.getvalue()
# ─────────────────────────────────────────────────────────────────────────────
# 3. Kerberos Keytab Binary Parser (Version 0x0502)
# ─────────────────────────────────────────────────────────────────────────────
ENCTYPE_MAP = {
1: "des-cbc-crc",
3: "des-cbc-md5",
16: "des3-cbc-sha1",
17: "aes128-cts-hmac-sha1-96",
18: "aes256-cts-hmac-sha1-96",
23: "rc4-hmac",
}
class KeytabParser:
"""
Pure Python parser for Kerberos keytab binary files (/etc/krb5.keytab).
Conforms to RFC keytab file format standard version 0x0502.
"""
@classmethod
def parse(cls, data: bytes) -> list[dict[str, Any]]:
entries: list[dict[str, Any]] = []
if len(data) < 2:
return entries
# File format version: 0x0502
version = struct.unpack(">H", data[:2])[0]
if version not in (0x0502, 0x0501):
return entries
offset = 2
while offset + 4 <= len(data):
size = struct.unpack(">i", data[offset : offset + 4])[0]
offset += 4
if size <= 0:
# Deleted entry or invalid
if size < 0:
offset += abs(size)
continue
entry_end = offset + size
if entry_end > len(data):
break
entry_data = data[offset:entry_end]
offset = entry_end
parsed_entry = cls._parse_entry(entry_data)
if parsed_entry:
entries.append(parsed_entry)
return entries
@classmethod
def _parse_entry(cls, data: bytes) -> dict[str, Any] | None:
if len(data) < 14:
return None
offset = 0
num_components = struct.unpack(">h", data[offset : offset + 2])[0]
offset += 2
# Realm
if offset + 2 > len(data):
return None
realm_len = struct.unpack(">H", data[offset : offset + 2])[0]
offset += 2
if offset + realm_len > len(data):
return None
realm = data[offset : offset + realm_len].decode("latin-1", errors="replace")
offset += realm_len
# Components
components: list[str] = []
for _ in range(num_components):
if offset + 2 > len(data):
return None
comp_len = struct.unpack(">H", data[offset : offset + 2])[0]
offset += 2
if offset + comp_len > len(data):
return None
comp = data[offset : offset + comp_len].decode("latin-1", errors="replace")
offset += comp_len
components.append(comp)
# Name type (4), timestamp (4), vno (1), keytype (2), keylen (2)
if offset + 13 > len(data):
return None
name_type, timestamp, vno, keytype, keylen = struct.unpack(
">IIBHH", data[offset : offset + 13]
)
offset += 13
if offset + keylen > len(data):
return None
keydata = data[offset : offset + keylen]
offset += keylen
# vno32 if available
vno32 = vno
if offset + 4 <= len(data):
vno32 = struct.unpack(">I", data[offset : offset + 4])[0]
principal_str = "/".join(components) + "@" + realm
enctype_str = ENCTYPE_MAP.get(keytype, f"enctype-{keytype}")
return {
"principal": principal_str,
"realm": realm,
"components": components,
"name_type": name_type,
"timestamp": timestamp,
"timestamp_str": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(timestamp)),
"vno": vno32,
"keytype": keytype,
"enctype": enctype_str,
"key_hex": keydata.hex(),
"key_len": keylen,
}
# ─────────────────────────────────────────────────────────────────────────────
# 4. Next-Gen Linux KCM (Kerberos Credential Manager) IPC Client
# ─────────────────────────────────────────────────────────────────────────────
class KCMClient:
"""
Pure Python client for Kerberos Credential Manager (KCM) Unix domain socket.
Targets /var/run/sss/pipes/kcm and /run/.heim_org.h5l.kcm-socket without subprocesses.
Supported on modern Linux distributions (RHEL 8/9, Ubuntu 22.04/24.04).
"""
KCM_OP_GET_DEFAULT_CACHE = 1
KCM_OP_GET_CACHE_LIST = 18
DEFAULT_SOCKETS = [
"/var/run/sss/pipes/kcm",
"/run/.heim_org.h5l.kcm-socket",
]
@classmethod
def is_available(cls) -> str | None:
"""Returns the first active KCM Unix domain socket path if accessible."""
if not hasattr(socket, "AF_UNIX"):
return None
for path in cls.DEFAULT_SOCKETS:
if os.path.exists(path) and os.access(path, os.R_OK | os.W_OK):
return path
return None
@classmethod
def get_cache_list(cls, socket_path: str) -> list[str]:
"""Queries the KCM daemon for available credential cache names."""
if not hasattr(socket, "AF_UNIX"):
return []
caches: list[str] = []
try:
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.settimeout(2.0)
sock.connect(socket_path)
# Request: len (4), major (2), minor (2), opcode (2)
req = struct.pack(">IHHI", 8, 1, 0, cls.KCM_OP_GET_CACHE_LIST)
sock.sendall(req)
resp_hdr = sock.recv(8)
if len(resp_hdr) == 8:
resp_len, status = struct.unpack(">II", resp_hdr)
if status == 0 and resp_len > 4:
payload = sock.recv(resp_len - 4)
# Payload is null-terminated strings
for name in payload.split(b"\x00"):
decoded = name.decode("utf-8", errors="replace").strip()
if decoded:
caches.append(decoded)
sock.close()
except Exception:
pass
return caches
# ─────────────────────────────────────────────────────────────────────────────
class KirbiParseError(ValueError):
"""Raised when parsing .kirbi / KRB-CRED ASN.1 DER data fails."""
# 5. Pure Python ASN.1 DER KRB-CRED (.kirbi) Codec
# ─────────────────────────────────────────────────────────────────────────────
class KirbiASN1Codec:
"""
Pure Python ASN.1 DER serializer & deserializer for Kerberos KRB-CRED (RFC 4120).
Enables lossless in-memory conversion between Linux ccache v4 and Windows .kirbi.
Zero external dependencies (does not require pyasn1 or impacket).
"""
@classmethod
def encode_kirbi(cls, ticket_data: dict[str, Any]) -> bytes:
"""
Encodes Kerberos ticket details into standard ASN.1 KRB-CRED (.kirbi) DER bytes.
"""
ticket_raw = ticket_data.get("ticket_bytes", b"")
if not ticket_raw:
# Synthetic placeholder ticket if none present
ticket_raw = cls._der_sequence([
cls._der_tagged(0, cls._der_integer(5)),
cls._der_tagged(1, cls._der_string(ticket_data.get("server", "krbtgt"))),
cls._der_tagged(2, cls._der_sequence([])),
])
# KRB-CRED-INFO structure
keytype = ticket_data.get("keytype", 18)
keydata = bytes.fromhex(ticket_data.get("keydata", ""))
keyblock = cls._der_sequence([
cls._der_tagged(0, cls._der_integer(keytype)),
cls._der_tagged(1, cls._der_octet_string(keydata)),
])
pname = ticket_data.get("client", "[email protected]")
client_tag = cls._der_tagged(1, cls._der_string(pname))
server_tag = cls._der_tagged(3, cls._der_string(ticket_data.get("server", "krbtgt")))
flags_val = int(ticket_data.get("flags", 0x40810000))
flags_tag = cls._der_tagged(2, cls._der_integer(flags_val))
authtime_tag = cls._der_tagged(4, cls._der_integer(int(ticket_data.get("authtime", 0))))
starttime_tag = cls._der_tagged(5, cls._der_integer(int(ticket_data.get("starttime", 0))))
endtime_tag = cls._der_tagged(6, cls._der_integer(int(ticket_data.get("endtime", 0))))
cred_info = cls._der_sequence([
cls._der_tagged(0, keyblock),
client_tag,
flags_tag,
server_tag,
authtime_tag,
starttime_tag,
endtime_tag,
])
enc_part = cls._der_sequence([
cls._der_tagged(0, cls._der_integer(0)), # enctype 0 (plaintext krb-cred)
cls._der_tagged(2, cls._der_octet_string(cls._der_sequence([cred_info]))),
])
# KRB-CRED SEQUENCE
krb_cred_seq = cls._der_sequence([
cls._der_tagged(0, cls._der_integer(5)), # pvno = 5
cls._der_tagged(1, cls._der_integer(22)), # msg-type = 22 (KRB-CRED)
cls._der_tagged(2, cls._der_sequence([ticket_raw])),
cls._der_tagged(3, enc_part),
])
# APPLICATION 22 tag (0x76)
return b"\x76" + cls._encode_length(len(krb_cred_seq)) + krb_cred_seq
@classmethod
def decode_kirbi(cls, data: bytes) -> dict[str, Any]:
"""
Extracts ticket bytes, client/server principals, validity period, and genuine
session key from standard RFC 4120 / Mimikatz / Rubeus .kirbi ASN.1 DER bytes.
Raises KirbiParseError on invalid or truncated data.
"""
if len(data) < 4:
raise KirbiParseError("Invalid kirbi payload: too short.")
# Application 22 header: 0x76 (or raw sequence 0x30)
if data[0] not in (0x76, 0x30):
raise KirbiParseError(f"Invalid kirbi format: unexpected root tag 0x{data[0]:02x}")
try:
root_res = cls._parse_der_tlv(data, 0)
if not root_res:
raise KirbiParseError("Empty or malformed kirbi root payload.")
_, _, _, root_val, _ = root_res
# If wrapped in Application 22 (0x76), the root_val may contain a SEQUENCE (0x30)
first_items = cls._parse_all_tlv(root_val)
if len(first_items) == 1 and first_items[0][0] == 0 and first_items[0][2] == 16:
krb_cred_items = cls._parse_all_tlv(first_items[0][3])
else:
krb_cred_items = first_items
krb_dict = {num: val for _, _, num, val in krb_cred_items}
# 1. Extract raw ticket
raw_ticket = b""
if 2 in krb_dict:
tkt_seq = cls._parse_all_tlv(krb_dict[2])
if tkt_seq:
raw_ticket = tkt_seq[0][3]
# 2. Extract enc-part (tag 3)
if 3 not in krb_dict:
raise KirbiParseError("Missing enc-part tag [3] in KRB-CRED structure.")
enc_part_items = cls._parse_all_tlv(krb_dict[3])
if enc_part_items and enc_part_items[0][0] == 0 and enc_part_items[0][2] == 16:
enc_fields = cls._parse_all_tlv(enc_part_items[0][3])
else:
enc_fields = enc_part_items
enc_dict = {num: val for _, _, num, val in enc_fields}
# In RFC 4120 EncryptedData: [0] enctype, [2] cipher
cipher_bytes = enc_dict.get(2, b"")
if not cipher_bytes:
raise KirbiParseError("Missing cipher tag [2] in KRB-CRED enc-part.")
# Cipher may be OCTET STRING (tag 4) wrapping SEQUENCE OF KrbCredInfo
cipher_tlv = cls._parse_all_tlv(cipher_bytes)
if cipher_tlv and cipher_tlv[0][2] == 4:
c_data = cipher_tlv[0][3]
else:
c_data = cipher_bytes
# Inside cipher is SEQUENCE OF KrbCredInfo (or EncKrbCredPart [APPLICATION 29])
c_items = cls._parse_all_tlv(c_data)
if c_items and c_items[0][0] in (0, 1) and c_items[0][2] in (16, 29):
cred_list = cls._parse_all_tlv(c_items[0][3])
# Could be [0] ticket-info SEQUENCE OF KrbCredInfo
if cred_list and cred_list[0][2] == 0:
cred_list = cls._parse_all_tlv(cred_list[0][3])
if cred_list and cred_list[0][2] == 16:
cred_info_fields = cls._parse_all_tlv(cred_list[0][3])
else:
cred_info_fields = cred_list
else:
cred_info_fields = c_items
info_dict = {num: val for _, _, num, val in cred_info_fields}
# 3. Session Key (tag 0: EncryptionKey [0] keytype, [1] keyvalue)
keyblock = info_dict.get(0, b"")
key_items = cls._parse_all_tlv(keyblock)
if key_items and key_items[0][2] == 16:
key_items = cls._parse_all_tlv(key_items[0][3])
key_dict = {num: val for _, _, num, val in key_items}
keytype = 18
if 0 in key_dict:
ktype_tlv = cls._parse_all_tlv(key_dict[0])
if ktype_tlv:
keytype = int.from_bytes(ktype_tlv[0][3], byteorder="big")
keydata = ""
if 1 in key_dict:
kdata_tlv = cls._parse_all_tlv(key_dict[1])
if kdata_tlv:
keydata = kdata_tlv[0][3].hex()
# 4. Client Principal
client = ""
if 1 in info_dict:
c_tlv = cls._parse_all_tlv(info_dict[1])
if c_tlv and c_tlv[0][2] in (12, 22, 27, 4):
client = c_tlv[0][3].decode("utf-8", errors="replace")
# RFC 4120 standard: prealm (tag 1) and pname (tag 2)
if not client and 2 in info_dict:
pname_items = cls._parse_all_tlv(info_dict[2])
realm = ""
if 1 in info_dict:
r_tlv = cls._parse_all_tlv(info_dict[1])
if r_tlv:
realm = r_tlv[0][3].decode("utf-8", errors="replace")
names = []
for _, _, _, nv in pname_items:
for _, _, _, sv in cls._parse_all_tlv(nv):
names.append(sv.decode("utf-8", errors="replace"))
if names:
client = "/".join(names) + (f"@{realm}" if realm else "")
# 5. Server Principal
server = ""
if 3 in info_dict:
s_tlv = cls._parse_all_tlv(info_dict[3])
if s_tlv and s_tlv[0][2] in (12, 22, 27, 4):
server = s_tlv[0][3].decode("utf-8", errors="replace")
# RFC 4120 standard: srealm (tag 8) and sname (tag 9)
if not server and 9 in info_dict:
sname_items = cls._parse_all_tlv(info_dict[9])
srealm = ""
if 8 in info_dict:
r_tlv = cls._parse_all_tlv(info_dict[8])
if r_tlv:
srealm = r_tlv[0][3].decode("utf-8", errors="replace")
snames = []
for _, _, _, nv in sname_items:
for _, _, _, sv in cls._parse_all_tlv(nv):
snames.append(sv.decode("utf-8", errors="replace"))
if snames:
server = "/".join(snames) + (f"@{srealm}" if srealm else "")
# 6. Validity period & Flags
def _get_int(tag: int, default: int = 0) -> int:
if tag in info_dict:
tlv = cls._parse_all_tlv(info_dict[tag])
if tlv:
return int.from_bytes(tlv[0][3], byteorder="big")
return default
flags = _get_int(2, 0x40810000)
authtime = _get_int(4, 0)
starttime = _get_int(5, 0)
endtime = _get_int(6, 0)
renew_till = _get_int(7, 0)
return {
"client": client or "[email protected]",
"server": server or "krbtgt/[email protected]",
"keytype": keytype,
"keydata": keydata,
"authtime": authtime,
"starttime": starttime,
"endtime": endtime,
"renew_till": renew_till,
"flags": flags,
"is_skey": 0,
"ticket_bytes": raw_ticket or data,
}
except KirbiParseError:
raise
except Exception as exc:
raise KirbiParseError(f"Failed to parse .kirbi DER structure: {exc}") from exc
@classmethod
def _parse_der_tlv(cls, data: bytes, offset: int = 0) -> tuple[int, bool, int, bytes, int] | None:
"""
Parses a single DER TLV at offset.
Returns: (tag_class, is_constructed, tag_number, value_bytes, next_offset)
"""
if offset >= len(data):
return None
tag_byte = data[offset]
offset += 1
tag_cls = (tag_byte & 0xC0) >> 6
is_constructed = bool(tag_byte & 0x20)
tag_num = tag_byte & 0x1F
if tag_num == 0x1F:
tag_num = 0
while offset < len(data):
b = data[offset]
offset += 1
tag_num = (tag_num << 7) | (b & 0x7F)
if not (b & 0x80):
break
if offset >= len(data):
raise KirbiParseError("Truncated DER tag in kirbi payload.")
length_byte = data[offset]
offset += 1
if length_byte & 0x80:
n_bytes = length_byte & 0x7F
if offset + n_bytes > len(data):
raise KirbiParseError("Truncated DER length bytes in kirbi payload.")
length = 0
for _ in range(n_bytes):
length = (length << 8) | data[offset]
offset += 1
else:
length = length_byte
if offset + length > len(data):
raise KirbiParseError("Truncated DER payload value.")
val = data[offset : offset + length]
return tag_cls, is_constructed, tag_num, val, offset + length
@classmethod
def _parse_all_tlv(cls, data: bytes) -> list[tuple[int, bool, int, bytes]]:
"""Parses all contiguous DER TLVs in a byte slice."""
items = []
off = 0
while off < len(data):
res = cls._parse_der_tlv(data, off)
if not res:
break
cls_id, constr, num, val, off = res
items.append((cls_id, constr, num, val))
return items
# ── Internal DER Helpers ─────────────────────────────────────────────────
@classmethod
def _encode_length(cls, length: int) -> bytes:
if length < 128:
return bytes([length])
length_bytes = []
while length > 0:
length_bytes.append(length & 0xFF)
length >>= 8
length_bytes.reverse()
return bytes([0x80 | len(length_bytes)]) + bytes(length_bytes)
@classmethod
def _der_integer(cls, val: int) -> bytes:
if val == 0:
payload = b"\x00"
else:
bytes_list = []
tmp = val
while tmp > 0:
bytes_list.append(tmp & 0xFF)
tmp >>= 8
if bytes_list and (bytes_list[-1] & 0x80):
bytes_list.append(0)
bytes_list.reverse()
payload = bytes(bytes_list)
return b"\x02" + cls._encode_length(len(payload)) + payload
@classmethod
def _der_octet_string(cls, data: bytes) -> bytes:
return b"\x04" + cls._encode_length(len(data)) + data
@classmethod
def _der_string(cls, s: str) -> bytes:
encoded = s.encode("latin-1")
return b"\x1b" + cls._encode_length(len(encoded)) + encoded
@classmethod
def _der_sequence(cls, items: list[bytes]) -> bytes:
payload = b"".join(items)
return b"\x30" + cls._encode_length(len(payload)) + payload
@classmethod
def _der_tagged(cls, tag_num: int, content: bytes) -> bytes:
tag_byte = 0xA0 | (tag_num & 0x1F)
return bytes([tag_byte]) + cls._encode_length(len(content)) + content
def pure_md4(data: bytes) -> bytes:
"""
Pure Python implementation of RFC 1320 (MD4) message digest algorithm.
Used for offline NTLM hash derivation in environments where modern OpenSSL 3.0+
disables MD4 from the default cryptographic provider.
"""
try:
import hashlib
return hashlib.new("md4", data).digest()
except Exception:
pass
def _left_rotate(val: int, n: int) -> int:
return ((val << n) | (val >> (32 - n))) & 0xFFFFFFFF
def _f(x: int, y: int, z: int) -> int:
return (x & y) | (~x & z)
def _g(x: int, y: int, z: int) -> int:
return (x & y) | (x & z) | (y & z)
def _h(x: int, y: int, z: int) -> int:
return x ^ y ^ z
msg_len = len(data)
padded = bytearray(data)
padded.append(0x80)
while len(padded) % 64 != 56:
padded.append(0x00)
padded += struct.pack("<Q", msg_len * 8)
a = 0x67452301
b = 0xEFCDAB89
c = 0x98BADCFE
d = 0x10325476
for offset in range(0, len(padded), 64):
x = struct.unpack("<16I", padded[offset : offset + 64])
aa, bb, cc, dd = a, b, c, d
# Round 1
s1 = [3, 7, 11, 19]
for i in range(16):
shift = s1[i % 4]
if i % 4 == 0:
a = _left_rotate((a + _f(b, c, d) + x[i]) & 0xFFFFFFFF, shift)
elif i % 4 == 1:
d = _left_rotate((d + _f(a, b, c) + x[i]) & 0xFFFFFFFF, shift)
elif i % 4 == 2:
c = _left_rotate((c + _f(d, a, b) + x[i]) & 0xFFFFFFFF, shift)
else:
b = _left_rotate((b + _f(c, d, a) + x[i]) & 0xFFFFFFFF, shift)
# Round 2
s2 = [3, 5, 9, 13]
idx2 = [0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15]
for i in range(16):
shift = s2[i % 4]
k = idx2[i]
if i % 4 == 0:
a = _left_rotate((a + _g(b, c, d) + x[k] + 0x5A827999) & 0xFFFFFFFF, shift)
elif i % 4 == 1:
d = _left_rotate((d + _g(a, b, c) + x[k] + 0x5A827999) & 0xFFFFFFFF, shift)
elif i % 4 == 2:
c = _left_rotate((c + _g(d, a, b) + x[k] + 0x5A827999) & 0xFFFFFFFF, shift)
else:
b = _left_rotate((b + _g(c, d, a) + x[k] + 0x5A827999) & 0xFFFFFFFF, shift)
# Round 3
s3 = [3, 9, 11, 15]
idx3 = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]
for i in range(16):
shift = s3[i % 4]
k = idx3[i]
if i % 4 == 0:
a = _left_rotate((a + _h(b, c, d) + x[k] + 0x6ED9EBA1) & 0xFFFFFFFF, shift)
elif i % 4 == 1:
d = _left_rotate((d + _h(a, b, c) + x[k] + 0x6ED9EBA1) & 0xFFFFFFFF, shift)
elif i % 4 == 2:
c = _left_rotate((c + _h(d, a, b) + x[k] + 0x6ED9EBA1) & 0xFFFFFFFF, shift)
else:
b = _left_rotate((b + _h(c, d, a) + x[k] + 0x6ED9EBA1) & 0xFFFFFFFF, shift)
a = (a + aa) & 0xFFFFFFFF
b = (b + bb) & 0xFFFFFFFF
c = (c + cc) & 0xFFFFFFFF
d = (d + dd) & 0xFFFFFFFF
return struct.pack("<4I", a, b, c, d)
def compute_ntlm_hash(password: str) -> str:
"""
Computes an NTLM hash (MD4 of UTF-16LE password) in hex format.
Zero external dependencies, cross-platform reliable.
"""
return pure_md4(password.encode("utf-16le")).hex()
# ─────────────────────────────────────────────────────────────────────────────
# 6. Pure-Python ELF Binary Parser (RPATH / RUNPATH Extraction)
# ─────────────────────────────────────────────────────────────────────────────
class ELFParser:
"""
Pure Python parser for ELF binaries (32-bit and 64-bit, Little & Big Endian).
Extracts DT_RPATH and DT_RUNPATH without spawning /usr/bin/readelf or ldd.
"""
@classmethod
def parse_rpath_file(cls, path: str) -> list[str]:
"""Reads file header and dynamic section to find RPATH/RUNPATH directories."""
try:
with open(path, "rb") as f:
data = f.read(1024 * 1024) # Read first 1MB (covers headers & dynamic table)
return cls.parse_rpath_bytes(data)
except Exception:
return []
@classmethod
def parse_rpath_bytes(cls, data: bytes) -> list[str]:
"""
Parses ELF bytes, discovers PT_DYNAMIC segment and SHT_STRTAB / DT_STRTAB,
and returns list of RPATH / RUNPATH directory strings.
"""
if len(data) < 52 or not data.startswith(b"\x7fELF"):
return []
ei_class = data[4] # 1 = 32-bit, 2 = 64-bit
ei_data = data[5] # 1 = Little Endian, 2 = Big Endian
endian = "<" if ei_data == 1 else ">"
if ei_class not in (1, 2):
return []
is_64 = (ei_class == 2)
try:
if is_64:
if len(data) < 64:
return []
# Elf64_Ehdr
_, _, _, _, _, e_phoff, e_shoff, _, _, e_phentsize, e_phnum, e_shentsize, e_shnum, _ = struct.unpack(
f"{endian}16sHHIQQQIHHHHHH", data[:64]
)
else:
# Elf32_Ehdr
_, _, _, _, _, e_phoff, e_shoff, _, _, e_phentsize, e_phnum, e_shentsize, e_shnum, _ = struct.unpack(
f"{endian}16sHHIIIIIHHHHHH", data[:52]
)
except struct.error:
return []
# Find PT_DYNAMIC (p_type == 2) and PT_LOAD headers
dyn_offset = 0
dyn_size = 0
dyn_vaddr = 0
load_segments: list[tuple[int, int, int]] = [] # (vaddr, offset, filesz)
for i in range(e_phnum):
ph_start = e_phoff + i * e_phentsize
if is_64:
if ph_start + 56 > len(data):
break
p_type, _, p_offset, p_vaddr, _, p_filesz, _, _ = struct.unpack(
f"{endian}IIQQQQQQ", data[ph_start : ph_start + 56]
)
else:
if ph_start + 32 > len(data):
break
p_type, p_offset, p_vaddr, _, p_filesz, _, _, _ = struct.unpack(
f"{endian}IIIIIIII", data[ph_start : ph_start + 32]
)
if p_type == 1: # PT_LOAD
load_segments.append((p_vaddr, p_offset, p_filesz))
elif p_type == 2: # PT_DYNAMIC
dyn_offset = p_offset
dyn_size = p_filesz
dyn_vaddr = p_vaddr # noqa: F841
if not dyn_offset or dyn_offset >= len(data):
return []
# Parse Elf_Dyn entries in PT_DYNAMIC
dyn_bytes = data[dyn_offset : dyn_offset + dyn_size]
strtab_val = 0
rpath_offsets: list[int] = []
entry_size = 16 if is_64 else 8
fmt = f"{endian}QQ" if is_64 else f"{endian}II"
for i in range(0, len(dyn_bytes) - entry_size + 1, entry_size):
try:
d_tag, d_val = struct.unpack(fmt, dyn_bytes[i : i + entry_size])
except struct.error:
break
if d_tag == 0: # DT_NULL
break
elif d_tag == 5: # DT_STRTAB
strtab_val = d_val
elif d_tag in (15, 29): # DT_RPATH (15) or DT_RUNPATH (29)
rpath_offsets.append(d_val)
if not rpath_offsets:
return []
# Resolve strtab offset in binary data
strtab_offset = 0
# Method A: Direct address check in binary
if 0 < strtab_val < len(data):
# Check if strtab_val is directly a file offset
strtab_offset = strtab_val
# Method B: Map virtual address via PT_LOAD
if not strtab_offset:
for vaddr, offset, filesz in load_segments:
if vaddr <= strtab_val < vaddr + filesz:
strtab_offset = offset + (strtab_val - vaddr)
break
# Method C: Check section headers for SHT_DYNAMIC (sh_type == 6) and its sh_link
if not strtab_offset and e_shoff > 0 and e_shnum > 0:
sh_entry_size = e_shentsize
dyn_sh_link = -1
for s in range(e_shnum):
sh_start = e_shoff + s * sh_entry_size
if is_64:
if sh_start + 64 > len(data):
break
_, sh_type, _, _, _, _, sh_link, _, _, _ = struct.unpack(
f"{endian}IIQQQQIIQQ", data[sh_start : sh_start + 64]
)
else:
if sh_start + 40 > len(data):
break
_, sh_type, _, _, _, _, sh_link, _, _, _ = struct.unpack(
f"{endian}IIIIIIIIII", data[sh_start : sh_start + 40]
)
if sh_type == 6: # SHT_DYNAMIC
dyn_sh_link = sh_link
break
if 0 <= dyn_sh_link < e_shnum:
strtab_sh_start = e_shoff + dyn_sh_link * sh_entry_size
if is_64 and strtab_sh_start + 64 <= len(data):
_, _, _, _, sh_offset, _, _, _, _, _ = struct.unpack(
f"{endian}IIQQQQIIQQ", data[strtab_sh_start : strtab_sh_start + 64]
)
strtab_offset = sh_offset
elif not is_64 and strtab_sh_start + 40 <= len(data):
_, _, _, _, sh_offset, _, _, _, _, _ = struct.unpack(
f"{endian}IIIIIIIIII", data[strtab_sh_start : strtab_sh_start + 40]
)
strtab_offset = sh_offset
if not strtab_offset or strtab_offset >= len(data):
return []
# Extract RPATH strings from strtab
result: list[str] = []
for r_off in rpath_offsets:
abs_str_offset = strtab_offset + r_off
if abs_str_offset >= len(data):
continue
null_pos = data.find(b"\x00", abs_str_offset)
if null_pos != -1:
rpath_str = data[abs_str_offset:null_pos].decode("utf-8", errors="replace").strip()
else:
rpath_str = data[abs_str_offset:abs_str_offset + 512].decode("utf-8", errors="replace").strip()
if rpath_str:
for part in rpath_str.split(":"):
p = part.strip()
if p and p not in result:
result.append(p)
return result
# ─────────────────────────────────────────────────────────────────────────────
# 7. Pure-Python Linux Capability Decoder (security.capability / vfs_cap_data)
# ─────────────────────────────────────────────────────────────────────────────
_LINUX_CAP_NAMES: dict[int, str] = {
0: "cap_chown",
1: "cap_dac_override",
2: "cap_dac_read_search",
3: "cap_fowner",
4: "cap_fsetid",
5: "cap_kill",
6: "cap_setgid",
7: "cap_setuid",
8: "cap_setpcap",
9: "cap_linux_immutable",
10: "cap_net_bind_service",
11: "cap_net_broadcast",
12: "cap_net_admin",
13: "cap_net_raw",
14: "cap_ipc_lock",
15: "cap_ipc_owner",
16: "cap_sys_module",
17: "cap_sys_rawio",
18: "cap_sys_chroot",
19: "cap_sys_ptrace",
20: "cap_sys_pacct",
21: "cap_sys_admin",
22: "cap_sys_boot",
23: "cap_sys_nice",
24: "cap_sys_resource",
25: "cap_sys_time",
26: "cap_sys_tty_config",
27: "cap_mknod",
28: "cap_lease",
29: "cap_audit_write",
30: "cap_audit_control",
31: "cap_setfcap",
32: "cap_mac_override",
33: "cap_mac_admin",
34: "cap_syslog",
35: "cap_wake_alarm",
36: "cap_block_suspend",
37: "cap_audit_read",
38: "cap_perfmon",
39: "cap_bpf",
40: "cap_checkpoint_restore",
}
class LinuxCapParser:
"""
Pure Python decoder for Linux security.capability xattr structures (vfs_cap_data).
Decodes effective/permitted capabilities without invoking /sbin/getcap.
"""
@classmethod
def get_file_capabilities(cls, path: str) -> list[str]:
"""Reads security.capability extended attribute via os.getxattr if supported."""
if not hasattr(os, "getxattr"):
return []
try:
cap_data = os.getxattr(path, "security.capability")
return cls.decode_capability_bytes(cap_data)
except (OSError, ValueError):
return []
@classmethod
def decode_capability_bytes(cls, data: bytes) -> list[str]:
"""
Decodes raw bytes of Linux vfs_cap_data / vfs_ns_cap_data structure.
Supports VFS_CAP_REVISION_1 (32-bit), VFS_CAP_REVISION_2 (64-bit), and VFS_CAP_REVISION_3.
"""
if len(data) < 12:
return []
# Determine endianness from magic
# Magic is stored in lower/upper byte of magic_etc
endian = "<" # Linux xattrs on disk are little-endian
try:
magic_etc = struct.unpack(f"{endian}I", data[:4])[0]
except struct.error:
return []
rev = magic_etc & 0xFF000000
permitted_64 = 0
if rev in (0x02000000, 0x03000000) and len(data) >= 20:
# VFS_CAP_REVISION_2 or 3: 2 uint32 pairs (permitted, inheritable)
try:
_, p0, _, p1, _ = struct.unpack(f"{endian}5I", data[:20])
permitted_64 = (p0 & 0xFFFFFFFF) | ((p1 & 0xFFFFFFFF) << 32)
except struct.error:
return []
elif rev == 0x01000000 and len(data) >= 12:
# VFS_CAP_REVISION_1: 1 uint32 pair (permitted, inheritable)
try:
_, p0, _ = struct.unpack(f"{endian}3I", data[:12])
permitted_64 = p0 & 0xFFFFFFFF
except struct.error:
return []
else:
# Fallback: try reading first 2 words
try:
_, p0 = struct.unpack(f"{endian}2I", data[:8])
permitted_64 = p0 & 0xFFFFFFFF
except struct.error:
return []
found: list[str] = []
for bit_idx, cap_name in _LINUX_CAP_NAMES.items():
if (permitted_64 & (1 << bit_idx)) != 0:
found.append(cap_name)
return found
# ─────────────────────────────────────────────────────────────────────────────
# 8. Pure-Python Local SUID / SGID Scanner
# ─────────────────────────────────────────────────────────────────────────────
def find_suid_binaries_local(search_dirs: list[str] | None = None) -> list[str]:
"""
Scans common binary directories or custom directories for S_ISUID files
in pure Python without invoking /usr/bin/find or /bin/bash.
"""
import stat
if search_dirs is None:
search_dirs = [
"/bin", "/sbin", "/usr/bin", "/usr/sbin",
"/usr/local/bin", "/usr/local/sbin", "/opt",
]
found: list[str] = []
for root_dir in search_dirs:
if not os.path.exists(root_dir) or not os.path.isdir(root_dir):
continue
try:
for entry in os.scandir(root_dir):
try:
if entry.is_file(follow_symlinks=False):
mode = os.stat(entry.path).st_mode
if mode & stat.S_ISUID:
found.append(entry.path)
except (OSError, PermissionError):
continue
except (OSError, PermissionError):
continue
return sorted(found)