honeymcp 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

honeymcp/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI application for HoneyMCP."""

honeymcp/api/app.py

@@ -0,0 +1,218 @@
+"""HoneyMCP FastAPI service for dashboard consumption."""
+
+from __future__ import annotations
+
+import os
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+from honeymcp.models.config import HoneyMCPConfig
+from honeymcp.models.events import AttackFingerprint
+from honeymcp.storage.event_store import get_event, list_events
+
+
+class EventListResponse(BaseModel):
+    """Paginated event list response."""
+
+    total: int = Field(description="Total events matching the filters")
+    count: int = Field(description="Number of events returned in this page")
+    offset: int = Field(description="Offset for pagination")
+    limit: int = Field(description="Limit for pagination")
+    events: List[AttackFingerprint] = Field(description="Event records")
+
+
+class MetricsResponse(BaseModel):
+    """Aggregate metrics for dashboard summaries."""
+
+    total_attacks: int
+    attacks_last_24h: int
+    critical_threats: int
+    unique_tools: int
+    unique_sessions: int
+    by_threat_level: Dict[str, int]
+    by_category: Dict[str, int]
+
+
+class FiltersResponse(BaseModel):
+    """Distinct filter values for UI dropdowns."""
+
+    threat_levels: List[str]
+    categories: List[str]
+    tools: List[str]
+
+
+def _apply_filters(
+    events: List[AttackFingerprint],
+    threat_level: Optional[str],
+    category: Optional[str],
+    tool: Optional[str],
+) -> List[AttackFingerprint]:
+    filtered = events
+    if threat_level:
+        filtered = [
+            event
+            for event in filtered
+            if event.threat_level.lower() == threat_level.lower()
+        ]
+    if category:
+        filtered = [event for event in filtered if event.attack_category == category]
+    if tool:
+        filtered = [event for event in filtered if event.ghost_tool_called == tool]
+    return filtered
+
+
+def _metrics(events: List[AttackFingerprint]) -> MetricsResponse:
+    now = datetime.utcnow()
+    total_attacks = len(events)
+    attacks_last_24h = len([event for event in events if now - event.timestamp < timedelta(days=1)])
+    critical_threats = len([event for event in events if event.threat_level == "critical"])
+    unique_tools = len({event.ghost_tool_called for event in events})
+    unique_sessions = len({event.session_id for event in events})
+
+    by_threat_level: Dict[str, int] = {}
+    by_category: Dict[str, int] = {}
+    for event in events:
+        by_threat_level[event.threat_level] = by_threat_level.get(event.threat_level, 0) + 1
+        by_category[event.attack_category] = by_category.get(event.attack_category, 0) + 1
+
+    return MetricsResponse(
+        total_attacks=total_attacks,
+        attacks_last_24h=attacks_last_24h,
+        critical_threats=critical_threats,
+        unique_tools=unique_tools,
+        unique_sessions=unique_sessions,
+        by_threat_level=by_threat_level,
+        by_category=by_category,
+    )
+
+
+def _configure_cors(app: FastAPI) -> None:
+    origins_raw = os.getenv("HONEYMCP_API_CORS_ORIGINS", "").strip()
+    if not origins_raw:
+        return
+    origins = [origin.strip() for origin in origins_raw.split(",") if origin.strip()]
+    if not origins:
+        return
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+
+def create_app(config_path: Optional[Path | str] = None) -> FastAPI:
+    """Create a FastAPI app configured with HoneyMCP settings."""
+    config = HoneyMCPConfig.load(config_path)
+
+    app = FastAPI(
+        title="HoneyMCP API",
+        version="0.1.0",
+        description="HTTP API for HoneyMCP dashboard consumption",
+    )
+    _configure_cors(app)
+
+    app.state.config = config
+    app.state.event_storage_path = config.event_storage_path
+    dashboard_root = Path(__file__).resolve().parent.parent / "dashboard" / "react_umd"
+    app.state.dashboard_root = dashboard_root
+
+    if dashboard_root.exists():
+        app.mount(
+            "/dashboard/assets",
+            StaticFiles(directory=str(dashboard_root)),
+            name="dashboard_assets",
+        )
+
+    @app.get("/health")
+    async def health() -> Dict[str, str]:
+        return {"status": "ok", "timestamp": datetime.utcnow().isoformat() + "Z"}
+
+    @app.get("/dashboard")
+    @app.get("/dashboard/", include_in_schema=False)
+    async def react_dashboard() -> FileResponse:
+        index_path = app.state.dashboard_root / "index.html"
+        if not index_path.exists():
+            raise HTTPException(status_code=404, detail="Dashboard UI not found")
+        return FileResponse(index_path)
+
+    @app.get("/events", response_model=EventListResponse)
+    async def get_events(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+        threat_level: Optional[str] = Query(default=None),
+        category: Optional[str] = Query(default=None),
+        tool: Optional[str] = Query(default=None),
+        limit: int = Query(default=200, ge=1, le=1000),
+        offset: int = Query(default=0, ge=0),
+    ) -> EventListResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        filtered = _apply_filters(events, threat_level, category, tool)
+        total = len(filtered)
+        page = filtered[offset : offset + limit]
+        return EventListResponse(
+            total=total,
+            count=len(page),
+            offset=offset,
+            limit=limit,
+            events=page,
+        )
+
+    @app.get("/events/{event_id}", response_model=AttackFingerprint)
+    async def get_event_by_id(event_id: str) -> AttackFingerprint:
+        event = await get_event(event_id, storage_path=app.state.event_storage_path)
+        if event is None:
+            raise HTTPException(status_code=404, detail="Event not found")
+        return event
+
+    @app.get("/metrics", response_model=MetricsResponse)
+    async def get_metrics(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+        threat_level: Optional[str] = Query(default=None),
+        category: Optional[str] = Query(default=None),
+        tool: Optional[str] = Query(default=None),
+    ) -> MetricsResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        filtered = _apply_filters(events, threat_level, category, tool)
+        return _metrics(filtered)
+
+    @app.get("/filters", response_model=FiltersResponse)
+    async def get_filters(
+        start_date: Optional[date] = Query(default=None),
+        end_date: Optional[date] = Query(default=None),
+    ) -> FiltersResponse:
+        events = await list_events(
+            storage_path=app.state.event_storage_path,
+            start_date=start_date,
+            end_date=end_date,
+        )
+        threat_levels = sorted({event.threat_level for event in events})
+        categories = sorted({event.attack_category for event in events})
+        tools = sorted({event.ghost_tool_called for event in events})
+        return FiltersResponse(
+            threat_levels=threat_levels,
+            categories=categories,
+            tools=tools,
+        )
+
+    return app
+
+
+app = create_app()

honeymcp/cli_tool_creator.py

@@ -0,0 +1,110 @@
+"""CLI command for creating new honeypot tools."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from honeymcp.core.tool_creator import ToolCreatorAgent
+from honeymcp.core.catalog_updater import CatalogUpdater
+
+
+def create_tool_command(description: str, project_root: Optional[Path] = None) -> int:
+    """CLI command to create a new honeypot tool.
+    
+    Args:
+        description: Natural language description of the tool
+        project_root: Optional project root path
+        
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    print("🍯 HoneyMCP Tool Creator")
+    print("=" * 50)
+    print(f"\nDescription: {description}\n")
+    
+    # Step 1: Create tool using ReAct agent
+    print("Step 1: Analyzing description and generating tool specification...")
+    agent = ToolCreatorAgent()
+    success, tool_spec, errors = agent.create_tool(description)
+    
+    if not success:
+        print("❌ Failed to create tool specification:")
+        for error in errors:
+            print(f"  - {error}")
+        return 1
+    
+    print(f"✅ Tool specification created: {tool_spec.name}")
+    print(f"   Category: {tool_spec.attack_category}")
+    print(f"   Threat Level: {tool_spec.threat_level}")
+    
+    # Show reasoning process
+    state = agent.get_state_summary()
+    if state["reasoning"]:
+        print("\n📝 Agent Reasoning:")
+        for i, thought in enumerate(state["reasoning"], 1):
+            print(f"   {i}. {thought}")
+    
+    if state["reflections"]:
+        print("\n🔍 Quality Reflections:")
+        for i, reflection in enumerate(state["reflections"], 1):
+            print(f"   {i}. {reflection}")
+    
+    # Step 2: Get response function code
+    print("\nStep 2: Extracting response generator code...")
+    # We need to regenerate the code since we can't extract it from the spec
+    # This is a limitation - in production, we'd store it in the agent
+    from honeymcp.core.tool_creator import ToolSpecification
+    
+    # Recreate spec for code generation
+    temp_spec = ToolSpecification(
+        name=tool_spec.name,
+        description=tool_spec.description,
+        parameters=tool_spec.parameters,
+        required_params=tool_spec.parameters.get("required", []),
+        category=agent._determine_category(description),
+        threat_level=agent._determine_threat_level(description),
+        response_template=""
+    )
+    response_func_code = agent._generate_response_function(temp_spec)
+    print(f"✅ Response generator created ({len(response_func_code)} chars)")
+    
+    # Step 3: Update catalog
+    print("\nStep 3: Adding tool to catalog...")
+    updater = CatalogUpdater(project_root)
+    success, errors = updater.add_tool_complete(tool_spec, response_func_code)
+    
+    if not success:
+        print("❌ Failed to update catalog:")
+        for error in errors:
+            print(f"  - {error}")
+        return 1
+    
+    print("✅ Tool added to ghost_tools.py")
+    print("✅ Handler added to middleware.py")
+    
+    # Step 4: Summary
+    print("\n" + "=" * 50)
+    print("✅ Tool creation complete!")
+    print(f"\nNew tool: {tool_spec.name}")
+    print(f"Description: {tool_spec.description}")
+    print(f"\nTo use this tool:")
+    print(f'  mcp = honeypot(mcp, ghost_tools=["{tool_spec.name}"])')
+    print("\nOr it will be available in dynamic mode automatically.")
+    
+    return 0
+
+
+def main():
+    """Main CLI entry point."""
+    if len(sys.argv) < 2:
+        print("Usage: honeymcp create-tool <description>")
+        print("\nExample:")
+        print('  honeymcp create-tool "dump container registry credentials"')
+        return 1
+    
+    description = " ".join(sys.argv[1:])
+    return create_tool_command(description)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

honeymcp/core/catalog_updater.py

@@ -0,0 +1,290 @@
+"""Catalog updater for adding new honeypot tools to ghost_tools.py and middleware.py"""
+
+import ast
+import re
+from pathlib import Path
+from typing import Tuple, List, Optional
+
+from honeymcp.models.ghost_tool_spec import GhostToolSpec
+
+
+class CatalogUpdater:
+    """Updates ghost_tools.py and middleware.py with new honeypot tools."""
+
+    def __init__(self, project_root: Optional[Path] = None):
+        """Initialize catalog updater.
+        
+        Args:
+            project_root: Root directory of HoneyMCP project. If None, auto-detects.
+        """
+        if project_root is None:
+            # Auto-detect project root
+            current = Path(__file__).resolve()
+            while current.parent != current:
+                if (current / "src" / "honeymcp").exists():
+                    project_root = current
+                    break
+                current = current.parent
+        
+        self.project_root = project_root
+        self.ghost_tools_path = project_root / "src" / "honeymcp" / "core" / "ghost_tools.py"
+        self.middleware_path = project_root / "src" / "honeymcp" / "core" / "middleware.py"
+
+    def add_tool_to_catalog(
+        self, 
+        tool_spec: GhostToolSpec,
+        response_func_code: str
+    ) -> Tuple[bool, List[str]]:
+        """Add new tool to ghost_tools.py catalog.
+        
+        Args:
+            tool_spec: GhostToolSpec for the new tool
+            response_func_code: Python code for response generator function
+            
+        Returns:
+            Tuple of (success, errors)
+        """
+        errors = []
+        
+        # Step 1: Validate tool doesn't already exist
+        if self._tool_exists(tool_spec.name):
+            errors.append(f"Tool '{tool_spec.name}' already exists in catalog")
+            return False, errors
+        
+        # Step 2: Read current ghost_tools.py
+        try:
+            content = self.ghost_tools_path.read_text()
+        except Exception as e:
+            errors.append(f"Failed to read ghost_tools.py: {e}")
+            return False, errors
+        
+        # Step 3: Add response generator function
+        updated_content = self._add_response_generator(content, response_func_code)
+        
+        # Step 4: Add tool to GHOST_TOOL_CATALOG
+        updated_content = self._add_to_catalog(updated_content, tool_spec)
+        
+        # Step 5: Validate syntax
+        try:
+            ast.parse(updated_content)
+        except SyntaxError as e:
+            errors.append(f"Generated code has syntax error: {e}")
+            return False, errors
+        
+        # Step 6: Write updated file
+        try:
+            self.ghost_tools_path.write_text(updated_content)
+        except Exception as e:
+            errors.append(f"Failed to write ghost_tools.py: {e}")
+            return False, errors
+        
+        return True, []
+
+    def add_tool_to_middleware(self, tool_spec: GhostToolSpec) -> Tuple[bool, List[str]]:
+        """Add new tool handler to middleware.py.
+        
+        Args:
+            tool_spec: GhostToolSpec for the new tool
+            
+        Returns:
+            Tuple of (success, errors)
+        """
+        errors = []
+        
+        # Step 1: Read current middleware.py
+        try:
+            content = self.middleware_path.read_text()
+        except Exception as e:
+            errors.append(f"Failed to read middleware.py: {e}")
+            return False, errors
+        
+        # Step 2: Generate handler code
+        handler_code = self._generate_handler_code(tool_spec)
+        
+        # Step 3: Insert handler before "else:" clause
+        updated_content = self._insert_handler(content, handler_code)
+        
+        # Step 4: Validate syntax
+        try:
+            ast.parse(updated_content)
+        except SyntaxError as e:
+            errors.append(f"Generated middleware code has syntax error: {e}")
+            return False, errors
+        
+        # Step 5: Write updated file
+        try:
+            self.middleware_path.write_text(updated_content)
+        except Exception as e:
+            errors.append(f"Failed to write middleware.py: {e}")
+            return False, errors
+        
+        return True, []
+
+    def _tool_exists(self, tool_name: str) -> bool:
+        """Check if tool already exists in catalog."""
+        content = self.ghost_tools_path.read_text()
+        return f'"{tool_name}": GhostToolSpec(' in content
+
+    def _add_response_generator(self, content: str, func_code: str) -> str:
+        """Add response generator function to ghost_tools.py."""
+        # Find the last response generator function
+        last_func_pattern = r'(def generate_fake_\w+\(args: Dict\[str, Any\]\) -> str:.*?(?=\n\ndef |\n\n# Ghost tool catalog))'
+        matches = list(re.finditer(last_func_pattern, content, re.DOTALL))
+        
+        if matches:
+            last_match = matches[-1]
+            insert_pos = last_match.end()
+            # Add new function after last one
+            return content[:insert_pos] + "\n\n" + func_code.rstrip() + "\n" + content[insert_pos:]
+        else:
+            # No functions found, add before catalog
+            catalog_pos = content.find("# Ghost tool catalog")
+            if catalog_pos > 0:
+                return content[:catalog_pos] + func_code.rstrip() + "\n\n" + content[catalog_pos:]
+        
+        return content
+
+    def _add_to_catalog(self, content: str, tool_spec: GhostToolSpec) -> str:
+        """Add tool entry to GHOST_TOOL_CATALOG dictionary."""
+        # Generate catalog entry
+        catalog_entry = self._generate_catalog_entry(tool_spec)
+        
+        # Find the closing brace of GHOST_TOOL_CATALOG
+        # Look for the last tool entry before the closing brace
+        pattern = r'(    "[\w_]+": GhostToolSpec\(.*?\),)\n(\})'
+        
+        def replacer(match):
+            last_entry = match.group(1)
+            closing_brace = match.group(2)
+            return f"{last_entry}\n{catalog_entry}\n{closing_brace}"
+        
+        updated = re.sub(pattern, replacer, content, flags=re.DOTALL)
+        
+        return updated
+
+    def _generate_catalog_entry(self, tool_spec: GhostToolSpec) -> str:
+        """Generate catalog entry code for tool."""
+        # Format parameters as Python dict
+        params_str = str(tool_spec.parameters).replace("'", '"')
+        
+        entry = f'''    "{tool_spec.name}": GhostToolSpec(
+        name="{tool_spec.name}",
+        description="{tool_spec.description}",
+        parameters={params_str},
+        response_generator=generate_fake_{tool_spec.name},
+        threat_level="{tool_spec.threat_level}",
+        attack_category="{tool_spec.attack_category}",
+    ),'''
+        
+        return entry
+
+    def _generate_handler_code(self, tool_spec: GhostToolSpec) -> str:
+        """Generate middleware handler code for tool."""
+        # Extract parameters
+        properties = tool_spec.parameters.get("properties", {})
+        required = tool_spec.parameters.get("required", [])
+        
+        # Build parameter list
+        params = []
+        for param_name, param_spec in properties.items():
+            param_type = self._python_type_from_json_type(param_spec.get("type", "string"))
+            if param_name in required:
+                params.append(f"{param_name}: {param_type}")
+            else:
+                default = self._get_param_default(param_name, param_spec)
+                params.append(f"{param_name}: {param_type} = {default}")
+        
+        params_str = ", ".join(params) if params else ""
+        
+        # Build args dict
+        if params:
+            args_dict_lines = [f'                {{"{p.split(":")[0].strip()}": {p.split(":")[0].strip()}}}' 
+                             for p in params]
+            args_dict = "{\n" + ",\n".join([f'                "{p.split(":")[0].strip()}": {p.split(":")[0].strip()}' 
+                                           for p in params]) + "\n            }"
+        else:
+            args_dict = "{}"
+        
+        handler = f'''    elif ghost_spec.name == "{tool_spec.name}":
+
+        @server.tool(name=ghost_spec.name, description=ghost_spec.description)
+        async def handler({params_str}):
+            """Generated handler for {tool_spec.name} (fallback only)."""
+            return ghost_spec.response_generator({args_dict})
+'''
+        
+        return handler
+
+    def _python_type_from_json_type(self, json_type: str) -> str:
+        """Convert JSON schema type to Python type hint."""
+        type_map = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+            "array": "list",
+            "object": "dict"
+        }
+        return type_map.get(json_type, "str")
+
+    def _get_param_default(self, param_name: str, param_spec: dict) -> str:
+        """Get default value for parameter."""
+        param_type = param_spec.get("type", "string")
+        
+        if param_type == "integer":
+            if "limit" in param_name or "count" in param_name:
+                return "10"
+            elif "duration" in param_name:
+                return "60"
+            return "0"
+        elif param_type == "boolean":
+            return "True"
+        elif param_type == "string":
+            return f'"{param_name}_default"'
+        else:
+            return "None"
+
+    def _insert_handler(self, content: str, handler_code: str) -> str:
+        """Insert handler code before the final else clause."""
+        # Find the last "elif ghost_spec.name ==" before "else:"
+        pattern = r'(    elif ghost_spec\.name == "[\w_]+":\n.*?return ghost_spec\.response_generator\(.*?\)\n)\n(    else:\n        raise ValueError)'
+        
+        def replacer(match):
+            last_handler = match.group(1)
+            else_clause = match.group(2)
+            return f"{last_handler}\n{handler_code}\n{else_clause}"
+        
+        updated = re.sub(pattern, replacer, content, flags=re.DOTALL)
+        
+        return updated
+
+    def add_tool_complete(
+        self, 
+        tool_spec: GhostToolSpec,
+        response_func_code: str
+    ) -> Tuple[bool, List[str]]:
+        """Complete workflow: add tool to both catalog and middleware.
+        
+        Args:
+            tool_spec: GhostToolSpec for the new tool
+            response_func_code: Python code for response generator function
+            
+        Returns:
+            Tuple of (success, errors)
+        """
+        all_errors = []
+        
+        # Step 1: Add to ghost_tools.py
+        success, errors = self.add_tool_to_catalog(tool_spec, response_func_code)
+        if not success:
+            all_errors.extend(errors)
+            return False, all_errors
+        
+        # Step 2: Add to middleware.py
+        success, errors = self.add_tool_to_middleware(tool_spec)
+        if not success:
+            all_errors.extend(errors)
+            # Rollback ghost_tools.py changes would go here
+            return False, all_errors
+        
+        return True, []