zen-ai-pentest 2.1.0__tar.gz → 2.2.0__tar.gz

{zen_ai_pentest-2.1.0 → zen_ai_pentest-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zen-ai-pentest
-Version: 2.1.0
+Version: 2.2.0
 Summary: Advanced AI-Powered Penetration Testing Framework with Multi-Agent Orchestration
 Home-page: https://github.com/SHAdd0WTAka/zen-ai-pentest
 Author: SHAdd0WTAka

{zen_ai_pentest-2.1.0 → zen_ai_pentest-2.2.0}/api/main.py

@@ -60,7 +60,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="Zen-AI-Pentest API",
     description="Professional Pentesting Framework API",
-    version="2.1.0",
+    version="2.2.0",
     lifespan=lifespan
 )
 
@@ -500,7 +500,7 @@ async def health_check():
     """Health check endpoint"""
     return {
         "status": "healthy",
-        "version": "2.1.0",
+        "version": "2.2.0",
         "timestamp": datetime.utcnow().isoformat()
     }
 

zen_ai_pentest-2.2.0/api/websocket_v2.py

@@ -0,0 +1,181 @@
+"""
+WebSocket v2.0 - Real-time Updates
+Q2 2026 Feature
+"""
+
+import json
+import logging
+from typing import Dict, Set
+from fastapi import WebSocket, WebSocketDisconnect
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class ConnectionManagerV2:
+    """Advanced WebSocket connection manager with rooms"""
+    
+    def __init__(self):
+        # Active connections by room
+        self.rooms: Dict[str, Set[WebSocket]] = {
+            "dashboard": set(),
+            "scans": set(),
+            "findings": set(),
+            "notifications": set()
+        }
+        # User connections
+        self.user_connections: Dict[str, WebSocket] = {}
+    
+    async def connect(self, websocket: WebSocket, room: str = "dashboard", user_id: str = None):
+        """Connect client to room"""
+        await websocket.accept()
+        
+        if room in self.rooms:
+            self.rooms[room].add(websocket)
+        
+        if user_id:
+            self.user_connections[user_id] = websocket
+        
+        logger.info(f"Client connected to room: {room}")
+        
+        # Send welcome message
+        await websocket.send_json({
+            "type": "connection",
+            "status": "connected",
+            "room": room,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    def disconnect(self, websocket: WebSocket, room: str = None):
+        """Disconnect client"""
+        if room and room in self.rooms:
+            self.rooms[room].discard(websocket)
+        else:
+            # Remove from all rooms
+            for room_set in self.rooms.values():
+                room_set.discard(websocket)
+        
+        # Remove from user connections
+        for user_id, conn in list(self.user_connections.items()):
+            if conn == websocket:
+                del self.user_connections[user_id]
+        
+        logger.info("Client disconnected")
+    
+    async def broadcast_to_room(self, room: str, message: dict):
+        """Broadcast message to all clients in room"""
+        if room not in self.rooms:
+            return
+        
+        disconnected = set()
+        for connection in self.rooms[room]:
+            try:
+                await connection.send_json(message)
+            except Exception:
+                disconnected.add(connection)
+        
+        # Clean up disconnected clients
+        for conn in disconnected:
+            self.rooms[room].discard(conn)
+    
+    async def send_to_user(self, user_id: str, message: dict):
+        """Send message to specific user"""
+        if user_id in self.user_connections:
+            try:
+                await self.user_connections[user_id].send_json(message)
+            except Exception:
+                del self.user_connections[user_id]
+    
+    async def broadcast_scan_update(self, scan_id: str, status: str, progress: int = None):
+        """Broadcast scan progress update"""
+        await self.broadcast_to_room("scans", {
+            "type": "scan_update",
+            "scan_id": scan_id,
+            "status": status,
+            "progress": progress,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    async def broadcast_finding(self, finding: dict):
+        """Broadcast new finding discovery"""
+        await self.broadcast_to_room("findings", {
+            "type": "new_finding",
+            "finding": finding,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    async def broadcast_notification(self, title: str, message: str, severity: str = "info"):
+        """Broadcast system notification"""
+        await self.broadcast_to_room("notifications", {
+            "type": "notification",
+            "title": title,
+            "message": message,
+            "severity": severity,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    def get_room_stats(self) -> dict:
+        """Get connection statistics"""
+        return {
+            room: len(connections)
+            for room, connections in self.rooms.items()
+        }
+
+
+# Global manager instance
+manager_v2 = ConnectionManagerV2()
+
+
+async def websocket_dashboard_endpoint(websocket: WebSocket):
+    """Dashboard real-time updates"""
+    await manager_v2.connect(websocket, room="dashboard")
+    try:
+        while True:
+            # Receive ping from client
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            if message.get("action") == "ping":
+                await websocket.send_json({
+                    "type": "pong",
+                    "timestamp": datetime.utcnow().isoformat()
+                })
+            
+    except WebSocketDisconnect:
+        manager_v2.disconnect(websocket, room="dashboard")
+
+
+async def websocket_scans_endpoint(websocket: WebSocket):
+    """Scan progress real-time updates"""
+    await manager_v2.connect(websocket, room="scans")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            # Handle scan subscription requests
+            message = json.loads(data)
+            
+            if message.get("action") == "subscribe_scan":
+                scan_id = message.get("scan_id")
+                await websocket.send_json({
+                    "type": "subscribed",
+                    "scan_id": scan_id,
+                    "message": f"Subscribed to scan {scan_id} updates"
+                })
+                
+    except WebSocketDisconnect:
+        manager_v2.disconnect(websocket, room="scans")
+
+
+async def websocket_notifications_endpoint(websocket: WebSocket, user_id: str = None):
+    """User-specific notifications"""
+    await manager_v2.connect(websocket, room="notifications", user_id=user_id)
+    try:
+        while True:
+            data = await websocket.receive_text()
+            # Acknowledge receipt
+            await websocket.send_json({
+                "type": "ack",
+                "received": True
+            })
+    except WebSocketDisconnect:
+        manager_v2.disconnect(websocket, room="notifications")

zen_ai_pentest-2.2.0/modules/report_export.py

@@ -0,0 +1,207 @@
+"""
+Report Export Module
+Q2 2026 - PDF & CSV Export
+"""
+
+import csv
+import io
+import logging
+from datetime import datetime
+from typing import List, Dict, Any
+from dataclasses import dataclass
+
+try:
+    from weasyprint import HTML, CSS
+    WEASYPRINT_AVAILABLE = True
+except ImportError:
+    WEASYPRINT_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ReportData:
+    """Report data structure"""
+    title: str
+    scan_date: datetime
+    target: str
+    findings: List[Dict[str, Any]]
+    summary: Dict[str, int]
+    recommendations: List[str]
+
+
+class ReportExporter:
+    """Export reports to various formats"""
+    
+    def __init__(self):
+        self.templates = {
+            "executive": self._executive_template,
+            "technical": self._technical_template,
+            "compliance": self._compliance_template
+        }
+    
+    def export_csv(self, findings: List[Dict], filename: str = None) -> bytes:
+        """Export findings to CSV"""
+        if not filename:
+            filename = f"findings_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        
+        output = io.StringIO()
+        writer = csv.writer(output)
+        
+        # Header
+        writer.writerow([
+            "ID", "Severity", "Title", "Description", "Target",
+            "CVE", "CVSS", "Status", "Discovered"
+        ])
+        
+        # Data
+        for finding in findings:
+            writer.writerow([
+                finding.get("id", ""),
+                finding.get("severity", ""),
+                finding.get("title", ""),
+                finding.get("description", ""),
+                finding.get("target", ""),
+                finding.get("cve_id", ""),
+                finding.get("cvss_score", ""),
+                finding.get("status", "open"),
+                finding.get("discovered_at", "")
+            ])
+        
+        return output.getvalue().encode('utf-8')
+    
+    def export_pdf(self, report: ReportData, template: str = "executive") -> bytes:
+        """Export report to PDF"""
+        if not WEASYPRINT_AVAILABLE:
+            logger.error("WeasyPrint not available. Install: pip install weasyprint")
+            raise RuntimeError("PDF generation requires WeasyPrint")
+        
+        html_content = self.templates.get(template, self._executive_template)(report)
+        
+        pdf = HTML(string=html_content).write_pdf()
+        return pdf
+    
+    def _executive_template(self, report: ReportData) -> str:
+        """Executive summary template"""
+        findings_html = ""
+        for f in report.findings[:10]:  # Top 10
+            severity_color = {
+                "critical": "#dc2626",
+                "high": "#ea580c",
+                "medium": "#ca8a04",
+                "low": "#16a34a"
+            }.get(f.get("severity", "low"), "#6b7280")
+            
+            findings_html += f"""
+            <div style="margin: 10px 0; padding: 10px; border-left: 4px solid {severity_color}; background: #f9fafb;">
+                <strong>{f.get('title', 'Unknown')}</strong> 
+                <span style="color: {severity_color}; text-transform: uppercase; font-size: 0.8em;">
+                    {f.get('severity', 'unknown')}
+                </span>
+                <p style="margin: 5px 0; color: #4b5563;">{f.get('description', '')[:200]}...</p>
+            </div>
+            """
+        
+        return f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <title>{report.title}</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 40px; }}
+                h1 {{ color: #111827; border-bottom: 2px solid #059669; padding-bottom: 10px; }}
+                .summary {{ background: #f3f4f6; padding: 20px; border-radius: 8px; margin: 20px 0; }}
+                .metric {{ display: inline-block; margin: 10px 20px; }}
+                .metric-value {{ font-size: 2em; font-weight: bold; color: #059669; }}
+                .metric-label {{ color: #6b7280; font-size: 0.9em; }}
+                .findings {{ margin-top: 30px; }}
+            </style>
+        </head>
+        <body>
+            <h1>{report.title}</h1>
+            <p><strong>Target:</strong> {report.target}</p>
+            <p><strong>Scan Date:</strong> {report.scan_date.strftime('%Y-%m-%d %H:%M')}</p>
+            
+            <div class="summary">
+                <h2>Summary</h2>
+                <div class="metric">
+                    <div class="metric-value">{report.summary.get('critical', 0)}</div>
+                    <div class="metric-label">Critical</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-value">{report.summary.get('high', 0)}</div>
+                    <div class="metric-label">High</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-value">{report.summary.get('medium', 0)}</div>
+                    <div class="metric-label">Medium</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-value">{report.summary.get('low', 0)}</div>
+                    <div class="metric-label">Low</div>
+                </div>
+            </div>
+            
+            <div class="findings">
+                <h2>Top Findings</h2>
+                {findings_html}
+            </div>
+            
+            <div style="margin-top: 40px; padding-top: 20px; border-top: 1px solid #e5e7eb; color: #6b7280; font-size: 0.9em;">
+                <p>Generated by Zen AI Pentest v2.1.0</p>
+                <p>Confidential - For authorized eyes only</p>
+            </div>
+        </body>
+        </html>
+        """
+    
+    def _technical_template(self, report: ReportData) -> str:
+        """Technical detailed template"""
+        # Similar to executive but with more technical details
+        return self._executive_template(report)  # Simplified for now
+    
+    def _compliance_template(self, report: ReportData) -> str:
+        """Compliance-focused template"""
+        # For compliance reporting (PCI-DSS, GDPR, etc.)
+        return self._executive_template(report)  # Simplified for now
+    
+    def export_json(self, findings: List[Dict]) -> str:
+        """Export findings to JSON"""
+        import json
+        return json.dumps(findings, indent=2)
+    
+    def get_export_formats(self) -> List[str]:
+        """List available export formats"""
+        formats = ["csv", "json"]
+        if WEASYPRINT_AVAILABLE:
+            formats.append("pdf")
+        return formats
+
+
+# Convenience function
+def export_findings(findings: List[Dict], format: str = "csv") -> bytes:
+    """Quick export function"""
+    exporter = ReportExporter()
+    
+    if format == "csv":
+        return exporter.export_csv(findings)
+    elif format == "json":
+        return exporter.export_json(findings).encode('utf-8')
+    elif format == "pdf":
+        report = ReportData(
+            title="Security Assessment Report",
+            scan_date=datetime.now(),
+            target="Multiple Targets",
+            findings=findings,
+            summary={
+                "critical": len([f for f in findings if f.get("severity") == "critical"]),
+                "high": len([f for f in findings if f.get("severity") == "high"]),
+                "medium": len([f for f in findings if f.get("severity") == "medium"]),
+                "low": len([f for f in findings if f.get("severity") == "low"])
+            },
+            recommendations=[]
+        )
+        return exporter.export_pdf(report)
+    else:
+        raise ValueError(f"Unsupported format: {format}")

{zen_ai_pentest-2.1.0 → zen_ai_pentest-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zen-ai-pentest"
-version = "2.1.0"
+version = "2.2.0"
 description = "Advanced AI-Powered Penetration Testing Framework with Multi-Agent Orchestration"
 readme = "README.md"
 license = {text = "MIT"}

{zen_ai_pentest-2.1.0 → zen_ai_pentest-2.2.0}/zen_ai_pentest.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zen-ai-pentest
-Version: 2.1.0
+Version: 2.2.0
 Summary: Advanced AI-Powered Penetration Testing Framework with Multi-Agent Orchestration
 Home-page: https://github.com/SHAdd0WTAka/zen-ai-pentest
 Author: SHAdd0WTAka

{zen_ai_pentest-2.1.0 → zen_ai_pentest-2.2.0}/zen_ai_pentest.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ api/auth.py
 api/main.py
 api/schemas.py
 api/websocket.py
+api/websocket_v2.py
 autonomous/__init__.py
 autonomous/agent.py
 autonomous/agent_loop.py
@@ -105,6 +106,7 @@ modules/nuclei_integration.py
 modules/osint.py
 modules/protonvpn.py
 modules/recon.py
+modules/report_export.py
 modules/siem_integration.py
 modules/sql_injection_db.py
 modules/tool_orchestrator.py