ersec 21.0.0__tar.gz

ersec-21.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ERSEC Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ersec-21.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include ersec *.py

ersec-21.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: ersec
+Version: 21.0.0
+Summary: Enterprise Reconnaissance & Security Engine - Professional Vulnerability Scanner
+Author: ERSEC Team
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: urllib3>=2.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Professional vulnerability scanner with MITRE ATT&CK integration and AI-powered analysis

ersec-21.0.0/README.md

@@ -0,0 +1,10 @@
+# ERSEC - Enterprise Reconnaissance & Security Engine
+
+Professional vulnerability scanner with MITRE ATT&CK integration for authorized security assessment.
+
+## Features
+- Deep Vulnerability Detection (SQL Injection, XSS, Command Injection, LFI/RFI)
+- Complete MITRE ATT&CK Framework
+- Professional AI Analysis
+- Advanced Reconnaissance
+- Comprehensive Reporting

ersec-21.0.0/ersec/__init__.py

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

ersec-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