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(accuracy): kernel_suggester separate kernel vs userspace CVE matching (MOD-071)
Mafifrizica3d469070c4
diff --git a/ares/modules/linux/kernel_suggester.py b/ares/modules/linux/kernel_suggester.pyindex 8184868..a480223 100644--- a/ares/modules/linux/kernel_suggester.py+++ b/ares/modules/linux/kernel_suggester.py@@ -28,19 +28,118 @@ from ares.sdk import (logger = get_logger("ares.modules.linux.kernel_suggester")-# kernel_version_regex → (CVE, description, severity, affected_range)-# Ranges are illustrative - real check via uname -r parsing-_KERNEL_CVES: list[tuple[str, str, str, str, str]] = [- (r"[345]\.[0-9]+", "CVE-2021-4034", "Polkit pkexec LPE (PwnKit)", "CRITICAL", "< 0.120-3"),- (r"[345]\.[0-9]+", "CVE-2021-3156", "Sudo heap-overflow LPE (Baron Samedit)", "CRITICAL", "< 1.9.5p2"),- (r"5\.[0-9]+\.[0-9]+", "CVE-2022-0847", "Dirty Pipe - arbitrary write via pipe", "HIGH", "5.8–5.16.11"),- (r"[34]\.[0-9]+\.[0-9]+","CVE-2016-5195", "Dirty COW - race condition write", "HIGH", "< 4.8.3"),- (r"5\.[0-9]+\.[0-9]+", "CVE-2021-33909", "seq_file LPE (size_t-to-int overflow)", "HIGH", "< 5.13.4"),- (r"[345]\.[0-9]+", "CVE-2019-13272", "ptrace PTRACE_TRACEME LPE", "HIGH", "< 5.1.17"),- (r"[345]\.[0-9]+", "CVE-2017-16995", "eBPF verifier integer overflow LPE", "HIGH", "3.18–4.14"),- (r"[345]\.[0-9]+", "CVE-2017-7308", "af_packet ring buffer LPE", "HIGH", "< 4.10.6"),+# Genuine Linux Kernel CVEs - matched against kernel version from uname -r+_KERNEL_CVES: list[dict[str, Any]] = [+ {+ "cve": "CVE-2022-0847",+ "description": "Dirty Pipe - arbitrary write via pipe",+ "severity": "HIGH",+ "affected_range": "5.8.0 to 5.16.11",+ "min_version": (5, 8, 0),+ "max_version": (5, 16, 11),+ },+ {+ "cve": "CVE-2016-5195",+ "description": "Dirty COW - race condition write",+ "severity": "HIGH",+ "affected_range": "2.6.22 to 4.8.3",+ "min_version": (2, 6, 22),+ "max_version": (4, 8, 3),+ },+ {+ "cve": "CVE-2021-33909",+ "description": "seq_file LPE (size_t-to-int overflow)",+ "severity": "HIGH",+ "affected_range": "3.16.0 to 5.13.4",+ "min_version": (3, 16, 0),+ "max_version": (5, 13, 4),+ },+ {+ "cve": "CVE-2019-13272",+ "description": "ptrace PTRACE_TRACEME LPE",+ "severity": "HIGH",+ "affected_range": "4.10.0 to 5.1.17",+ "min_version": (4, 10, 0),+ "max_version": (5, 1, 17),+ },+ {+ "cve": "CVE-2017-16995",+ "description": "eBPF verifier integer overflow LPE",+ "severity": "HIGH",+ "affected_range": "3.18.0 to 4.14.0",+ "min_version": (3, 18, 0),+ "max_version": (4, 14, 0),+ },+ {+ "cve": "CVE-2017-7308",+ "description": "af_packet ring buffer LPE",+ "severity": "HIGH",+ "affected_range": "3.2.0 to 4.10.6",+ "min_version": (3, 2, 0),+ "max_version": (4, 10, 6),+ },]+# Userspace Utility CVEs - NEVER matched against kernel version!+# Requires standalone binary version query (sudo -V, pkexec --version)+_USERSPACE_CVES: list[dict[str, Any]] = [+ {+ "cve": "CVE-2021-4034",+ "description": "Polkit pkexec LPE (PwnKit)",+ "binary": "pkexec",+ "version_key": "pkexec_version",+ "severity": "CRITICAL",+ "affected_range": "< 0.120-3 (or unpatched pkexec < 120)",+ },+ {+ "cve": "CVE-2021-3156",+ "description": "Sudo heap-overflow LPE (Baron Samedit)",+ "binary": "sudo",+ "version_key": "sudo_version",+ "severity": "CRITICAL",+ "affected_range": "1.8.2–1.8.31p2, 1.9.0–1.9.5p2",+ },+]+++def _parse_version_tuple(ver_str: str) -> tuple[int, ...] | None:+ """Extract integer version components from a version string (e.g. '5.15.0-42' -> (5, 15, 0, 42))."""+ if not ver_str:+ return None+ match = re.search(r"(\d+)\.(\d+)(?:\.(\d+))?(?:[p\-](\d+))?", ver_str)+ if not match:+ return None+ return tuple(int(g) for g in match.groups() if g is not None)+++def _is_sudo_vulnerable(ver_str: str) -> bool:+ """Check if Sudo version is vulnerable to Baron Samedit (CVE-2021-3156: 1.8.2 <= ver <= 1.9.5p2)."""+ parsed = _parse_version_tuple(ver_str)+ if not parsed or len(parsed) < 2:+ return False+ major, minor = parsed[0], parsed[1]+ patch = parsed[2] if len(parsed) > 2 else 0+ p_level = parsed[3] if len(parsed) > 3 else 0++ if major == 1 and minor == 8 and patch >= 2:+ return True+ if major == 1 and minor == 9:+ if patch < 5:+ return True+ if patch == 5 and p_level <= 2:+ return True+ return False+++def _is_pkexec_vulnerable(ver_str: str) -> bool:+ """Check if Polkit pkexec version is vulnerable to PwnKit (CVE-2021-4034: < 0.120 or < 120)."""+ parsed = _parse_version_tuple(ver_str)+ if not parsed:+ return False+ if parsed[0] == 0:+ return len(parsed) > 1 and parsed[1] < 120+ return parsed[0] < 120+@module_contract(permissions=[@@ -255,6 +354,8 @@ class KernelSuggesterModule(BaseModule[KernelSuggesterParams, ModuleResult]):("uname -a", "uname_full"),("cat /etc/os-release 2>/dev/null | head -5", "os_release"),("id", "current_user"),+ ("sudo -V 2>/dev/null | head -1", "sudo_version"),+ ("pkexec --version 2>/dev/null | head -1", "pkexec_version"),]:try:_, stdout, _ = client.exec_command(cmd, timeout=5)@@ -264,44 +365,136 @@ class KernelSuggesterModule(BaseModule[KernelSuggesterParams, ModuleResult]):client.close()return results- try:- info = await loop.run_in_executor(None, _get_info)- except Exception as e:- return [], {"error": str(e)[:200]}+ info: dict[str, str] = dict(kwargs.get("info") or {})+ if not info:+ try:+ info = await loop.run_in_executor(None, _get_info)+ except Exception as e:+ return [], {"error": str(e)[:200]}++ if "kernel" in kwargs:+ info["kernel"] = kwargs["kernel"]+ if "sudo_version" in kwargs:+ info["sudo_version"] = kwargs["sudo_version"]+ if "pkexec_version" in kwargs:+ info["pkexec_version"] = kwargs["pkexec_version"]kernel_ver = info.get("kernel", "")- suggestions: list[dict[str, str]] = []+ suggestions: list[dict[str, Any]] = []++ # 1. Genuine Kernel CVE Evaluation+ parsed_kver = _parse_version_tuple(kernel_ver)+ if parsed_kver:+ for cve_def in _KERNEL_CVES:+ cve = cve_def["cve"]+ description = cve_def["description"]+ affected = cve_def["affected_range"]+ min_v = cve_def["min_version"]+ max_v = cve_def["max_version"]++ matched = False+ is_exact = False++ if len(parsed_kver) >= 3:+ k3 = parsed_kver[:3]+ if min_v <= k3 <= max_v:+ matched = True+ is_exact = True+ elif len(parsed_kver) == 2:+ k2 = parsed_kver[:2]+ if min_v[:2] <= k2 <= max_v[:2]:+ matched = True+ is_exact = False++ if matched:+ if is_exact:+ severity_str = cve_def["severity"]+ confidence = 0.8+ desc_suffix = "Verify patch level before attempting exploitation."+ else:+ severity_str = "MEDIUM"+ confidence = 0.5 # unverified patch level (< 0.7)+ desc_suffix = "patch version unknown, manual verification required."++ sev = {"CRITICAL": Severity.CRITICAL, "HIGH": Severity.HIGH,+ "MEDIUM": Severity.MEDIUM}.get(severity_str, Severity.MEDIUM)++ suggestions.append({+ "cve": cve, "description": description,+ "severity": severity_str, "affected_range": affected,+ "type": "kernel", "confidence": confidence,+ })+ self.finding(+ title=f"Potential Kernel LPE: {cve} - {description}",+ description=(+ f"Kernel {kernel_ver} on {target} may be vulnerable to {cve} "+ f"({description}). Affected range: {affected}. {desc_suffix}"+ ),+ severity=sev,+ mitre_technique="T1068",+ mitre_tactic="Privilege Escalation",+ evidence={"kernel": kernel_ver, "cve": cve,+ "host": target, "current_user": info.get("current_user", "")},+ remediation=(+ f"Apply kernel security patches. Upgrade to a version not affected "+ f"by {cve}. Enable automatic security updates."+ ),+ host=target, confidence=confidence,+ )++ # 2. Userspace Tool CVE Evaluation (sudo, pkexec) - NEVER matched against kernel version!+ for u_cve in _USERSPACE_CVES:+ cve = u_cve["cve"]+ description = u_cve["description"]+ binary = u_cve["binary"]+ v_key = u_cve["version_key"]+ affected = u_cve["affected_range"]+ raw_ver = info.get(v_key, "").strip()++ if not raw_ver:+ continue++ vulnerable = False+ if binary == "sudo":+ vulnerable = _is_sudo_vulnerable(raw_ver)+ elif binary == "pkexec":+ vulnerable = _is_pkexec_vulnerable(raw_ver)- for pattern, cve, description, severity_str, affected in _KERNEL_CVES:- if re.search(pattern, kernel_ver):+ if vulnerable:+ severity_str = u_cve["severity"]+ sev = Severity.CRITICAL if severity_str == "CRITICAL" else Severity.HIGH+ confidence = 0.85suggestions.append({"cve": cve, "description": description,"severity": severity_str, "affected_range": affected,+ "type": "userspace", "binary": binary, "version": raw_ver,+ "confidence": confidence,})- sev = {"CRITICAL": Severity.CRITICAL, "HIGH": Severity.HIGH,- "MEDIUM": Severity.MEDIUM}.get(severity_str, Severity.INFO)self.finding(- title=f"Potential Kernel LPE: {cve} - {description}",+ title=f"Potential Userspace LPE: {cve} - {description}",description=(- f"Kernel {kernel_ver} on {target} may be vulnerable to {cve} "- f"({description}). Affected range: {affected}. "- "Verify patch level before attempting exploitation."+ f"Binary '{binary}' version '{raw_ver}' on {target} is vulnerable to {cve} "+ f"({description}). Affected range: {affected}."),severity=sev,mitre_technique="T1068",mitre_tactic="Privilege Escalation",- evidence={"kernel": kernel_ver, "cve": cve,- "host": target, "current_user": info.get("current_user", "")},+ evidence={+ "binary": binary, "version": raw_ver, "cve": cve,+ "host": target, "current_user": info.get("current_user", "")+ },remediation=(- f"Apply kernel security patches. Upgrade to a version not affected "- f"by {cve}. Enable automatic security updates."+ f"Upgrade {binary} package immediately to a patched release. "+ f"Refer to advisory for {cve}."),- host=target, confidence=0.7,+ host=target, confidence=confidence,)raw = {"target": target, "kernel": kernel_ver,"os_info": info.get("os_release", ""),"current_user": info.get("current_user", ""),+ "sudo_version": info.get("sudo_version", ""),+ "pkexec_version": info.get("pkexec_version", ""),"suggestions": suggestions}raw["privesc_vectors"] = self._findings # OUTPUTS keyreturn self._findings[:], rawdiff --git a/tests/unit/modules/test_kernel_suggester_mod071.py b/tests/unit/modules/test_kernel_suggester_mod071.pynew file mode 100644index 0000000..0c9efbf--- /dev/null+++ b/tests/unit/modules/test_kernel_suggester_mod071.py@@ -0,0 +1,90 @@+"""+Unit tests for MOD-071: linux.kernel_suggester separation of kernel vs userspace CVEs.+Validates:+- Kernel 5.4.0 does NOT generate PwnKit (CVE-2021-4034) finding.+- Kernel 5.15.0 with sudo 1.9.5p2 generates Baron Samedit (CVE-2021-3156) finding when sudo version is queried.+- Unverified kernel findings (major.minor only without patch version) have confidence < 0.7 (0.5) and MEDIUM severity.+- Exact kernel version matches (e.g. Dirty Pipe) have confidence >= 0.7.+"""+from __future__ import annotations++import pytest++from ares.core.campaign import Campaign, ScopeEntry+from ares.core.config import AresSettings+from ares.core.noise import NoiseController, NoiseProfile+from ares.modules.linux.kernel_suggester import KernelSuggesterModule+++def _make_suggester() -> KernelSuggesterModule:+ settings = AresSettings(+ ares_secret_key="test-secret-key-32chars-minimum!!",+ ares_encryption_key="test-encryption-key-32chars-min!!",+ )+ campaign = Campaign(+ name="Kernel-Suggester-Test",+ client="Unit-Testing",+ scope=[ScopeEntry(cidr="10.0.0.0/8")],+ noise_profile=NoiseProfile.NORMAL,+ )+ noise = NoiseController(campaign)+ return KernelSuggesterModule(settings=settings, campaign=campaign, noise=noise)+++async def test_kernel_5_4_0_does_not_produce_pwnkit():+ """MOD-071: Linux kernel 5.4.0 must NOT match PwnKit (CVE-2021-4034, which is a polkit userspace bug)."""+ module = _make_suggester()+ findings, raw = await module.run(+ target="10.0.0.5",+ username="operator",+ info={"kernel": "5.4.0-42-generic", "current_user": "uid=1000(user)"},+ )++ finding_cves = [f.evidence.get("cve") for f in findings]+ assert "CVE-2021-4034" not in finding_cves, (+ "MOD-071 FAIL: PwnKit (userspace polkit) was incorrectly matched against kernel version!"+ )+++async def test_sudo_version_query_generates_baron_samedit():+ """MOD-071: Kernel 5.15.0 with sudo 1.9.5p2 produces Baron Samedit (CVE-2021-3156) via userspace query."""+ module = _make_suggester()+ findings, raw = await module.run(+ target="10.0.0.5",+ username="operator",+ info={+ "kernel": "5.15.0-100-generic",+ "sudo_version": "Sudo version 1.9.5p2",+ "current_user": "uid=1000(user)",+ },+ )++ baron_findings = [f for f in findings if f.evidence.get("cve") == "CVE-2021-3156"]+ assert len(baron_findings) == 1, (+ "MOD-071 FAIL: Baron Samedit should be detected when vulnerable sudo version is queried"+ )+ assert baron_findings[0].evidence["binary"] == "sudo"+ assert "1.9.5p2" in baron_findings[0].evidence["version"]+ assert baron_findings[0].confidence >= 0.7+++async def test_unverified_kernel_finding_has_low_confidence():+ """MOD-071: Kernel finding with major.minor only (unverified patch level) has confidence < 0.7 and MEDIUM severity."""+ module = _make_suggester()+ # 5.10 with no patch version provided+ findings, raw = await module.run(+ target="10.0.0.5",+ username="operator",+ info={"kernel": "5.10", "current_user": "uid=1000(user)"},+ )++ # Any finding generated for unverified patch version must have confidence < 0.7+ for f in findings:+ assert f.confidence < 0.7, (+ f"MOD-071 FAIL: Unverified finding {f.title} has confidence {f.confidence} >= 0.7"+ )+ assert f.severity.value == "medium"+ assert "patch version unknown, manual verification required" in f.description