zen-ai-pentest 2.0.0__py3-none-any.whl

agents/analysis_agent.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""
+Analysis Agent - Specializes in analyzing data and finding patterns
+Part of the Multi-Agent Collaboration System
+Author: SHAdd0WTAka
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, List
+
+from .agent_base import AgentMessage, AgentRole, BaseAgent
+
+logger = logging.getLogger("ZenAI.Agents")
+
+
+class AnalysisAgent(BaseAgent):
+    """
+    Analysis Agent - Analyzes findings, identifies patterns
+    Correlates data from multiple sources to identify attack paths
+    """
+
+    def __init__(self, name: str, orchestrator=None, zen_orchestrator=None):
+        super().__init__(name, AgentRole.ANALYST, orchestrator)
+        self.zen_orchestrator = zen_orchestrator
+        self.analysis_cache = {}
+
+        # Register handlers
+        self.register_handler("findings", self._handle_findings)
+        self.register_handler("analysis_request", self._handle_analysis_request)
+
+    async def _handle_findings(self, msg: AgentMessage):
+        """Process findings from other agents"""
+        findings = msg.context.get("findings", [])
+        source = msg.sender
+
+        logger.info(
+            f"[AnalysisAgent:{self.name}] Analyzing {len(findings)} findings from {source}"
+        )
+
+        # Perform analysis
+        analysis = await self._analyze_findings(findings)
+
+        # If critical patterns found, alert all agents
+        if analysis.get("critical_patterns"):
+            await self.send_message(
+                content=f"⚠️ Critical patterns detected! Risk level: {analysis['risk_level']}",
+                recipient="all",
+                msg_type="alert",
+                priority=4,  # Critical
+                context={
+                    "patterns": analysis["critical_patterns"],
+                    "recommendations": analysis["recommendations"],
+                },
+            )
+
+        # Send detailed analysis to requesting agent
+        await self.send_message(
+            content=f"Analysis complete: {analysis['summary']}",
+            recipient=msg.sender,
+            msg_type="analysis_result",
+            context={"analysis": analysis},
+        )
+
+        # Update shared context
+        self.update_context(f"analysis_{msg.id}", analysis, share=True)
+
+    async def _handle_analysis_request(self, msg: AgentMessage):
+        """Handle explicit analysis requests"""
+        data = msg.context.get("data", [])
+        analysis_type = msg.context.get("analysis_type", "general")
+
+        result = await self._analyze_data(data, analysis_type)
+
+        await self.send_message(
+            content=f"Analysis of {analysis_type} complete",
+            recipient=msg.sender,
+            msg_type="response",
+            context={"analysis": result},
+        )
+
+    async def _analyze_findings(self, findings: List[Dict]) -> Dict:
+        """Analyze findings and identify patterns"""
+        analysis = {
+            "total_findings": len(findings),
+            "by_type": {},
+            "critical_patterns": [],
+            "risk_level": "low",
+            "recommendations": [],
+            "summary": "",
+        }
+
+        # Categorize by type
+        for finding in findings:
+            f_type = finding.get("type", "unknown")
+            if f_type not in analysis["by_type"]:
+                analysis["by_type"][f_type] = []
+            analysis["by_type"][f_type].append(finding)
+
+        # Look for critical patterns
+        cves = [f for f in findings if f.get("type") == "cve"]
+        ransomware = [f for f in findings if f.get("type") == "ransomware"]
+
+        # Pattern 1: CVE associated with ransomware
+        for cve in cves:
+            cve_data = cve.get("data", {})
+            if hasattr(cve_data, "ransomware_used_by") and cve_data.ransomware_used_by:
+                analysis["critical_patterns"].append(
+                    {
+                        "type": "ransomware_cve",
+                        "description": f"{cve_data.cve_id} is used by ransomware",
+                        "affected": cve_data.ransomware_used_by,
+                    }
+                )
+                analysis["risk_level"] = "critical"
+
+        # Pattern 2: Multiple high-severity CVEs
+        high_cves = [c for c in cves if c.get("data", {}).get("severity") == "Critical"]
+        if len(high_cves) >= 3:
+            analysis["critical_patterns"].append(
+                {
+                    "type": "multiple_critical_cves",
+                    "description": f"Found {len(high_cves)} critical CVEs",
+                    "count": len(high_cves),
+                }
+            )
+            analysis["risk_level"] = "high"
+
+        # Generate recommendations using LLM
+        if self.zen_orchestrator and analysis["critical_patterns"]:
+            prompt = f"""
+            Analyze these security patterns and provide recommendations:
+            {analysis["critical_patterns"]}
+            
+            Provide:
+            1. Priority order for remediation
+            2. Immediate actions
+            3. Long-term security improvements
+            """
+
+            response = await self.zen_orchestrator.process(prompt)
+            analysis["recommendations"] = response.content.split("\n")
+
+        analysis["summary"] = (
+            f"Found {len(analysis['critical_patterns'])} critical patterns across {len(findings)} findings"
+        )
+
+        return analysis
+
+    async def _analyze_data(self, data: List, analysis_type: str) -> Dict:
+        """Generic data analysis"""
+        if analysis_type == "attack_path":
+            return await self._analyze_attack_paths(data)
+        elif analysis_type == "correlation":
+            return await self._correlate_data(data)
+        else:
+            return {"status": "unknown_analysis_type"}
+
+    async def _analyze_attack_paths(self, data: List) -> Dict:
+        """Analyze potential attack paths through the system"""
+        # This would use the LLM to chain together vulnerabilities
+        if self.zen_orchestrator:
+            prompt = f"""
+            Analyze these vulnerabilities and identify potential attack paths:
+            {data}
+            
+            Map out:
+            1. Entry points
+            2. Lateral movement possibilities
+            3. Critical asset exposure
+            4. Kill chain stages
+            """
+
+            response = await self.zen_orchestrator.process(prompt)
+
+            return {
+                "type": "attack_path_analysis",
+                "paths": response.content,
+                "agent": self.name,
+            }
+
+        return {"type": "attack_path_analysis", "paths": [], "agent": self.name}
+
+    async def _correlate_data(self, data: List) -> Dict:
+        """Find correlations between different data points"""
+        correlations = []
+
+        # Simple correlation: shared CVEs between findings
+        cve_sets = []
+        for item in data:
+            if "cves" in item:
+                cve_sets.append(set(item["cves"]))
+
+        # Find common CVEs
+        if len(cve_sets) >= 2:
+            common = cve_sets[0].intersection(*cve_sets[1:])
+            if common:
+                correlations.append(
+                    {
+                        "type": "shared_cves",
+                        "cves": list(common),
+                        "significance": "high",
+                    }
+                )
+
+        return {
+            "type": "correlation_analysis",
+            "correlations": correlations,
+            "agent": self.name,
+        }
+
+    async def execute_task(self, task: Dict) -> Dict:
+        """Execute analysis task"""
+        task_type = task.get("type", "")
+        context = task.get("context", {})
+
+        logger.info(f"[AnalysisAgent:{self.name}] Executing task: {task_type}")
+
+        if task_type == "vulnerability_analysis":
+            findings = context.get("findings", [])
+            analysis = await self._analyze_findings(findings)
+
+            return {"status": "complete", "analysis": analysis, "agent": self.name}
+
+        return {"status": "unknown_task"}

