#!/usr/bin/env python3
"""
Comprehensive Security Assessment Report Generator
Generates complete security assessment reports with recommendations
"""

import json
import base64
import hashlib
import datetime
import re
from typing import Dict, List, Optional, Any

# Import all security assessment modules
from security_headers_analyzer import SecurityHeadersAnalyzer
from ssrf_tester import SSRFTester
from file_upload_security import FileUploadSecurityAssessment
from logging_monitoring_evaluator import LoggingMonitoringEvaluator
from dos_vulnerability_tester import DOSVulnerabilityTester

class ComprehensiveSecurityAssessment:
    """Generate comprehensive security assessment reports"""
    
    def __init__(self):
        self.headers_analyzer = SecurityHeadersAnalyzer()
        self.ssrf_tester = SSRFTester()
        self.file_upload_assessor = FileUploadSecurityAssessment()
        self.logging_evaluator = LoggingMonitoringEvaluator()
        self.dos_tester = DOSVulnerabilityTester()
        
        self.assessment_categories = [
            'security_headers',
            'ssrf_vulnerabilities',
            'file_upload_security',
            'logging_monitoring',
            'dos_resilience'
        ]
        
        self.severity_weights = {
            'critical': 4,
            'high': 3,
            'medium': 2,
            'low': 1
        }

    def generate_comprehensive_assessment(self, target_info: Dict[str, Any]) -> Dict[str, Any]:
        """Generate complete security assessment report"""
        
        report = {
            'metadata': self._generate_report_metadata(target_info),
            'executive_summary': {},
            'detailed_findings': {},
            'risk_assessment': {},
            'recommendations': {},
            'compliance_status': {},
            'remediation_roadmap': {},
            'appendices': {}
        }
        
        # Run all security assessments
        assessment_results = self._run_all_assessments(target_info)
        report['detailed_findings'] = assessment_results
        
        # Generate executive summary
        report['executive_summary'] = self._generate_executive_summary(assessment_results)
        
        # Generate risk assessment
        report['risk_assessment'] = self._generate_risk_assessment(assessment_results)
        
        # Generate prioritized recommendations
        report['recommendations'] = self._generate_prioritized_recommendations(assessment_results)
        
        # Generate compliance status
        report['compliance_status'] = self._generate_compliance_status(assessment_results)
        
        # Generate remediation roadmap
        report['remediation_roadmap'] = self._generate_remediation_roadmap(assessment_results)
        
        # Generate appendices
        report['appendices'] = self._generate_appendices(assessment_results, target_info)
        
        return report
    
    def _run_all_assessments(self, target_info: Dict[str, Any]) -> Dict[str, Any]:
        """Run all security assessment modules"""
        
        results = {}
        
        # Security Headers Analysis
        headers_result = self.headers_analyzer.analyze_headers(
            target_info.get('security_headers', {})
        )
        results['security_headers'] = headers_result
        
        # SSRF Testing
        ssrf_result = self.ssrf_tester.analyze_input_validation(
            target_info.get('test_input', 'http://example.com')
        )
        results['ssrf_vulnerabilities'] = ssrf_result
        
        # File Upload Security
        file_upload_result = self.file_upload_assessor.analyze_file_upload(
            target_info.get('file_data', b'sample'), 
            target_info.get('filename', 'test.txt'),
            target_info.get('content_type', 'text/plain')
        )
        results['file_upload_security'] = file_upload_result
        
        # Logging and Monitoring Evaluation
        logging_result = self.logging_evaluator.evaluate_logging_configuration(
            target_info.get('logging_config', {})
        )
        monitoring_result = self.logging_evaluator.evaluate_monitoring_setup(
            target_info.get('monitoring_config', {})
        )
        results['logging_monitoring'] = {
            'logging': logging_result,
            'monitoring': monitoring_result
        }
        
        # DoS Vulnerability Testing
        dos_result = self.dos_tester.assess_dos_resilience(target_info)
        results['dos_resilience'] = dos_result
        
        return results
    
    def _generate_report_metadata(self, target_info: Dict[str, Any]) -> Dict[str, Any]:
        """Generate report metadata"""
        
        return {
            'report_title': 'Comprehensive Security Assessment Report',
            'target_name': target_info.get('target_name', 'Target Application'),
            'target_url': target_info.get('target_url', 'https://example.com'),
            'assessment_date': datetime.datetime.now().isoformat(),
            'assessment_version': '1.0',
            'assessor': 'Security Assessment Framework',
            'scope': target_info.get('scope', 'Full Application Security Assessment'),
            'exclusions': target_info.get('exclusions', []),
            'methodology': 'Automated Security Assessment Framework'
        }
    
    def _generate_executive_summary(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Generate executive summary"""
        
        # Calculate overall scores
        scores = {}
        for category, results in assessment_results.items():
            if category == 'logging_monitoring':
                scores['logging'] = results.get('logging', {}).get('compliance_score', 0)
                scores['monitoring'] = results.get('monitoring', {}).get('monitoring_score', 0)
            elif category == 'security_headers':
                scores[category] = results.get('score', 0)
            elif category == 'ssrf_vulnerabilities':
                scores[category] = results.get('validation_score', 0)
            elif category == 'file_upload_security':
                scores[category] = results.get('security_score', 0)
            elif category == 'dos_resilience':
                scores[category] = results.get('overall_score', 0)
        
        # Calculate overall score
        overall_score = sum(scores.values()) // len(scores) if scores else 0
        
        # Count vulnerabilities by severity
        vulnerability_counts = self._count_vulnerabilities(assessment_results)
        
        return {
            'overall_security_score': overall_score,
            'security_grade': self._calculate_security_grade(overall_score),
            'category_scores': scores,
            'total_vulnerabilities': sum(vulnerability_counts.values()),
            'vulnerability_breakdown': vulnerability_counts,
            'critical_findings': self._extract_critical_findings(assessment_results),
            'key_highlights': self._generate_key_highlights(assessment_results),
            'immediate_actions_required': self._get_immediate_actions(assessment_results)
        }
    
    def _generate_risk_assessment(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Generate risk assessment"""
        
        risk_matrix = self._calculate_risk_matrix(assessment_results)
        top_risks = self._identify_top_risks(assessment_results)
        
        return {
            'overall_risk_level': 'medium',  # Simplified
            'risk_matrix': risk_matrix,
            'top_risks': top_risks,
            'risk_by_category': {},  # Simplified
            'risk_trends': [],  # Simplified
            'business_impact_assessment': 'Medium impact on business operations'  # Simplified
        }
    
    def _generate_prioritized_recommendations(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Generate prioritized recommendations"""
        
        all_recommendations = []
        
        # Collect recommendations from all categories
        for category, results in assessment_results.items():
            recommendations = self._extract_recommendations_from_category(category, results)
            all_recommendations.extend(recommendations)
        
        # Prioritize recommendations
        prioritized = self._prioritize_recommendations(all_recommendations)
        
        return {
            'immediate_actions': prioritized[:10],
            'short_term_actions': prioritized[10:25] if len(prioritized) > 10 else [],
            'long_term_actions': prioritized[25:] if len(prioritized) > 25 else [],
            'recommendations_by_severity': {},  # Simplified
            'implementation_cost_estimate': 'Medium cost estimate',  # Simplified
            'expected_improvement': 'Expected 40% improvement in security posture'  # Simplified
        }
    
    def _generate_compliance_status(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Generate compliance status"""
        
        compliance_standards = ['OWASP', 'NIST', 'ISO27001', 'SOC2', 'GDPR']
        compliance_status = {}
        
        for standard in compliance_standards:
            compliance_status[standard] = {
                'compliance_level': 'partial',
                'score': 65,
                'gaps': ['Security headers not fully implemented']
            }
        
        return {
            'overall_compliance_score': 65,  # Simplified
            'standards_status': compliance_status,
            'compliance_gaps': ['Missing security controls', 'Insufficient logging'],
            'remediation_priority': 'High priority for OWASP and NIST compliance'
        }
    
    def _generate_remediation_roadmap(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Generate remediation roadmap"""
        
        return {
            'phase_1_critical': ['Implement security headers', 'Fix SSRF vulnerabilities'],
            'phase_2_high': ['Enhance file upload security', 'Improve logging'],
            'phase_3_medium': ['Add rate limiting', 'Implement monitoring'],
            'phase_4_low': ['Documentation updates', 'User training'],
            'timeline_estimates': '3-6 months for complete implementation',
            'resource_requirements': '2-3 security engineers, 6-12 months total effort',
            'success_metrics': 'Zero critical vulnerabilities, 80%+ security score'
        }
    
    def _generate_appendices(self, assessment_results: Dict[str, Any], target_info: Dict[str, Any]) -> Dict[str, Any]:
        """Generate report appendices"""
        
        return {
            'technical_details': 'Detailed technical findings and evidence',
            'test_methodology': 'OWASP testing methodology followed',
            'glossary': {'SSRF': 'Server-Side Request Forgery', 'DoS': 'Denial of Service'},
            'references': ['OWASP Top 10', 'NIST Cybersecurity Framework'],
            'raw_assessment_data': assessment_results
        }
    
    def _count_vulnerabilities(self, assessment_results: Dict[str, Any]) -> Dict[str, int]:
        """Count vulnerabilities by severity"""
        
        counts = {'critical': 0, 'high': 0, 'medium': 0, 'low': 0}
        
        for category, results in assessment_results.items():
            if category == 'logging_monitoring':
                # Handle logging and monitoring separately
                for subcategory, subresults in results.items():
                    issues = subresults.get('security_issues', []) or subresults.get('monitoring_issues', [])
                    for issue in issues:
                        severity = issue.get('severity', 'low').lower()
                        if severity in counts:
                            counts[severity] += 1
            else:
                issues = results.get('risks', []) or results.get('vulnerabilities_found', [])
                for issue in issues:
                    severity = issue.get('severity', 'low').lower()
                    if severity in counts:
                        counts[severity] += 1
        
        return counts
    
    def _calculate_security_grade(self, score: int) -> str:
        """Calculate security grade from score"""
        if score >= 90:
            return 'A'
        elif score >= 80:
            return 'B'
        elif score >= 70:
            return 'C'
        elif score >= 60:
            return 'D'
        else:
            return 'F'
    
    def _extract_critical_findings(self, assessment_results: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Extract critical findings from assessments"""
        
        critical_findings = []
        
        for category, results in assessment_results.items():
            if category == 'logging_monitoring':
                for subcategory, subresults in results.items():
                    issues = subresults.get('security_issues', []) or subresults.get('monitoring_issues', [])
                    for issue in issues:
                        if issue.get('severity', '').lower() == 'critical':
                            critical_findings.append({
                                'category': f"{category}_{subcategory}",
                                'finding': issue
                            })
            else:
                issues = results.get('risks', []) or results.get('vulnerabilities_found', [])
                for issue in issues:
                    if issue.get('severity', '').lower() == 'critical':
                        critical_findings.append({
                            'category': category,
                            'finding': issue
                        })
        
        return critical_findings
    
    def _generate_key_highlights(self, assessment_results: Dict[str, Any]) -> List[str]:
        """Generate key highlights from assessment"""
        
        highlights = []
        
        # Check for strong areas
        if assessment_results.get('security_headers', {}).get('score', 0) >= 80:
            highlights.append("Strong security headers implementation")
        
        if assessment_results.get('ssrf_vulnerabilities', {}).get('validation_score', 0) >= 80:
            highlights.append("Good SSRF protection measures")
        
        # Check for areas needing improvement
        if assessment_results.get('file_upload_security', {}).get('security_score', 0) < 50:
            highlights.append("File upload security requires immediate attention")
        
        if assessment_results.get('dos_resilience', {}).get('overall_score', 0) < 50:
            highlights.append("DoS resilience measures need significant improvement")
        
        return highlights
    
    def _get_immediate_actions(self, assessment_results: Dict[str, Any]) -> List[str]:
        """Get immediate actions required"""
        
        actions = []
        
        # Check for critical issues requiring immediate action
        critical_findings = self._extract_critical_findings(assessment_results)
        for finding in critical_findings:
            category = finding['category']
            issue = finding['finding']
            
            if 'file_upload' in category:
                actions.append("Implement immediate file upload security controls")
            elif 'ssrf' in category:
                actions.append("Deploy SSRF protection immediately")
            elif 'dos' in category:
                actions.append("Implement DoS protection measures")
        
        return list(set(actions))
    
    def _calculate_risk_matrix(self, assessment_results: Dict[str, Any]) -> Dict[str, Any]:
        """Calculate risk matrix"""
        
        # Simplified risk matrix calculation
        likelihood_scores = {'high': 3, 'medium': 2, 'low': 1}
        impact_scores = {'high': 3, 'medium': 2, 'low': 1}
        
        return {
            'likelihood_scores': likelihood_scores,
            'impact_scores': impact_scores,
            'risk_levels': {'critical': 9, 'high': 6, 'medium': 4, 'low': 2}
        }
    
    def _identify_top_risks(self, assessment_results: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Identify top risks"""
        
        risks = []
        
        # Collect high-risk findings
        for category, results in assessment_results.items():
            if category == 'logging_monitoring':
                for subcategory, subresults in results.items():
                    issues = subresults.get('security_issues', []) or subresults.get('monitoring_issues', [])
                    for issue in issues:
                        if issue.get('severity', '').lower() in ['critical', 'high']:
                            risks.append({
                                'category': f"{category}_{subcategory}",
                                'risk': issue,
                                'score': self._calculate_risk_score(issue)
                            })
            else:
                issues = results.get('risks', []) or results.get('vulnerabilities_found', [])
                for issue in issues:
                    if issue.get('severity', '').lower() in ['critical', 'high']:
                        risks.append({
                            'category': category,
                            'risk': issue,
                            'score': self._calculate_risk_score(issue)
                        })
        
        # Sort by risk score and return top 10
        risks.sort(key=lambda x: x['score'], reverse=True)
        return risks[:10]
    
    def _calculate_risk_score(self, risk: Dict[str, Any]) -> int:
        """Calculate risk score for a finding"""
        
        severity = risk.get('severity', '').lower()
        return self.severity_weights.get(severity, 1)
    
    def _extract_recommendations_from_category(self, category: str, results: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Extract recommendations from assessment category"""
        
        recommendations = []
        
        if category == 'logging_monitoring':
            for subcategory, subresults in results.items():
                subrecs = subresults.get('recommendations', [])
                for rec in subrecs:
                    recommendations.append({
                        'category': f"{category}_{subcategory}",
                        'recommendation': rec,
                        'priority': self._determine_priority_from_severity(subresults)
                    })
        else:
            recs = results.get('recommendations', [])
            for rec in recs:
                recommendations.append({
                    'category': category,
                    'recommendation': rec,
                    'priority': self._determine_priority_from_severity(results)
                })
        
        return recommendations
    
    def _determine_priority_from_severity(self, results: Dict[str, Any]) -> str:
        """Determine priority from assessment results"""
        
        # Check for critical or high severity issues
        issues = results.get('risks', []) or results.get('vulnerabilities_found', []) or results.get('security_issues', [])
        
        for issue in issues:
            severity = issue.get('severity', '').lower()
            if severity == 'critical':
                return 'immediate'
            elif severity == 'high':
                return 'high'
        
        return 'medium'
    
    def _prioritize_recommendations(self, recommendations: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Prioritize recommendations"""
        
        # Sort by priority and category importance
        priority_order = {'immediate': 4, 'high': 3, 'medium': 2, 'low': 1}
        
        recommendations.sort(key=lambda x: (
            priority_order.get(x['priority'], 1),
            len(x['recommendation'])  # Shorter, more actionable items first
        ), reverse=True)
        
        return recommendations
    
    def generate_html_report(self, assessment_results: Dict[str, Any]) -> str:
        """Generate HTML version of the report"""
        
        html_template = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Comprehensive Security Assessment Report</title>
    <style>
        body {{ font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; }}
        .header {{ background: #2c3e50; color: white; padding: 20px; border-radius: 5px; }}
        .section {{ margin: 20px 0; padding: 15px; border: 1px solid #ddd; border-radius: 5px; }}
        .critical {{ border-left: 5px solid #e74c3c; }}
        .high {{ border-left: 5px solid #f39c12; }}
        .medium {{ border-left: 5px solid #f1c40f; }}
        .low {{ border-left: 5px solid #27ae60; }}
        .score {{ font-size: 24px; font-weight: bold; color: #2c3e50; }}
        .grade {{ font-size: 36px; font-weight: bold; }}
        .grade.A {{ color: #27ae60; }}
        .grade.B {{ color: #f39c12; }}
        .grade.C {{ color: #e67e22; }}
        .grade.D {{ color: #e74c3c; }}
        .grade.F {{ color: #c0392b; }}
        table {{ width: 100%; border-collapse: collapse; margin: 10px 0; }}
        th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
        th {{ background-color: #f2f2f2; }}
        .chart-container {{ margin: 20px 0; }}
    </style>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
    <div class="header">
        <h1>{report_title}</h1>
        <p>Target: {target_name}</p>
        <p>Date: {assessment_date}</p>
    </div>
    
    <div class="section">
        <h2>Executive Summary</h2>
        <div class="grade {security_grade_class}">Security Grade: {security_grade}</div>
        <div class="score">Overall Score: {overall_score}/100</div>
        
        <div class="chart-container">
            <canvas id="vulnerabilityChart"></canvas>
        </div>
        
        <h3>Key Findings</h3>
        <ul>
            {key_highlights}
        </ul>
    </div>
    
    <div class="section">
        <h2>Detailed Assessment Results</h2>
        {detailed_results}
    </div>
    
    <div class="section">
        <h2>Recommendations</h2>
        {recommendations}
    </div>
    
    <script>
        // Vulnerability breakdown chart
        const ctx = document.getElementById('vulnerabilityChart').getContext('2d');
        new Chart(ctx, {{
            type: 'bar',
            data: {{
                labels: ['Critical', 'High', 'Medium', 'Low'],
                datasets: [{{
                    label: 'Vulnerabilities by Severity',
                    data: [{vulnerability_data}],
                    backgroundColor: ['#e74c3c', '#f39c12', '#f1c40f', '#27ae60']
                }}]
            }},
            options: {{
                responsive: true,
                plugins: {{
                    title: {{
                        display: true,
                        text: 'Vulnerability Breakdown'
                    }}
                }}
            }}
        }});
    </script>
</body>
</html>
        """
        
        # Extract data for HTML template
        metadata = assessment_results.get('metadata', {})
        exec_summary = assessment_results.get('executive_summary', {})
        recommendations = assessment_results.get('recommendations', {})
        
        vulnerability_counts = exec_summary.get('vulnerability_breakdown', {})
        vulnerability_data = f"{vulnerability_counts.get('critical', 0)}, {vulnerability_counts.get('high', 0)}, {vulnerability_counts.get('medium', 0)}, {vulnerability_counts.get('low', 0)}"
        
        key_highlights = '\n            '.join([f"<li>{highlight}</li>" for highlight in exec_summary.get('key_highlights', [])])
        
        return html_template.format(
            report_title=metadata.get('report_title', 'Security Assessment Report'),
            target_name=metadata.get('target_name', 'Target'),
            assessment_date=metadata.get('assessment_date', 'N/A'),
            security_grade=exec_summary.get('security_grade', 'F'),
            security_grade_class=exec_summary.get('security_grade', 'F').lower(),
            overall_score=exec_summary.get('overall_security_score', 0),
            vulnerability_data=vulnerability_data,
            key_highlights=key_highlights,
            detailed_results="Detailed assessment results would be rendered here...",
            recommendations="Prioritized recommendations would be rendered here..."
        )

def main():
    """Test the comprehensive security assessment"""
    assessor = ComprehensiveSecurityAssessment()
    
    # Sample target information
    target_info = {
        'target_name': 'Example Web Application',
        'target_url': 'https://example.com',
        'scope': 'Full Application Security Assessment',
        'security_headers': {
            'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
            'Content-Security-Policy': "default-src 'self'",
            'X-Frame-Options': 'DENY'
        },
        'test_input': 'http://example.com/test',
        'file_data': b'<?php system($_GET["cmd"]); ?>',
        'filename': 'test.php',
        'content_type': 'application/x-php',
        'logging_config': {
            'logged_events': ['authentication_success', 'file_upload'],
            'log_fields': ['timestamp', 'event_type'],
            'log_rotation_enabled': True,
            'log_encryption_enabled': False
        },
        'monitoring_config': {
            'metrics': ['request_rate', 'error_rate'],
            'alert_rules': ['high_error_rate'],
            'real_time_monitoring': True
        }
    }
    
    # Generate comprehensive assessment
    assessment = assessor.generate_comprehensive_assessment(target_info)
    
    # Generate HTML report
    html_report = assessor.generate_html_report(assessment)
    
    results = {
        'assessment_completed': True,
        'assessment_data': assessment,
        'html_report_generated': True,
        'summary': {
            'overall_score': assessment['executive_summary']['overall_security_score'],
            'security_grade': assessment['executive_summary']['security_grade'],
            'total_vulnerabilities': assessment['executive_summary']['total_vulnerabilities'],
            'critical_findings': len(assessment['executive_summary']['critical_findings'])
        }
    }
    
    print("Comprehensive Security Assessment Results:")
    print("=" * 60)
    print(f"Overall Score: {results['summary']['overall_score']}")
    print(f"Security Grade: {results['summary']['security_grade']}")
    print(f"Total Vulnerabilities: {results['summary']['total_vulnerabilities']}")
    print(f"Critical Findings: {results['summary']['critical_findings']}")
    print(f"HTML Report Generated: {results['html_report_generated']}")
    
    # Save HTML report
    with open('/data/uploads/results/wish-c9364f592d6f257543e49772492ce4b48170fdc84198035b95061b1b942c37d5/security_assessment_report.html', 'w') as f:
        f.write(html_report)
    
    return {
        'test_completed': True,
        'results': results
    }

if __name__ == "__main__":
    main()