aegis-rex 1.5.1 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aegis-rex",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Headless-drivable security auditor for Linux, macOS and Windows. Runs a 17-check local audit and can be driven by an AI agent (--capabilities / --audit --json / --fix). npm is the distribution channel; the tool itself is dependency-free Python.",
   "bin": {
     "rex": "bin/rex.js"

package/vendor/rex.py

@@ -118,7 +118,7 @@ IS_LINUX = _OS == "Linux"
 # ============================================================
 # KONFIGURATION
 # ============================================================
-VERSION  = "1.5.1"
+VERSION  = "1.5.3"
 APP_NAME = "ÆGIS Security Audit"
 
 # Lines emitted by find(1)/stat(1) *about* a path rather than *as a result*.
@@ -126,9 +126,68 @@ APP_NAME = "ÆGIS Security Audit"
 # with real hits — without this split, "Permission denied" is counted as a
 # world-writable file that was never actually found.
 _FIND_NOISE = re.compile(
-    r"^(?:find|stat|ls|du|grep|getfacl)\s*:\s", re.IGNORECASE
+    r"^(?:find|stat|ls|du|grep|getfacl|dpkg-query|rpm|pacman)\s*:\s", re.IGNORECASE
 )
 
+# A variable whose *name* marks it as a credential. Matched on segment
+# boundaries, not as a bare substring: SSH_AUTH_SOCK and XAUTHORITY used to be
+# reported as secrets because they contain "auth", and PWD because it contains
+# "pwd" — neither holds a credential.
+_SECRET_NAME_ANY = re.compile(
+    r"(?:^|[_\-.0-9])(key|keys|token|secret|passwd|password|credential|"
+    r"credentials|apikey|api_key|access_key|private_key|bearer|jwt|oauth|"
+    r"webhook)(?:$|[_\-.0-9])",
+    re.IGNORECASE,
+)
+
+# Weaker words that are only credential-ish as the *last* segment: MY_AUTH and
+# MYSQL_PWD are secrets, SSH_AUTH_SOCK is a socket path.
+_SECRET_NAME_TAIL = re.compile(r"(?:^|[_\-.0-9])(auth|pwd|private)$", re.IGNORECASE)
+
+# Values that are credentials whatever the variable is called.
+_SECRET_VALUE = re.compile(
+    r"^sk-[A-Za-z0-9_\-]{16,}"           # OpenAI / Anthropic / DeepSeek
+    r"|^whsec_[A-Za-z0-9]{16,}"           # Stripe webhook secret
+    r"|^gsk_[A-Za-z0-9]{20,}"             # Groq
+    r"|^ghp_|^ghs_|^github_pat_"          # GitHub tokens
+    r"|^xox[bpoas]-"                      # Slack tokens
+    r"|^[a-f0-9]{40,}$"                   # long hex digest
+    r"|^[A-Za-z0-9+/]{40,}={0,2}$",       # long base64 blob
+    re.IGNORECASE,
+)
+
+# Names that merely *contain* a credential-ish word but are paths, sockets or
+# session identifiers, not secrets.
+_BENIGN_VARS = frozenset({
+    "PWD", "OLDPWD", "XAUTHORITY", "SSH_AUTH_SOCK", "SSH_ASKPASS",
+    "DBUS_SESSION_BUS_ADDRESS", "XDG_SESSION_PATH", "XDG_SEAT_PATH",
+    "XDG_RUNTIME_DIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CONFIG_DIRS",
+    "GPG_AGENT_INFO", "HISTFILE", "KEYRING_PID",
+})
+
+
+def _looks_like_path(value):
+    """True for filesystem/socket paths that merely resemble a long blob.
+
+    /org/freedesktop/DisplayManager/Session0 is 38 characters drawn entirely
+    from [A-Za-z0-9+/], so it satisfied the "long base64 blob" rule even
+    though "/" is only in that class to allow real base64 padding.
+    """
+    return value.startswith(("/", "~", "./", "../")) or os.path.exists(value)
+
+
+def _is_secret_var(name, value):
+    """Decide whether one environment entry looks like a credential."""
+    if name.upper() in _BENIGN_VARS:
+        return False
+    if _SECRET_NAME_ANY.search(name) or _SECRET_NAME_TAIL.search(name):
+        return True
+    if value and _SECRET_VALUE.search(value):
+        # A value-only hit must not be a path, or XDG_SESSION_PATH and
+        # XDG_SEAT_PATH come back as secrets.
+        return not _looks_like_path(value)
+    return False
+
 # ============================================================
 # AI PROVIDERS
 # ============================================================
@@ -385,6 +444,39 @@ class AuditEngine:
                 findings.append(line)
         return findings, noise
 
+    @staticmethod
+    def _pkg_split(paths):
+        """Partition paths into (hand-placed, installed-by-a-package-manager).
+
+        The SUID section used to judge by *path* alone, so a setuid helper that
+        shipped inside a .deb but unpacked to /opt/<App>/ was reported as if
+        someone had placed it by hand. Asking the package manager is the honest
+        test. If no package manager is available the paths stay on the
+        hand-placed side — absence of evidence is not a pass.
+        """
+        if not paths:
+            return [], []
+        owned = set()
+        for exe_name in ("dpkg-query", "rpm", "pacman"):
+            exe = shutil.which(exe_name)
+            if not exe:
+                continue
+            out = AuditEngine._cmd([exe, "-S"] + [str(p) for p in paths], timeout=20)
+            real, _ = AuditEngine._split_noise(out)
+            for line in real:
+                if ":" not in line:
+                    continue
+                # "terminal-ds: /opt/Terminal DS/chrome-sandbox" — split on the
+                # first colon only; the path itself may contain spaces.
+                _, _, resolved = line.partition(":")
+                resolved = resolved.strip()
+                if resolved:
+                    owned.add(resolved)
+            break  # first package manager that exists is the right one
+        hand = [p for p in paths if p not in owned]
+        packaged = [p for p in paths if p in owned]
+        return hand, packaged
+
     @staticmethod
     def _na(feature):
         return "ok", f"[N/A on {_OS}] {feature} is not applicable on this platform."
@@ -714,24 +806,51 @@ class AuditEngine:
                 return status, out or "No world-accessible binaries found in System32"
 
             else:  # Linux + macOS
-                safe_paths = ["/usr", "/bin", "/sbin", "/lib", "/lib64", "/opt"]
+                # Where a distro's package manager is allowed to drop a
+                # SUID/SGID binary. A stock Ubuntu box carries ~30 helpers in
+                # /usr/bin and /usr/lib (sudo, passwd, mount, su, pkexec …);
+                # reporting that inventory as a defect buries the one binary
+                # that was actually put there by hand. So the bit itself is
+                # inventoried, and only *where* it was found decides the status.
+                managed_dirs = (
+                    "/usr/bin/", "/usr/sbin/", "/usr/lib/", "/usr/lib32/",
+                    "/usr/lib64/", "/usr/libexec/", "/bin/", "/sbin/",
+                    "/lib/", "/lib32/", "/lib64/",
+                )
                 if IS_MAC:
-                    safe_paths = ["/usr", "/bin", "/sbin", "/opt"]
-                existing = [p for p in safe_paths if os.path.isdir(p)]
-                out = cmd(["find"] + existing + ["-perm", "/6000", "-type", "f"], timeout=20)
+                    managed_dirs = ("/usr/bin/", "/usr/sbin/", "/usr/lib/",
+                                    "/usr/libexec/", "/bin/", "/sbin/", "/System/")
+                # /home is deliberately absent: a recursive scan of home dirs
+                # exceeded 120s on a real machine, and an audit that stalls is
+                # worse than one with a stated scope. The remaining roots are
+                # sub-second.
+                scan_roots = ["/usr", "/bin", "/sbin", "/lib", "/lib64",
+                              "/usr/local", "/opt", "/tmp", "/var/tmp"]
+                existing = [p for p in scan_roots if os.path.isdir(p)]
+                out = cmd(["find"] + existing + ["-perm", "/6000", "-type", "f"], timeout=25)
                 real, noise = self._split_noise(out)
-                if real:
-                    lines = real[:30]
-                    out = "\n".join(lines)
-                    if len(lines) == 30:
-                        out += "\n[truncated at 30 results]"
-                    if noise:
-                        out += f"\n({len(noise)} path(s) not readable, skipped)"
-                    return "warn", out
-                note = "No SUID/SGID files found in system dirs"
-                if noise:
-                    note += f" ({len(noise)} path(s) not readable, skipped)"
-                return "ok", note
+                managed = [f for f in real if f.startswith(managed_dirs)]
+                unexpected = [f for f in real if not f.startswith(managed_dirs)]
+                # Ruling by path alone reported /opt/Terminal DS/chrome-sandbox
+                # as hand-placed; it belongs to the terminal-ds package. Only a
+                # binary that neither the distro nor a package shipped is a
+                # finding.
+                hand, packaged = self._pkg_split(unexpected)
+                inventory = len(managed) + len(packaged)
+                suffix = f"\n({len(noise)} path(s) not readable, skipped)" if noise else ""
+                if hand:
+                    lines = hand[:30]
+                    body = "\n".join(lines)
+                    if len(hand) > 30:
+                        body += f"\n[truncated at 30 of {len(hand)} results]"
+                    if inventory:
+                        body += (f"\n({inventory} SUID/SGID binary(ies) under distro- or "
+                                 f"package-managed locations, expected inventory)")
+                    return "warn", body + suffix
+                if inventory:
+                    return "ok", (f"{inventory} SUID/SGID binaries found, all under distro- "
+                                  f"or package-managed locations (expected inventory)" + suffix)
+                return "ok", "No SUID/SGID files found in scanned paths" + suffix
 
         # ── World-Writable Files ──────────────────────────────
         elif section == "World-Writable Files":
@@ -828,22 +947,9 @@ class AuditEngine:
 
         # ── Environment Secrets ───────────────────────────────
         elif section == "Environment Secrets":
-            SECRET_NAME = re.compile(
-                r"(key|token|secret|password|passwd|pwd|credential|auth|"
-                r"apikey|api_key|access_key|private|bearer|jwt|oauth|webhook)",
-                re.IGNORECASE,
-            )
-            SECRET_VAL = re.compile(
-                r"^[A-Za-z0-9+/]{32,}$"          # base64-like long string
-                r"|^[a-f0-9]{32,}$"               # hex hash
-                r"|^sk-[A-Za-z0-9]{20,}"          # OpenAI-style
-                r"|^ghp_|^ghs_|^github_pat_"      # GitHub tokens
-                r"|^xox[bpoas]-",                  # Slack tokens
-                re.IGNORECASE,
-            )
             suspicious, clean = [], []
             for k, v in os.environ.items():
-                if SECRET_NAME.search(k) or (v and SECRET_VAL.search(v)):
+                if _is_secret_var(k, v):
                     masked = (v[:4] + "****" + v[-2:]) if len(v) > 6 else "****"
                     suspicious.append(f"⚠  {k} = {masked}")
                 else: