agent-gate-sec 0.2.0__py3-none-any.whl

agent_gate/__init__.py

@@ -0,0 +1,3 @@
+"""AgentGate — AI Agent Data Collection & Security Analysis Gateway."""
+
+__version__ = "0.2.0"

agent_gate/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m agent_gate"""
+
+from .cli import main
+
+main()

agent_gate/cli.py

@@ -0,0 +1,118 @@
+"""CLI entry point for AgentGate service."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .config import get_config, reload_config
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="agent-gate",
+        description="AgentGate - AI Agent Data Collection & Security Analysis Gateway",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # ---- server command ----
+    server_parser = subparsers.add_parser("server", help="Start AgentGate server")
+    server_parser.add_argument(
+        "--mode", choices=["http", "socket"], default="http",
+        help="Server mode: http (TCP) or socket (Unix Domain Socket)"
+    )
+    server_parser.add_argument(
+        "--host", default="0.0.0.0",
+        help="Bind host (HTTP mode only, default: 0.0.0.0)"
+    )
+    server_parser.add_argument(
+        "--port", type=int, default=9100,
+        help="Bind port (HTTP mode only, default: 9100)"
+    )
+    server_parser.add_argument(
+        "--socket", dest="socket_path",
+        help="Unix socket path (socket mode only)"
+    )
+    server_parser.add_argument(
+        "--log-level", choices=["debug", "info", "warning", "error"],
+        default="info", help="Log level"
+    )
+    server_parser.add_argument(
+        "--workers", type=int, default=1,
+        help="Number of worker processes"
+    )
+    server_parser.add_argument(
+        "--config", type=Path, dest="config_path",
+        help="Path to YAML config file"
+    )
+    server_parser.add_argument(
+        "--db-path", type=str, dest="db_path",
+        help="SQLite database path override"
+    )
+
+    # ---- clean command ----
+    clean_parser = subparsers.add_parser("clean", help="Clean old database records")
+    clean_parser.add_argument(
+        "--retention-days", type=int, default=30,
+        help="Days to retain records (default: 30)"
+    )
+    clean_parser.add_argument(
+        "--config", type=Path, dest="config_path",
+        help="Path to YAML config file"
+    )
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "server":
+        _run_server(args)
+
+    elif args.command == "clean":
+        _run_clean(args)
+
+
+def _run_server(args):
+    # Load config
+    cfg = get_config(args.config_path)
+    server_cfg = cfg.server
+
+    host = args.host or server_cfg.get("host", "0.0.0.0")
+    port = args.port or server_cfg.get("port", 9100)
+    mode = args.mode or server_cfg.get("mode", "http")
+    socket_path = args.socket_path or server_cfg.get("socket_path")
+    log_level = args.log_level or server_cfg.get("log_level", "info")
+    workers = args.workers or server_cfg.get("workers", 1)
+    db_path = args.db_path or cfg.storage.get("db_path") or "data/agent_gate.db"
+
+    from .server.app import run_server
+    run_server(
+        host=host,
+        port=port,
+        mode=mode,
+        socket_path=socket_path,
+        log_level=log_level,
+        workers=workers,
+        db_path=db_path,
+    )
+
+
+def _run_clean(args):
+    cfg = get_config(args.config_path)
+    db_path = cfg.storage.get("db_path")
+
+    from .storage.db import get_db
+    from .storage.repository import Repository
+    from loguru import logger
+
+    db = get_db(db_path)
+    repo = Repository(db)
+
+    deleted = repo.cleanup_old_records(args.retention_days)
+    logger.info(f"Cleaned up {deleted} old records (retention: {args.retention_days} days)")
+    db.close()
+
+
+if __name__ == "__main__":
+    main()

agent_gate/client/__init__.py

@@ -0,0 +1,4 @@
+from .moss_client import MossClient
+from .cache import DecisionCache
+
+__all__ = ["MossClient", "DecisionCache"]

agent_gate/client/cache.py

