Skip to content

Personal AI, On Personal Devices

Python
6.7 KB
Raw Blame
"""Security guardrails — scanners, engine wrapper, audit, SSRF."""

from __future__ import annotations

import logging
from dataclasses import dataclass
from importlib import import_module
from typing import Any, Optional

from openjarvis.core.events import EventBus

logger = logging.getLogger(__name__)


@dataclass
class SecurityContext:
    """Result of setup_security() — wrapped engine, policy, audit."""

    engine: Any
    capability_policy: Any = None
    audit_logger: Any = None
    rate_limiter: Any = None


def setup_security(
    config: Any,
    engine: Any,
    bus: Optional[EventBus] = None,
) -> SecurityContext:
    """Apply security guardrails to an engine based on config.

    Returns a SecurityContext. No-ops if config.security.enabled is False.
    """
    if not config.security.enabled:
        return SecurityContext(engine=engine)

    from openjarvis.security._stubs import BaseScanner
    from openjarvis.security.audit import AuditLogger
    from openjarvis.security.guardrails import GuardrailsEngine
    from openjarvis.security.scanner import PIIScanner, SecretScanner
    from openjarvis.security.types import RedactionMode

    # Scanners + engine wrapping
    try:
        scanners: list[BaseScanner] = []
        if config.security.secret_scanner:
            scanners.append(SecretScanner())
        if config.security.pii_scanner:
            scanners.append(PIIScanner())

        if scanners:
            mode = RedactionMode(config.security.mode)
            engine = GuardrailsEngine(
                engine,
                scanners=scanners,
                mode=mode,
                scan_input=config.security.scan_input,
                scan_output=config.security.scan_output,
                bus=bus,
            )
    except Exception as exc:
        logger.debug("Failed to set up security scanners: %s", exc)

    # Capability policy
    cap_policy = None
    if config.security.capabilities.enabled:
        try:
            from openjarvis.security.capabilities import CapabilityPolicy

            cap_policy = CapabilityPolicy(
                policy_path=config.security.capabilities.policy_path or None,
                default_deny=config.security.capabilities.default_deny,
            )
            # No explicit policy file: grant a conservative baseline to the
            # "_default" wildcard agent so default-deny doesn't silently
            # break every managed agent (whose UUIDs aren't known ahead of
            # time). Read/fetch/memory only — writes, code execution, and
            # admin tools require an explicit per-agent grant.
            if (
                config.security.capabilities.default_deny
                and not config.security.capabilities.policy_path
            ):
                for cap in (
                    "file:read",
                    "network:fetch",
                    "memory:read",
                    "memory:write",
                ):
                    cap_policy.grant("_default", cap)
        except Exception as exc:
            # Explicitly enabled enforcement is a contract in every profile.
            # Missing native support or an invalid policy must not produce an
            # unrestricted executor merely because the profile is personal.
            raise RuntimeError("Capability policy initialization failed") from exc

    # Rate limiter — config.security.rate_limit_* were previously read by
    # nothing; this is the first thing in the codebase that actually turns
    # them into an enforced limiter.
    rate_limiter = None
    if config.security.rate_limit_enabled:
        try:
            from openjarvis.security.rate_limiter import RateLimitConfig, RateLimiter

            rate_limiter = RateLimiter(
                RateLimitConfig(
                    requests_per_minute=config.security.rate_limit_rpm,
                    burst_size=config.security.rate_limit_burst,
                    enabled=True,
                )
            )
        except Exception as exc:
            if config.security.profile in {"shared", "server"}:
                raise RuntimeError("Rate limiter initialization failed") from exc
            logger.warning("Failed to set up rate limiter: %s", exc)

    # Audit logger
    audit = None
    try:
        audit = AuditLogger(
            db_path=config.security.audit_log_path,
            bus=bus,
        )
    except Exception as exc:
        logger.debug("Failed to set up audit logger: %s", exc)

    return SecurityContext(
        engine=engine,
        capability_policy=cap_policy,
        audit_logger=audit,
        rate_limiter=rate_limiter,
    )


__all__ = [
    "AuditLogger",
    "BaseScanner",
    "DEFAULT_SENSITIVE_PATTERNS",
    "GuardrailsEngine",
    "PIIScanner",
    "RedactionMode",
    "ScanFinding",
    "ScanResult",
    "SecretScanner",
    "SecurityBlockError",
    "SecurityContext",
    "SecurityEvent",
    "SecurityEventType",
    "ThreatLevel",
    "check_ssrf",
    "filter_sensitive_paths",
    "is_private_ip",
    "is_sensitive_file",
    "setup_security",
]

_LAZY_EXPORTS = {
    "AuditLogger": ("openjarvis.security.audit", "AuditLogger"),
    "BaseScanner": ("openjarvis.security._stubs", "BaseScanner"),
    "DEFAULT_SENSITIVE_PATTERNS": (
        "openjarvis.security.file_policy",
        "DEFAULT_SENSITIVE_PATTERNS",
    ),
    "GuardrailsEngine": ("openjarvis.security.guardrails", "GuardrailsEngine"),
    "PIIScanner": ("openjarvis.security.scanner", "PIIScanner"),
    "RedactionMode": ("openjarvis.security.types", "RedactionMode"),
    "ScanFinding": ("openjarvis.security.types", "ScanFinding"),
    "ScanResult": ("openjarvis.security.types", "ScanResult"),
    "SecretScanner": ("openjarvis.security.scanner", "SecretScanner"),
    "SecurityBlockError": (
        "openjarvis.security.guardrails",
        "SecurityBlockError",
    ),
    "SecurityEvent": ("openjarvis.security.types", "SecurityEvent"),
    "SecurityEventType": ("openjarvis.security.types", "SecurityEventType"),
    "ThreatLevel": ("openjarvis.security.types", "ThreatLevel"),
    "check_ssrf": ("openjarvis.security.ssrf", "check_ssrf"),
    "filter_sensitive_paths": (
        "openjarvis.security.file_policy",
        "filter_sensitive_paths",
    ),
    "is_private_ip": ("openjarvis.security.ssrf", "is_private_ip"),
    "is_sensitive_file": ("openjarvis.security.file_policy", "is_sensitive_file"),
}


def __getattr__(name: str) -> Any:
    target = _LAZY_EXPORTS.get(name)
    if target is None:
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
    module_name, attribute = target
    value = getattr(import_module(module_name), attribute)
    globals()[name] = value
    return value


def __dir__() -> list[str]:
    return sorted(set(globals()) | set(_LAZY_EXPORTS))