agents/cli.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+CLI Interface for Multi-Agent System
+Interactive commands for managing agents
+Author: SHAdd0WTAka
+"""
+
+import asyncio
+import sys
+from typing import Dict
+
+from backends.duckduckgo import DuckDuckGoBackend
+from core.orchestrator import ZenOrchestrator
+from utils.helpers import colorize
+
+from .integration import AgentSystemIntegration
+
+
+class AgentCLI:
+    """Command-line interface for the agent system"""
+
+    def __init__(self):
+        self.integration = None
+        self.zen_orchestrator = None
+
+    async def initialize(self):
+        """Initialize the system"""
+        print(colorize("[*] Initializing Zen AI Agent System...", "cyan"))
+
+        # Setup LLM orchestrator
+        self.zen_orchestrator = ZenOrchestrator()
+        async with DuckDuckGoBackend() as ddg:
+            self.zen_orchestrator.add_backend(ddg)
+
+        # Setup agent integration
+        self.integration = AgentSystemIntegration(self.zen_orchestrator)
+        await self.integration.initialize()
+
+        print(colorize("[+] Agent system ready!", "green"))
+        print()
+
+    def print_banner(self):
+        """Print agent system banner"""
+        print(
+            colorize(
+                """
+╔══════════════════════════════════════════════════════════════╗
+║           🤖 Zen AI Multi-Agent System 🤖                     ║
+║              (Inspired by Clawed/Moltbot)                    ║
+╠══════════════════════════════════════════════════════════════╣
+║  Agents: Research • Analysis • Exploit                       ║
+║  Features: Collaborative Research • Context Sharing          ║
+╚══════════════════════════════════════════════════════════════╝
+        """,
+                "bold",
+            )
+        )
+
+    def print_help(self):
+        """Print help message"""
+        help_text = """
+Available Commands:
+  research <topic>       - Start collaborative research on topic
+  analyze <target>       - Have agents analyze a target
+  discuss <topic>        - Facilitate agent discussion
+  status                 - Show agent system status
+  agents                 - List all active agents
+  context <key> <value>  - Share context with agents
+  chat <message>         - Send message to all agents
+  stop                   - Shutdown agent system
+  help                   - Show this help
+  quit/exit              - Exit
+
+Examples:
+  research WordPress CVEs
+  analyze example.com
+  discuss Attack vectors for CVE-2017-0144
+  context target example.com
+        """
+        print(help_text)
+
+    async def run(self):
+        """Main CLI loop"""
+        self.print_banner()
+        await self.initialize()
+        self.print_help()
+
+        while True:
+            try:
+                cmd = input(colorize("agents> ", "bold")).strip()
+
+                if not cmd:
+                    continue
+
+                parts = cmd.split(maxsplit=1)
+                command = parts[0].lower()
+                args = parts[1] if len(parts) > 1 else ""
+
+                if command in ("quit", "exit"):
+                    print(colorize("[*] Shutting down agent system...", "yellow"))
+                    await self.integration.shutdown()
+                    print(colorize("[+] Goodbye!", "green"))
+                    break
+
+                elif command == "help":
+                    self.print_help()
+
+                elif command == "research":
+                    if not args:
+                        print(colorize("[!] Usage: research <topic>", "red"))
+                        continue
+                    print(colorize(f"[*] Starting research on: {args}", "cyan"))
+                    thread_id = await self.integration.conduct_research(
+                        topic=args,
+                        pentest_context={
+                            "target_type": "unknown",
+                            "initiated_by": "user",
+                        },
+                    )
+                    print(
+                        colorize(f"[+] Research thread started: {thread_id}", "green")
+                    )
+                    print(
+                        colorize(
+                            "[*] Agents are working... Check status for updates",
+                            "yellow",
+                        )
+                    )
+
+                elif command == "analyze":
+                    if not args:
+                        print(colorize("[!] Usage: analyze <target>", "red"))
+                        continue
+                    print(colorize(f"[*] Analyzing target: {args}", "cyan"))
+                    results = await self.integration.analyze_target(
+                        target=args, findings=[]
+                    )
+                    print(colorize(f"[+] Analysis complete!", "green"))
+                    print(
+                        colorize(
+                            f"[*] Agent responses: {len(results.get('agent_responses', {}))}",
+                            "cyan",
+                        )
+                    )
+
+                elif command == "discuss":
+                    if not args:
+                        print(colorize("[!] Usage: discuss <topic>", "red"))
+                        continue
+                    print(
+                        colorize(
+                            f"[*] Facilitating agent discussion on: {args}", "cyan"
+                        )
+                    )
+                    messages = await self.integration.facilitate_discussion(
+                        topic=args, rounds=2
+                    )
+                    print(colorize("[+] Discussion complete:", "green"))
+                    for i, msg in enumerate(messages, 1):
+                        print(f"  {i}. {msg[:100]}...")
+
+                elif command == "status":
+                    status = self.integration.get_system_status()
+                    print(colorize("[*] Agent System Status:", "cyan"))
+                    print(f"  Active agents: {len(status.get('agents', {}))}")
+                    print(f"  Message count: {status.get('message_count', 0)}")
+                    print(
+                        f"  Shared context keys: {len(status.get('shared_context_keys', []))}"
+                    )
+                    print(f"  Role distribution: {status.get('role_distribution', {})}")
+
+                elif command == "agents":
+                    status = self.integration.get_system_status()
+                    print(colorize("[*] Active Agents:", "cyan"))
+                    for agent_id, agent_status in status.get("agents", {}).items():
+                        role = agent_status.get("role", "unknown")
+                        running = "✓" if agent_status.get("running") else "✗"
+                        print(
+                            f"  {running} {agent_status['name']} ({role}) [{agent_id}]"
+                        )
+                        print(
+                            f"     Queue: {agent_status.get('queue_size', 0)} | Inbox: {agent_status.get('inbox_count', 0)}"
+                        )
+
+                elif command == "context":
+                    if not args or len(args.split()) < 2:
+                        print(colorize("[!] Usage: context <key> <value>", "red"))
+                        continue
+                    key_val = args.split(maxsplit=1)
+                    key, value = key_val[0], key_val[1]
+                    await self.integration.share_context(key, value)
+                    print(colorize(f"[+] Shared context: {key} = {value}", "green"))
+
+                elif command == "chat":
+                    if not args:
+                        print(colorize("[!] Usage: chat <message>", "red"))
+                        continue
+                    # Send to all agents
+                    from .agent_base import AgentMessage
+
+                    for (
+                        agent_id,
+                        agent,
+                    ) in self.integration.agent_orchestrator.agents.items():
+                        await agent.receive_message(
+                            AgentMessage(
+                                sender="user",
+                                recipient=f"{agent.name}[{agent.id}]",
+                                msg_type="chat",
+                                content=args,
+                            )
+                        )
+                    print(colorize(f"[+] Message sent to all agents", "green"))
+
+                elif command == "stop":
+                    await self.integration.shutdown()
+                    print(colorize("[+] Agent system stopped", "green"))
+
+                else:
+                    print(colorize(f"[!] Unknown command: {command}", "red"))
+
+            except KeyboardInterrupt:
+                print(colorize("\n[*] Use 'quit' to exit", "yellow"))
+            except Exception as e:
+                print(colorize(f"[!] Error: {e}", "red"))
+
+
+async def main():
+    """Entry point for agent CLI"""
+    cli = AgentCLI()
+    try:
+        await cli.run()
+    except Exception as e:
+        print(colorize(f"[!] Fatal error: {e}", "red"))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    # Handle Windows Python 3.13+ compatibility
+    import sys
+
+    if sys.platform == "win32" and sys.version_info >= (3, 13):
+        from utils.async_fixes import apply_windows_async_fixes
+
+        apply_windows_async_fixes()
+
+        loop = asyncio.SelectorEventLoop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(main())
+        finally:
+            try:
+                loop.run_until_complete(asyncio.sleep(0.25))
+            except:
+                pass
+            loop.close()
+    else:
+        asyncio.run(main())