@@ -0,0 +1,57 @@
+"""LRU decision cache.
+
+Only caches Allow decisions. Deny decisions are never cached.
+Keys are SHA-256 hashes of (session_id, cwd, command).
+"""
+
+import hashlib
+import time
+from collections import OrderedDict
+from typing import Optional
+
+
+class DecisionCache:
+    """LRU cache for Allow decisions with TTL-based expiration."""
+
+    def __init__(self, max_size: int = 500, ttl: int = 300):
+        self._max_size = max_size
+        self._ttl = ttl  # seconds
+        self._cache: OrderedDict[str, tuple[float, dict]] = OrderedDict()
+
+    def _key(self, session_id: str, cwd: str, command: str) -> str:
+        raw = f"{session_id}:{cwd}:{command}"
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    def get(self, session_id: str, cwd: str, command: str) -> Optional[dict]:
+        key = self._key(session_id, cwd, command)
+        entry = self._cache.get(key)
+        if entry is None:
+            return None
+        timestamp, result = entry
+        if self._ttl > 0 and (time.time() - timestamp) > self._ttl:
+            # Expired
+            del self._cache[key]
+            return None
+        # Move to end (most recently used)
+        self._cache.move_to_end(key)
+        return result.copy()
+
+    def set(self, session_id: str, cwd: str, command: str, result: dict) -> None:
+        # Only cache Allow decisions
+        if result.get("decision") != "Allow":
+            return
+        key = self._key(session_id, cwd, command)
+        if key in self._cache:
+            self._cache.move_to_end(key)
+            self._cache[key] = (time.time(), result.copy())
+        else:
+            if len(self._cache) >= self._max_size:
+                self._cache.popitem(last=False)  # Remove least recently used
+            self._cache[key] = (time.time(), result.copy())
+
+    def clear(self) -> None:
+        self._cache.clear()
+
+    @property
+    def size(self) -> int:
+        return len(self._cache)

agent_gate/client/moss_client.py

