ersec 21.0.0__py3-none-any.whl

ersec/__init__.py

@@ -0,0 +1,2 @@
+"""ERSEC - Enterprise Reconnaissance & Security Engine"""
+__version__ = "21.0.0"

ersec/ai.py

@@ -0,0 +1,206 @@
+"""Professional AI Analysis Engine for ERSEC"""
+
+from typing import Dict, Any, List
+from .mitre import MITREKnowledgeBase
+
+
+class ProfessionalAI:
+    """AI-powered analysis engine using MITRE knowledge base"""
+    
+    def __init__(self):
+        self.mitre = MITREKnowledgeBase()
+    
+    def analyze(self, target: str, results: Dict[str, Any]) -> str:
+        """Generate comprehensive analysis"""
+        findings = results.get("all_findings", [])
+        
+        sections = []
+        sections.append(self._generate_summary(target, findings))
+        sections.append(self._generate_vulnerability_details(findings))
+        sections.append(self._generate_mitre_mapping(findings))
+        sections.append(self._generate_exploitation_guide(findings))
+        sections.append(self._generate_defense_strategies(findings))
+        sections.append(self._generate_recommendations(findings))
+        
+        return "\n\n".join(sections)
+    
+    def _generate_summary(self, target: str, findings: List[Dict]) -> str:
+        """Generate executive 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"])
+        total = len(findings)
+        
+        risk_score = min(100, critical * 30 + high * 15 + medium * 5)
+        
+        if risk_score >= 80:
+            risk_level = "CRITICAL"
+        elif risk_score >= 60:
+            risk_level = "HIGH"
+        elif risk_score >= 40:
+            risk_level = "MEDIUM"
+        else:
+            risk_level = "LOW"
+        
+        return f"""
+╔══════════════════════════════════════════════════════════════╗
+║                    EXECUTIVE SECURITY REPORT                   ║
+╚══════════════════════════════════════════════════════════════╝
+
+📋 Target: {target}
+📊 Risk Score: {risk_score}/100 - {risk_level}
+
+Vulnerability Distribution:
+  🔴 Critical: {critical}
+  🟠 High: {high}
+  🟡 Medium: {medium}
+  📊 Total: {total}
+
+{"⚠️  CRITICAL VULNERABILITIES - IMMEDIATE ACTION REQUIRED!" if critical > 0 else "⚡ Vulnerabilities found - remediation recommended" if total > 0 else "✅ No critical vulnerabilities detected"}
+"""
+    
+    def _generate_vulnerability_details(self, findings: List[Dict]) -> str:
+        """Generate detailed vulnerability analysis"""
+        if not findings:
+            return "No vulnerabilities detected."
+        
+        details = "╔══════════════════════════════════════════════════════════════╗\n"
+        details += "║                    VULNERABILITY DETAILS                      ║\n"
+        details += "╚══════════════════════════════════════════════════════════════╝\n"
+        
+        for i, f in enumerate(findings, 1):
+            severity = f.get("severity", "Unknown")
+            emoji = "🔴" if severity == "Critical" else "🟠" if severity == "High" else "🟡"
+            
+            details += f"""
+
+{emoji} Finding #{i}: {f.get('name', 'Unknown')}
+{'=' * 60}
+  Type: {f.get('type', 'Unknown')}
+  Severity: {severity}
+  CVSS Score: {f.get('cvss', 'N/A')}
+  
+  Description:
+  {f.get('description', 'No description available')}
+  
+  Impact:
+  {f.get('impact', 'Unknown impact')}
+"""
+        
+        return details
+    
+    def _generate_mitre_mapping(self, findings: List[Dict]) -> str:
+        """Generate MITRE ATT&CK mapping"""
+        if not findings:
+            return ""
+        
+        mapping = "╔══════════════════════════════════════════════════════════════╗\n"
+        mapping += "║                    MITRE ATT&CK MAPPING                       ║\n"
+        mapping += "╚══════════════════════════════════════════════════════════════╝\n"
+        
+        seen = set()
+        for f in findings:
+            for tech_id in f.get("techniques", []):
+                if tech_id in seen:
+                    continue
+                seen.add(tech_id)
+                
+                tech = self.mitre.get_technique(tech_id)
+                if tech:
+                    mapping += f"""
+
+[{tech_id}] {tech.get('name', 'Unknown')}
+  Tactic: {tech.get('tactic', 'Unknown')}
+  Description: {tech.get('description', 'N/A')}
+"""
+        
+        return mapping
+    
+    def _generate_exploitation_guide(self, findings: List[Dict]) -> str:
+        """Generate exploitation guide"""
+        if not findings:
+            return ""
+        
+        guide = "╔══════════════════════════════════════════════════════════════╗\n"
+        guide += "║                    EXPLOITATION GUIDE                         ║\n"
+        guide += "╚══════════════════════════════════════════════════════════════╝\n"
+        
+        for f in findings:
+            tools = f.get("tools", [])
+            commands = f.get("commands", [])
+            
+            if tools or commands:
+                guide += f"""
+
+{'-' * 60}
+Exploiting: {f.get('name', 'Unknown')}
+{'-' * 60}
+
+🛠️ Tools:
+  {', '.join(tools) if tools else 'Manual exploitation'}
+
+💻 Commands:
+"""
+                for cmd in commands:
+                    guide += f"  $ {cmd}\n"
+        
+        return guide
+    
+    def _generate_defense_strategies(self, findings: List[Dict]) -> str:
+        """Generate defense strategies"""
+        if not findings:
+            return ""
+        
+        defense = "╔══════════════════════════════════════════════════════════════╗\n"
+        defense += "║                    DEFENSE STRATEGIES                         ║\n"
+        defense += "╚══════════════════════════════════════════════════════════════╝\n"
+        
+        for f in findings:
+            strategies = f.get("defense", [])
+            if strategies:
+                defense += f"""
+
+{'-' * 60}
+Defending Against: {f.get('name', 'Unknown')}
+{'-' * 60}
+
+"""
+                for s in strategies:
+                    defense += f"  ✅ {s}\n"
+        
+        defense += """
+
+🔒 General Hardening:
+  ✅ Regular patching
+  ✅ Network segmentation
+  ✅ Least privilege
+  ✅ MFA everywhere
+  ✅ WAF deployment
+"""
+        
+        return defense
+    
+    def _generate_recommendations(self, findings: List[Dict]) -> str:
+        """Generate prioritized recommendations"""
+        recommendations = "╔══════════════════════════════════════════════════════════════╗\n"
+        recommendations += "║                    PRIORITIZED RECOMMENDATIONS                ║\n"
+        recommendations += "╚══════════════════════════════════════════════════════════════╝\n"
+        
+        if not findings:
+            recommendations += "\n✅ No critical vulnerabilities\n✅ Maintain security posture\n"
+            return recommendations
+        
+        critical = [f for f in findings if f.get("severity") == "Critical"]
+        high = [f for f in findings if f.get("severity") == "High"]
+        
+        if critical:
+            recommendations += "\n🚨 IMMEDIATE (24-48 Hours):\n"
+            for f in critical:
+                recommendations += f"  ⚡ {f.get('name')}: {f.get('description', '')[:80]}\n"
+        
+        if high:
+            recommendations += "\n⚠️ URGENT (1 Week):\n"
+            for f in high:
+                recommendations += f"  ⚠️ {f.get('name')}: {f.get('description', '')[:80]}\n"
+        
+        return recommendations