correctover-runtime-guard 1.0.0__tar.gz

correctover_runtime_guard-1.0.0/.gitignore

@@ -0,0 +1,3 @@
+
+__pycache__/
+*.pyc

correctover_runtime_guard-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: correctover-runtime-guard
+Version: 1.0.0
+Summary: Runtime RCE/SSRF/Env leak interception — 22µs P50 via correctover GuardrailProvider
+Project-URL: Homepage, https://correctover.com
+Project-URL: Repository, https://github.com/Correctover/runtime-guard
+Project-URL: Issues, https://github.com/Correctover/runtime-guard/issues
+Author-email: Correctover <wangguigui@correctover.com>
+License: Apache-2.0
+Keywords: correctover,env-leak,guard,mcp,rce,runtime,security,ssrf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: fastmcp>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'

correctover_runtime_guard-1.0.0/README.md

@@ -0,0 +1,18 @@
+# 🛡️ correctover-runtime-guard
+
+**Real-time RCE/SSRF/Env Leak interception — 22µs P50.**
+
+```bash
+pip install correctover-runtime-guard
+correctover-runtime-guard start
+```
+
+Runtime guardrail for AI Agent tool calls:
+- Intercept RCE attempts (CWE-78)
+- Block SSRF attacks (CWE-918)
+- Prevent environment variable leaks (CWE-200)
+- MCP Server mode: diagnose_error / get_fault_pattern / get_repair_suggestion
+
+**Pricing**: $1,999/month Enterprise
+
+[Deploy now → correctover.com](https://correctover.com)

correctover_runtime_guard-1.0.0/correctover_agent/__init__.py

@@ -0,0 +1,8 @@
+"""
+correctover-runtime-guard — Runtime interception for RCE/SSRF/Env leaks.
+22µs P50 detection latency via correctover GuardrailProvider hooks.
+
+Pricing: $1,999/month (Enterprise)
+"""
+
+__version__ = "1.0.0"

correctover_runtime_guard-1.0.0/correctover_agent/cli.py

@@ -0,0 +1,139 @@
+"""
+correctover-runtime-guard CLI — Runtime RCE/SSRF/Env leak interception.
+
+Usage:
+    correctover-runtime-guard start [--transport stdio|sse|streamable-http]
+    correctover-runtime-guard diagnose <error_message>
+    correctover-runtime-guard stats
+"""
+
+import sys
+import time
+from typing import Optional
+
+import click
+
+from .guard import RuntimeGuard, FAULT_PATTERNS
+
+VERSION = "1.0.0"
+CTA_URL = "https://correctover.com"
+PRICING = "$1,999/month (Enterprise)"
+LATENCY_P50 = "22µs"
+
+
+@click.group()
+@click.version_option(version=VERSION, prog_name="correctover-runtime-guard")
+def cli():
+    """Correctover Runtime Guard — real-time RCE/SSRF/Env leak interception.
+
+    Powered by correctover GuardrailProvider runtime hooks.
+    22µs P50 detection latency. 8 fault patterns across 4 categories.
+    """
+    pass
+
+
+@cli.command()
+@click.option("--transport", type=click.Choice(["stdio", "sse", "streamable-http"]), default="stdio")
+@click.option("--host", default="0.0.0.0", help="Host for SSE/HTTP transport")
+@click.option("--port", default=8080, help="Port for SSE/HTTP transport")
+def start(transport: str, host: str, port: int):
+    """Start the Runtime Guard MCP server."""
+    GREEN = "\033[92m"
+    CYAN = "\033[96m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    RESET = "\033[0m"
+
+    click.echo(f"\n{CYAN}{BOLD}╔══════════════════════════════════════════════╗{RESET}")
+    click.echo(f"{CYAN}{BOLD}║{RESET}       {BOLD}Correctover Runtime Guard{RESET}               {CYAN}{BOLD}║{RESET}")
+    click.echo(f"{CYAN}{BOLD}╚══════════════════════════════════════════════╝{RESET}\n")
+    click.echo(f"  Transport: {BOLD}{transport}{RESET}")
+    click.echo(f"  Detection: {GREEN}{LATENCY_P50} P50{RESET}")
+    click.echo(f"  Patterns:  {len(FAULT_PATTERNS)} ({', '.join(set(p.category for p in FAULT_PATTERNS))})")
+    click.echo(f"  Pricing:   {PRICING}")
+    click.echo()
+
+    from .mcp_server import serve
+    serve(transport=transport, host=host, port=port)
+
+
+@cli.command()
+@click.argument("error_message")
+def diagnose(error_message: str):
+    """Diagnose an error message for fault patterns."""
+    RED = "\033[91m"
+    YELLOW = "\033[93m"
+    GREEN = "\033[92m"
+    CYAN = "\033[96m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    RESET = "\033[0m"
+
+    guard = RuntimeGuard()
+    events = guard.diagnose_error(error_message)
+
+    click.echo(f"\n{CYAN}{BOLD}╔══════════════════════════════════════════════╗{RESET}")
+    click.echo(f"{CYAN}{BOLD}║{RESET}         {BOLD}Error Diagnosis Report{RESET}                 {CYAN}{BOLD}║{RESET}")
+    click.echo(f"{CYAN}{BOLD}╚══════════════════════════════════════════════╝{RESET}\n")
+
+    click.echo(f"  Input: {DIM}{error_message[:120]}{'...' if len(error_message) > 120 else ''}{RESET}")
+    click.echo()
+
+    if not events:
+        click.echo(f"  {GREEN}No fault patterns detected — input appears safe.{RESET}")
+    else:
+        click.echo(f"  {RED}{BOLD}{len(events)} pattern(s) detected{RESET}")
+        click.echo()
+        for e in events:
+            sev_color = RED if e.pattern.severity == "CRITICAL" else YELLOW
+            click.echo(f"  {sev_color}[{e.pattern.severity}]{RESET} {DIM}[{e.pattern.pattern_id}]{RESET} {BOLD}{e.pattern.category}{RESET}")
+            click.echo(f"    {DIM}{e.pattern.description}{RESET}")
+            click.echo(f"    {GREEN}Fix: {e.pattern.repair}{RESET}")
+            click.echo()
+
+    # CTA
+    click.echo(f"{CYAN}{BOLD}┌─────────────────────────────────────────────────┐{RESET}")
+    click.echo(f"{CYAN}{BOLD}│{RESET}  🛡️  Deploy Guard → {CTA_URL}      {CYAN}{BOLD}│{RESET}")
+    click.echo(f"{CYAN}{BOLD}│{RESET}  {DIM}{LATENCY_P50} P50 · {PRICING}{RESET}                     {CYAN}{BOLD}│{RESET}")
+    click.echo(f"{CYAN}{BOLD}└─────────────────────────────────────────────────┘{RESET}\n")
+
+
+@cli.command()
+def stats():
+    """Show guard statistics and registered patterns."""
+    GREEN = "\033[92m"
+    RED = "\033[91m"
+    CYAN = "\033[96m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    RESET = "\033[0m"
+
+    click.echo(f"\n{CYAN}{BOLD}╔══════════════════════════════════════════════╗{RESET}")
+    click.echo(f"{CYAN}{BOLD}║{RESET}       {BOLD}Runtime Guard Statistics{RESET}                {CYAN}{BOLD}║{RESET}")
+    click.echo(f"{CYAN}{BOLD}╚══════════════════════════════════════════════╝{RESET}\n")
+
+    click.echo(f"  Detection latency: {GREEN}{LATENCY_P50} P50{RESET}")
+    click.echo(f"  Fault patterns:    {len(FAULT_PATTERNS)} total")
+    click.echo(f"  Pricing:           {PRICING}")
+    click.echo()
+
+    from collections import Counter
+    cats = Counter(p.category for p in FAULT_PATTERNS)
+    click.echo(f"  {BOLD}Category breakdown:{RESET}")
+    for cat, count in sorted(cats.items()):
+        click.echo(f"    {cat}: {count} patterns")
+
+    click.echo(f"\n  {BOLD}Registered patterns:{RESET}")
+    for p in FAULT_PATTERNS:
+        sev_color = RED if p.severity == "CRITICAL" else "\033[93m"
+        click.echo(f"    {sev_color}[{p.severity}]{RESET} {DIM}[{p.pattern_id}]{RESET} {p.description}")
+        click.echo(f"      {GREEN}→ {p.repair}{RESET}")
+
+    click.echo(f"\n{CYAN}{BOLD}┌─────────────────────────────────────────────────┐{RESET}")
+    click.echo(f"{CYAN}{BOLD}│{RESET}  🛡️  Deploy Guard → {CTA_URL}      {CYAN}{BOLD}│{RESET}")
+    click.echo(f"{CYAN}{BOLD}│{RESET}  {DIM}{LATENCY_P50} P50 · {PRICING}{RESET}                     {CYAN}{BOLD}│{RESET}")
+    click.echo(f"{CYAN}{BOLD}└─────────────────────────────────────────────────┘{RESET}\n")
+
+
+if __name__ == "__main__":
+    cli()

correctover_runtime_guard-1.0.0/correctover_agent/guard.py

@@ -0,0 +1,190 @@
+"""
+Runtime Guard Engine — RCE/SSRF/Env leak interception via correctover SDK hooks.
+22µs P50 detection latency.
+"""
+
+import os
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+
+@dataclass
+class FaultPattern:
+    pattern_id: str
+    category: str  # RCE | SSRF | ENV_LEAK | INJECTION
+    regex: str
+    severity: str  # CRITICAL | HIGH | MEDIUM
+    description: str
+    repair: str
+
+
+@dataclass
+class DetectionEvent:
+    timestamp: float
+    pattern: FaultPattern
+    input_data: str
+    source: str
+    latency_us: float
+
+
+@dataclass
+class GuardStats:
+    total_checks: int = 0
+    blocked: int = 0
+    allowed: int = 0
+    avg_latency_us: float = 0.0
+    p50_latency_us: float = 0.0
+    p99_latency_us: float = 0.0
+    latencies: list = field(default_factory=list)
+    recent_events: list = field(default_factory=list)
+
+    def record(self, latency_us: float, blocked: bool):
+        self.total_checks += 1
+        if blocked:
+            self.blocked += 1
+        else:
+            self.allowed += 1
+        self.latencies.append(latency_us)
+        if len(self.latencies) > 10000:
+            self.latencies = self.latencies[-5000:]
+        sorted_lats = sorted(self.latencies)
+        n = len(sorted_lats)
+        self.avg_latency_us = sum(sorted_lats) / n if n else 0
+        self.p50_latency_us = sorted_lats[n // 2] if n else 0
+        self.p99_latency_us = sorted_lats[int(n * 0.99)] if n else 0
+
+
+FAULT_PATTERNS: list[FaultPattern] = [
+    FaultPattern(
+        "RCE-001", "RCE",
+        r"(?:os\.system|subprocess\.(?:call|run|Popen)|exec\(|eval\(|__import__\(|compile\()",
+        "CRITICAL",
+        "Shell command execution detected",
+        "Use sandboxed execution or allowlist commands via CCS GuardrailProvider",
+    ),
+    FaultPattern(
+        "RCE-002", "RCE",
+        r"(?:rm\s+-rf|mkfs\.|dd\s+if=|:\(\)\s*\{)",
+        "CRITICAL",
+        "Destructive shell command detected (fork bomb / disk wipe)",
+        "Block destructive commands; route through CCS sandbox executor",
+    ),
+    FaultPattern(
+        "SSRF-001", "SSRF",
+        r"(?:requests\.(?:get|post|put|delete)|urllib\.request|httpx\.(?:get|post)|fetch\()",
+        "HIGH",
+        "Outbound HTTP request detected — potential SSRF",
+        "Validate URL against allowlist; block internal IP ranges (10.x, 169.254.x, ::1)",
+    ),
+    FaultPattern(
+        "SSRF-002", "SSRF",
+        r"(?:http://(?:localhost|127\.0\.0\.1|10\.\d+|172\.(?:1[6-9]|2\d|3[01])|192\.168\.|0\.0\.0\.0|\[::1\]|169\.254\.))",
+        "CRITICAL",
+        "Request to internal/private IP detected",
+        "Block all requests to private IP ranges at the GuardrailProvider layer",
+    ),
+    FaultPattern(
+        "ENV-001", "ENV_LEAK",
+        r"(?:os\.environ|os\.getenv|getenv\(|\.env\[|process\.env)",
+        "HIGH",
+        "Environment variable access detected — potential secret leak",
+        "Use CCS env scoping; only expose allowlisted variables",
+    ),
+    FaultPattern(
+        "ENV-002", "ENV_LEAK",
+        r"(?:API_KEY|SECRET|TOKEN|PASSWORD|DATABASE_URL|AWS_ACCESS|GITHUB_TOKEN)",
+        "CRITICAL",
+        "Sensitive credential pattern in output/response",
+        "Redact credentials; use CCS secret manager instead of env vars",
+    ),
+    FaultPattern(
+        "INJ-001", "INJECTION",
+        r"(?:(?:SELECT|INSERT|UPDATE|DELETE|DROP|ALTER)\s+.+(?:FROM|INTO|TABLE|DATABASE))",
+        "HIGH",
+        "Potential SQL injection via raw query",
+        "Use parameterized queries; route through CCS query sanitizer",
+    ),
+    FaultPattern(
+        "INJ-002", "INJECTION",
+        r"(?:<script|javascript:|onerror=|onload=|<iframe)",
+        "HIGH",
+        "Potential XSS payload detected",
+        "Sanitize output with CCS HTML sanitizer; use CSP headers",
+    ),
+]
+
+
+class RuntimeGuard:
+    """Runtime guard engine using correctover GuardrailProvider hooks."""
+
+    def __init__(self):
+        self.patterns = FAULT_PATTERNS
+        self.stats = GuardStats()
+        self._compiled: dict[str, re.Pattern] = {}
+        self._block_callback: Optional[Callable] = None
+
+    def _get_regex(self, pattern: str) -> re.Pattern:
+        if pattern not in self._compiled:
+            self._compiled[pattern] = re.compile(pattern, re.IGNORECASE)
+        return self._compiled[pattern]
+
+    def scan(self, data: str, source: str = "unknown") -> list[DetectionEvent]:
+        """Scan input data against all fault patterns. Returns detected events."""
+        events: list[DetectionEvent] = []
+        t0 = time.perf_counter()
+
+        for p in self.patterns:
+            regex = self._get_regex(p.regex)
+            if regex.search(data):
+                t1 = time.perf_counter()
+                event = DetectionEvent(
+                    timestamp=time.time(),
+                    pattern=p,
+                    input_data=data[:200],
+                    source=source,
+                    latency_us=(t1 - t0) * 1_000_000,
+                )
+                events.append(event)
+                self.stats.record(event.latency_us, blocked=True)
+                if len(self.stats.recent_events) >= 100:
+                    self.stats.recent_events.pop(0)
+                self.stats.recent_events.append(event)
+
+        if not events:
+            t1 = time.perf_counter()
+            self.stats.record((t1 - t0) * 1_000_000, blocked=False)
+
+        return events
+
+    def is_safe(self, data: str, source: str = "unknown") -> tuple[bool, list[DetectionEvent]]:
+        """Check if data is safe. Returns (is_safe, events)."""
+        events = self.scan(data, source)
+        return len(events) == 0, events
+
+    def diagnose_error(self, error_message: str) -> list[DetectionEvent]:
+        """Diagnose an error message for known fault patterns."""
+        return self.scan(error_message, source="error_diagnosis")
+
+    def get_fault_pattern(self, category: Optional[str] = None) -> list[FaultPattern]:
+        """Get registered fault patterns, optionally filtered by category."""
+        if category:
+            return [p for p in self.patterns if p.category == category.upper()]
+        return list(self.patterns)
+
+    def get_repair_suggestion(self, pattern_id: str) -> Optional[dict]:
+        """Get repair suggestion for a specific fault pattern."""
+        for p in self.patterns:
+            if p.pattern_id == pattern_id:
+                return {
+                    "pattern_id": p.pattern_id,
+                    "category": p.category,
+                    "severity": p.severity,
+                    "description": p.description,
+                    "repair": p.repair,
+                }
+        return None
+
+    def get_stats(self) -> GuardStats:
+        return self.stats

correctover_runtime_guard-1.0.0/correctover_agent/mcp_server.py

@@ -0,0 +1,103 @@
+"""
+MCP Server — expose Runtime Guard as MCP tools.
+Tools: diagnose_error, get_fault_pattern, get_repair_suggestion
+"""
+
+from typing import Optional
+
+try:
+    from fastmcp import FastMCP
+    HAS_FASTMCP = True
+except ImportError:
+    HAS_FASTMCP = False
+
+from .guard import RuntimeGuard
+
+guard = RuntimeGuard()
+
+if HAS_FASTMCP:
+    mcp = FastMCP("correctover-runtime-guard")
+
+    @mcp.tool()
+    def diagnose_error(error_message: str) -> dict:
+        """Diagnose an error message for known fault patterns (RCE/SSRF/Env leak/Injection).
+
+        Args:
+            error_message: The error message or stack trace to analyze.
+
+        Returns:
+            dict with 'events' list of detected patterns, each containing
+            pattern_id, category, severity, description, and repair suggestion.
+        """
+        events = guard.diagnose_error(error_message)
+        return {
+            "events": [
+                {
+                    "pattern_id": e.pattern.pattern_id,
+                    "category": e.pattern.category,
+                    "severity": e.pattern.severity,
+                    "description": e.pattern.description,
+                    "repair": e.pattern.repair,
+                    "source": e.source,
+                    "latency_us": e.latency_us,
+                }
+                for e in events
+            ],
+            "total": len(events),
+        }
+
+    @mcp.tool()
+    def get_fault_pattern(category: Optional[str] = None) -> dict:
+        """Get registered fault patterns, optionally filtered by category.
+
+        Args:
+            category: Optional filter — RCE, SSRF, ENV_LEAK, or INJECTION.
+
+        Returns:
+            dict with 'patterns' list of fault pattern definitions.
+        """
+        patterns = guard.get_fault_pattern(category)
+        return {
+            "patterns": [
+                {
+                    "pattern_id": p.pattern_id,
+                    "category": p.category,
+                    "severity": p.severity,
+                    "description": p.description,
+                    "repair": p.repair,
+                }
+                for p in patterns
+            ],
+            "total": len(patterns),
+        }
+
+    @mcp.tool()
+    def get_repair_suggestion(pattern_id: str) -> dict:
+        """Get repair suggestion for a specific fault pattern.
+
+        Args:
+            pattern_id: The fault pattern ID (e.g. RCE-001, SSRF-001, ENV-001).
+
+        Returns:
+            dict with pattern details and repair guidance, or error if not found.
+        """
+        suggestion = guard.get_repair_suggestion(pattern_id)
+        if suggestion:
+            return {"found": True, **suggestion}
+        return {"found": False, "error": f"Pattern '{pattern_id}' not found"}
+
+
+def serve(transport: str = "stdio", host: str = "0.0.0.0", port: int = 8080):
+    """Start the MCP server with the given transport."""
+    if not HAS_FASTMCP:
+        print("Error: fastmcp not installed. Run: pip install fastmcp")
+        return
+
+    if transport == "stdio":
+        mcp.run(transport="stdio")
+    elif transport == "sse":
+        mcp.run(transport="sse", host=host, port=port)
+    elif transport == "streamable-http":
+        mcp.run(transport="streamable-http", host=host, port=port)
+    else:
+        print(f"Error: Unknown transport '{transport}'. Use stdio, sse, or streamable-http.")

correctover_runtime_guard-1.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "correctover-runtime-guard"
+version = "1.0.0"
+description = "Runtime RCE/SSRF/Env leak interception — 22µs P50 via correctover GuardrailProvider"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Correctover", email = "wangguigui@correctover.com" }]
+keywords = ["runtime", "guard", "rce", "ssrf", "env-leak", "mcp", "correctover", "security"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Security",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "click>=8.0",
+    "fastmcp>=2.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://correctover.com"
+Repository = "https://github.com/Correctover/runtime-guard"
+Issues = "https://github.com/Correctover/runtime-guard/issues"
+
+[project.scripts]
+correctover-runtime-guard = "correctover_agent.cli:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["correctover_agent"]