@@ -0,0 +1,115 @@
+"""AgentMoss HTTP/Socket client with Fail-Closed semantics.
+
+Makes async HTTP calls to AgentMoss for security analysis.
+If AgentMoss is unreachable, returns Deny (security-first).
+"""
+
+from typing import Any, Optional
+
+import httpx
+from loguru import logger
+
+from ..config import get_config
+
+
+class MossClient:
+    """Async HTTP client for AgentMoss security analysis service.
+
+    Supports both HTTP TCP and Unix Domain Socket connections.
+    Implements Fail-Closed: returns Deny when AgentMoss is unavailable.
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout: Optional[float] = None,
+        max_retries: int = 2,
+    ):
+        cfg = get_config()
+        moss_cfg = cfg.agent_moss
+
+        self._base_url = (base_url or moss_cfg.get("url", "http://127.0.0.1:9090")).rstrip("/")
+        self._timeout = timeout or moss_cfg.get("timeout", 30.0)
+        self._max_retries = max_retries or moss_cfg.get("max_retries", 2)
+        self._retry_delay = moss_cfg.get("retry_delay", 1.0)
+
+        # Determine transport
+        if self._base_url.startswith("unix://"):
+            socket_path = self._base_url[len("unix://"):]
+            transport = httpx.AsyncHTTPTransport(uds=socket_path)
+            self._base_url = "http://localhost"  # Placeholder host for UDS
+        else:
+            transport = None
+
+        self._client = httpx.AsyncClient(
+            transport=transport,
+            timeout=httpx.Timeout(self._timeout),
+            limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
+        )
+
+    async def analyze(self, request: dict) -> dict:
+        """Send analysis request to AgentMoss.
+
+        Returns:
+            dict with decision/reason/risk_level fields.
+            On failure, returns Deny with error details (Fail-Closed).
+        """
+        last_error = ""
+        for attempt in range(self._max_retries + 1):
+            try:
+                response = await self._client.post(
+                    f"{self._base_url}/api/v1/analyze",
+                    json=request,
+                )
+                response.raise_for_status()
+                result = response.json()
+                logger.debug(
+                    f"AgentMoss response: decision={result.get('decision')}, "
+                    f"duration={result.get('analysis_duration_ms', 0)}ms"
+                )
+                return result
+
+            except httpx.TimeoutException as e:
+                last_error = f"AgentMoss timeout after {self._timeout}s"
+                logger.warning(f"{last_error} (attempt {attempt + 1})")
+
+            except httpx.ConnectError as e:
+                last_error = f"AgentMoss connection failed: {e}"
+                logger.warning(f"{last_error} (attempt {attempt + 1})")
+
+            except httpx.HTTPStatusError as e:
+                last_error = f"AgentMoss HTTP {e.response.status_code}"
+                logger.warning(f"{last_error} (attempt {attempt + 1})")
+                # Don't retry on 4xx
+                if 400 <= e.response.status_code < 500:
+                    break
+
+            except Exception as e:
+                last_error = f"AgentMoss unexpected error: {e}"
+                logger.warning(f"{last_error} (attempt {attempt + 1})")
+                break
+
+            # Wait before retry
+            if attempt < self._max_retries:
+                import asyncio
+                await asyncio.sleep(self._retry_delay)
+
+        # All retries exhausted → Fail-Closed
+        logger.error(f"AgentMoss unreachable, returning Deny: {last_error}")
+        return self._fail_closed_response(last_error)
+
+    def _fail_closed_response(self, error: str) -> dict:
+        return {
+            "decision": "Deny",
+            "reason": f"AgentMoss security service unavailable — blocking by default: {error}",
+            "risk_level": "high",
+            "risk_type": "service_unavailable",
+            "violated_layers": [],
+            "policy": "",
+            "violated_policy": "",
+            "confidence": 100,
+            "analysis_duration_ms": 0,
+        }
+
+    async def close(self) -> None:
+        await self._client.aclose()

agent_gate/collector/__init__.py

@@ -0,0 +1,95 @@
+"""Collector orchestrator: runs all collectors in parallel via ThreadPoolExecutor."""
+
+import time
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeoutError
+
+from loguru import logger
+
+from ..config import get_config
+from ..server.models import SystemContext, OsInfo, ResourceInfo, ProcessInfo, NetworkInfo, UserInfo
+from .system_info import SystemInfoCollector
+from .process_info import ProcessInfoCollector
+from .env_info import get_env_collector
+from .network_info import NetworkInfoCollector
+from .user_info import UserInfoCollector
+
+
+class CollectorOrchestrator:
+    """Orchestrates parallel system context collection.
+
+    Runs all 5 collectors in a thread pool with per-collector timeout.
+    Falls back to empty data when a collector fails or times out.
+    """
+
+    def __init__(self):
+        cfg = get_config().collector
+        self._timeout = cfg.get("timeout", 5.0)
+        self._pool_size = cfg.get("pool_size", 5)
+        self._enabled = {
+            "system_info": cfg.get("system_info", True),
+            "process_info": cfg.get("process_info", True),
+            "env_info": cfg.get("env_info", True),
+            "network_info": cfg.get("network_info", True),
+            "user_info": cfg.get("user_info", True),
+        }
+
+    def collect(self) -> SystemContext:
+        start = time.monotonic()
+        context = SystemContext()
+
+        collectors = []
+        if self._enabled["system_info"]:
+            collectors.append(("system_info", SystemInfoCollector.collect))
+        if self._enabled["process_info"]:
+            collectors.append(("process_info", ProcessInfoCollector.collect))
+        if self._enabled["env_info"]:
+            collectors.append(("env_info", get_env_collector().collect))
+        if self._enabled["network_info"]:
+            collectors.append(("network_info", NetworkInfoCollector.collect))
+        if self._enabled["user_info"]:
+            collectors.append(("user_info", UserInfoCollector.collect))
+
+        results = {}
+        with ThreadPoolExecutor(max_workers=min(len(collectors), self._pool_size)) as executor:
+            futures = {
+                executor.submit(fn): name
+                for name, fn in collectors
+            }
+            for future in futures:
+                name = futures[future]
+                try:
+                    results[name] = future.result(timeout=self._timeout)
+                except FutureTimeoutError:
+                    logger.warning(f"Collector '{name}' timed out after {self._timeout}s")
+                except Exception as e:
+                    logger.warning(f"Collector '{name}' failed: {e}")
+
+        # Merge results into context
+        for collector_name, data in results.items():
+            if "os" in data:
+                context.os = OsInfo(**data["os"]) if data["os"] else OsInfo()
+            if "resources" in data:
+                context.resources = ResourceInfo(**data["resources"]) if data["resources"] else ResourceInfo()
+            if "process" in data:
+                context.process = ProcessInfo(**data["process"]) if data["process"] else ProcessInfo()
+            if "network" in data:
+                context.network = NetworkInfo(**data["network"]) if data["network"] else NetworkInfo()
+            if "user" in data:
+                context.user = UserInfo(**data["user"]) if data["user"] else UserInfo()
+            if "env" in data:
+                context.env = data["env"]
+
+        elapsed = (time.monotonic() - start) * 1000
+        logger.debug(f"Collection completed in {elapsed:.1f}ms")
+        return context
+
+
+# Singleton
+_orchestrator: CollectorOrchestrator | None = None
+
+
+def get_orchestrator() -> CollectorOrchestrator:
+    global _orchestrator
+    if _orchestrator is None:
+        _orchestrator = CollectorOrchestrator()
+    return _orchestrator

agent_gate/collector/env_info.py

@@ -0,0 +1,54 @@
+"""Environment variable collector with security filtering.
+
+Applies whitelist + blacklist to prevent leaking secrets.
+"""
+
+import os
+import re
+
+from ..config import get_config
+
+
+class EnvInfoCollector:
+    """Collects environment variables, applying security filters."""
+
+    def __init__(self):
+        cfg = get_config().security
+        self._blacklist: list[re.Pattern] = [
+            re.compile(p) for p in cfg.get("env_blacklist", [])
+        ]
+        self._whitelist: list[re.Pattern] = [
+            re.compile(p) for p in cfg.get("env_whitelist", [])
+        ]
+
+    def is_safe(self, key: str) -> bool:
+        """Check if an env var key is safe to collect."""
+        # Whitelist takes priority
+        for pattern in self._whitelist:
+            if pattern.match(key):
+                return True
+        # Then check blacklist
+        for pattern in self._blacklist:
+            if pattern.match(key):
+                return False
+        # Not in either list → don't collect (conservative)
+        return False
+
+    def collect(self) -> dict:
+        result = {}
+        for key, value in os.environ.items():
+            if self.is_safe(key):
+                # Truncate long values (>500 chars)
+                result[key] = value[:500] if len(value) > 500 else value
+        return {"env": result}
+
+
+# Singleton
+_env_collector: EnvInfoCollector | None = None
+
+
+def get_env_collector() -> EnvInfoCollector:
+    global _env_collector
+    if _env_collector is None:
+        _env_collector = EnvInfoCollector()
+    return _env_collector

agent_gate/collector/network_info.py

@@ -0,0 +1,68 @@
+"""Network information collector: interfaces, active connections, public IP detection."""
+
+import os
+import socket
+
+
+class NetworkInfoCollector:
+    """Collects network interface and connection summary."""
+
+    @staticmethod
+    def collect() -> dict:
+        interfaces = _get_interfaces()
+        active_connections = _count_active_connections()
+        has_public_ip = _check_public_ip(interfaces)
+
+        return {
+            "network": {
+                "interfaces": interfaces,
+                "active_connections": active_connections,
+                "has_public_ip": has_public_ip,
+            }
+        }
+
+
+def _get_interfaces() -> list[str]:
+    """Get list of non-loopback network interfaces."""
+    ifaces = []
+    try:
+        for name in os.listdir("/sys/class/net/"):
+            if name != "lo":
+                ifaces.append(name)
+    except Exception:
+        pass
+    return ifaces
+
+
+def _count_active_connections() -> int:
+    """Count active network connections."""
+    count = 0
+    try:
+        # TCP connections
+        with open("/proc/net/tcp") as f:
+            lines = f.readlines()[1:]  # Skip header
+            count = len(lines)
+        with open("/proc/net/tcp6") as f:
+            lines = f.readlines()[1:]
+            count += len(lines)
+    except Exception:
+        pass
+    return count
+
+
+def _check_public_ip(interfaces: list[str]) -> bool:
+    """Check if any interface has a public IP."""
+    private_prefixes = ("10.", "172.16.", "172.17.", "172.18.",
+                        "172.19.", "172.20.", "172.21.", "172.22.",
+                        "172.23.", "172.24.", "172.25.", "172.26.",
+                        "172.27.", "172.28.", "172.29.", "172.30.",
+                        "172.31.", "192.168.", "127.")
+    try:
+        addrs = socket.getaddrinfo(socket.gethostname(), None)
+        for addr in addrs:
+            ip = addr[4][0]
+            if not any(ip.startswith(p) for p in private_prefixes):
+                return True
+    except Exception:
+        pass
+    return False

agent_gate/collector/process_info.py

@@ -0,0 +1,73 @@
+"""Process information collector: PID, parent process, capabilities, cgroup."""
+
+import os
+
+
+class ProcessInfoCollector:
+    """Collects information about the current process."""
+
+    @staticmethod
+    def collect() -> dict:
+        pid = os.getpid()
+        ppid = os.getppid()
+        name = ""
+        capabilities: list[str] = []
+        cgroup = ""
+
+        try:
+            with open(f"/proc/{pid}/comm") as f:
+                name = f.read().strip()
+        except Exception:
+            pass
+
+        try:
+            with open(f"/proc/{pid}/status") as f:
+                for line in f:
+                    if line.startswith("CapEff:"):
+                        caps_hex = line.split(":")[1].strip()
+                        capabilities = _parse_capabilities(caps_hex)
+                    elif line.startswith("Name:"):
+                        if not name:
+                            name = line.split(":")[1].strip()
+        except Exception:
+            pass
+
+        try:
+            with open(f"/proc/{pid}/cgroup") as f:
+                cgroup = f.readline().strip()
+        except Exception:
+            pass
+
+        return {
+            "process": {
+                "pid": pid,
+                "ppid": ppid,
+                "name": name,
+                "capabilities": capabilities,
+                "cgroup": cgroup,
+            }
+        }
+
+
+def _parse_capabilities(caps_hex: str) -> list[str]:
+    """Parse Linux capabilities from hex string."""
+    CAP_NAMES = [
+        "CAP_CHOWN", "CAP_DAC_OVERRIDE", "CAP_DAC_READ_SEARCH", "CAP_FOWNER",
+        "CAP_FSETID", "CAP_KILL", "CAP_SETGID", "CAP_SETUID",
+        "CAP_SETPCAP", "CAP_LINUX_IMMUTABLE", "CAP_NET_BIND_SERVICE",
+        "CAP_NET_BROADCAST", "CAP_NET_ADMIN", "CAP_NET_RAW",
+        "CAP_IPC_LOCK", "CAP_IPC_OWNER", "CAP_SYS_MODULE",
+        "CAP_SYS_RAWIO", "CAP_SYS_CHROOT", "CAP_SYS_PTRACE",
+        "CAP_SYS_PACCT", "CAP_SYS_ADMIN", "CAP_SYS_BOOT",
+        "CAP_SYS_NICE", "CAP_SYS_RESOURCE", "CAP_SYS_TIME",
+        "CAP_SYS_TTY_CONFIG", "CAP_MKNOD", "CAP_LEASE",
+        "CAP_AUDIT_WRITE", "CAP_AUDIT_CONTROL", "CAP_SETFCAP",
+        "CAP_MAC_OVERRIDE", "CAP_MAC_ADMIN", "CAP_SYSLOG",
+        "CAP_WAKE_ALARM", "CAP_BLOCK_SUSPEND", "CAP_AUDIT_READ",
+        "CAP_PERFMON", "CAP_BPF", "CAP_CHECKPOINT_RESTORE",
+    ]
+    try:
+        caps_int = int(caps_hex, 16)
+        return [name for i, name in enumerate(CAP_NAMES) if caps_int & (1 << i)]
+    except (ValueError, IndexError):
+        return []

agent_gate/collector/system_info.py

@@ -0,0 +1,54 @@
+"""System information collector: OS, kernel, CPU, memory, disk."""
+
+import os
+import platform
+from typing import Optional
+
+import psutil
+
+
+class SystemInfoCollector:
+    """Collects OS-level information."""
+
+    @staticmethod
+    def collect() -> dict:
+        try:
+            return {
+                "os": {
+                    "system": platform.system().lower(),
+                    "distribution": _get_distribution(),
+                    "kernel": platform.release(),
+                    "hostname": platform.node(),
+                    "machine": platform.machine(),
+                },
+                "resources": {
+                    "cpu_count": os.cpu_count() or 0,
+                    "cpu_percent": round(psutil.cpu_percent(interval=0.1), 1),
+                    "memory_total_gb": round(psutil.virtual_memory().total / (1024 ** 3), 1),
+                    "memory_percent": psutil.virtual_memory().percent,
+                    "disk_total_gb": round(
+                        psutil.disk_usage("/").total / (1024 ** 3), 1
+                    ),
+                    "disk_percent": psutil.disk_usage("/").percent,
+                },
+            }
+        except Exception:
+            return {"os": {}, "resources": {}}
+
+
+def _get_distribution() -> str:
+    """Detect Linux distribution name."""
+    try:
+        if os.path.exists("/etc/os-release"):
+            with open("/etc/os-release") as f:
+                info = {}
+                for line in f:
+                    if "=" in line:
+                        k, v = line.strip().split("=", 1)
+                        info[k] = v.strip('"')
+                name = info.get("NAME", "")
+                version = info.get("VERSION_ID", "")
+                return f"{name} {version}".strip()
+    except Exception:
+        pass
+    return platform.platform()