runbooks 0.7.9__py3-none-any.whl → 0.9.0__py3-none-any.whl

runbooks/security/security_export.py

@@ -7,7 +7,7 @@ with multiple format support (JSON, CSV, PDF) and multi-language reporting.
 
 Features:
 - JSON export for dashboard integration
-- CSV export for spreadsheet analysis  
+- CSV export for spreadsheet analysis
 - PDF export for executive reports
 - Multi-language export support (EN, JP, KR, VN)
 - Rich CLI progress tracking
@@ -43,68 +43,60 @@ logger = configure_logger(__name__)
 class SecurityExporter:
     """
     Enterprise security assessment export functionality with Rich CLI.
-    
+
     Supports JSON, CSV, and PDF exports with multi-language capabilities
     and professional formatting for enterprise compliance requirements.
     """
-    
+
     def __init__(self, output_dir: Optional[str] = None):
         self.output_dir = Path(output_dir) if output_dir else Path.cwd() / "security-exports"
         self.supported_formats = ["json", "csv", "pdf"]
         self.supported_languages = ["EN", "JP", "KR", "VN"]
-        
+
         # Ensure output directory exists
         self.output_dir.mkdir(parents=True, exist_ok=True)
-        
+
     def export_security_results(
-        self, 
-        account_id: str, 
-        results: Dict[str, List], 
-        language: str = "EN",
-        formats: List[str] = None
+        self, account_id: str, results: Dict[str, List], language: str = "EN", formats: List[str] = None
     ) -> Dict[str, str]:
         """
         Export security assessment results in multiple formats.
-        
+
         Args:
             account_id: AWS account ID
             results: Security assessment results
             language: Report language (EN, JP, KR, VN)
             formats: Export formats (json, csv, pdf)
-            
+
         Returns:
             Dictionary mapping format to file path
         """
         if formats is None:
             formats = ["json", "csv"]
-            
+
         export_results = {}
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
+
         # Display export startup
         export_info = f"""[bold cyan]Security Export Configuration[/bold cyan]
 
 [green]Account ID:[/green] {account_id}
 [green]Language:[/green] {language}
-[green]Formats:[/green] {', '.join(formats)}
+[green]Formats:[/green] {", ".join(formats)}
 [green]Output Directory:[/green] {self.output_dir}
 
 [dim]Exporting assessment results...[/dim]"""
-        
-        console.print(create_panel(
-            export_info,
-            title="📤 Security Data Export",
-            border_style="cyan"
-        ))
-        
+
+        console.print(create_panel(export_info, title="📤 Security Data Export", border_style="cyan"))
+
         with create_progress_bar(description="Exporting Data") as progress:
             export_task = progress.add_task("Processing exports...", total=len(formats))
-            
+
             for format_type in formats:
                 if format_type not in self.supported_formats:
                     print_warning(f"Unsupported format: {format_type}")
                     continue
-                    
+
                 try:
                     if format_type == "json":
                         file_path = self._export_json(account_id, results, language, timestamp)
@@ -112,25 +104,25 @@ class SecurityExporter:
                         file_path = self._export_csv(account_id, results, language, timestamp)
                     elif format_type == "pdf":
                         file_path = self._export_pdf(account_id, results, language, timestamp)
-                    
+
                     export_results[format_type] = str(file_path)
                     print_success(f"Exported {format_type.upper()}: {file_path}")
-                    
+
                 except Exception as e:
                     print_error(f"Failed to export {format_type}: {e}")
                     logger.error(f"Export failed for {format_type}: {e}", exc_info=True)
-                    
+
                 progress.update(export_task, advance=1)
-        
+
         # Display export summary
         self._display_export_summary(export_results, account_id)
         return export_results
-    
+
     def _export_json(self, account_id: str, results: Dict[str, List], language: str, timestamp: str) -> Path:
         """Export results to JSON format for dashboard integration."""
         filename = f"security-assessment-{account_id}-{timestamp}.json"
         file_path = self.output_dir / filename
-        
+
         # Transform results for JSON export
         json_data = {
             "metadata": {
@@ -138,56 +130,56 @@ class SecurityExporter:
                 "assessment_date": datetime.now().isoformat(),
                 "language": language,
                 "export_format": "json",
-                "version": "0.7.8"
+                "version": "0.7.8",
             },
             "summary": self._calculate_summary_stats(results),
             "findings": self._transform_findings_for_json(results),
             "compliance_frameworks": {
                 "aws_well_architected": self._map_to_wa_framework(results),
                 "soc2": self._map_to_soc2_framework(results),
-                "enterprise_baseline": self._map_to_enterprise_framework(results)
-            }
+                "enterprise_baseline": self._map_to_enterprise_framework(results),
+            },
         }
-        
+
         with file_path.open("w", encoding="utf-8") as f:
             json.dump(json_data, f, indent=2, ensure_ascii=False)
-            
+
         return file_path
-    
+
     def _export_csv(self, account_id: str, results: Dict[str, List], language: str, timestamp: str) -> Path:
         """Export results to CSV format for spreadsheet analysis."""
         filename = f"security-findings-{account_id}-{timestamp}.csv"
         file_path = self.output_dir / filename
-        
+
         with file_path.open("w", newline="", encoding="utf-8") as f:
             writer = csv.writer(f)
-            
+
             # CSV Headers
             headers = [
                 "Finding_ID",
-                "Status_Level", 
+                "Status_Level",
                 "Title",
                 "Message",
                 "Severity",
                 "Compliance_Framework",
                 "Remediation_Available",
-                "Assessment_Date"
+                "Assessment_Date",
             ]
             writer.writerow(headers)
-            
+
             # Write findings data
             finding_id = 1
             assessment_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            
+
             for level, findings in results.items():
                 for finding in findings:
-                    if hasattr(finding, 'to_dict'):
+                    if hasattr(finding, "to_dict"):
                         finding_dict = finding.to_dict()
                     elif isinstance(finding, dict):
                         finding_dict = finding
                     else:
                         continue
-                        
+
                     row = [
                         f"SEC-{finding_id:04d}",
                         level,
@@ -196,65 +188,65 @@ class SecurityExporter:
                         self._map_level_to_severity(level),
                         "AWS Security Baseline",
                         "Manual" if level in ["Danger", "Warning"] else "N/A",
-                        assessment_date
+                        assessment_date,
                     ]
                     writer.writerow(row)
                     finding_id += 1
-                    
+
         return file_path
-    
+
     def _export_pdf(self, account_id: str, results: Dict[str, List], language: str, timestamp: str) -> Path:
         """Export results to PDF format for executive reports."""
         filename = f"security-executive-report-{account_id}-{timestamp}.pdf"
         file_path = self.output_dir / filename
-        
+
         # For now, create a placeholder PDF export
         # In production, this would use a proper PDF library like reportlab
         html_content = self._generate_executive_html(account_id, results, language)
-        
+
         # Write HTML version as PDF placeholder
-        html_path = file_path.with_suffix('.html')
+        html_path = file_path.with_suffix(".html")
         with html_path.open("w", encoding="utf-8") as f:
             f.write(html_content)
-        
+
         print_info(f"PDF export created as HTML: {html_path}")
         return html_path
-    
+
     def _calculate_summary_stats(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Calculate summary statistics for the assessment."""
         total_checks = sum(len(findings) for findings in results.values())
         critical_issues = len(results.get("Danger", []))
         warnings = len(results.get("Warning", []))
         successful = len(results.get("Success", []))
-        
+
         if total_checks > 0:
             security_score = (successful / total_checks) * 100
         else:
             security_score = 0
-            
+
         return {
             "total_checks": total_checks,
             "critical_issues": critical_issues,
             "warnings": warnings,
             "successful_checks": successful,
             "security_score": round(security_score, 1),
-            "compliance_status": "COMPLIANT" if security_score >= 80 else "NON_COMPLIANT"
+            "compliance_status": "COMPLIANT" if security_score >= 80 else "NON_COMPLIANT",
         }
-    
+
     def _transform_findings_for_json(self, results: Dict[str, List]) -> List[Dict[str, Any]]:
         """Transform findings into structured JSON format."""
         findings = []
         finding_id = 1
-        
+
         for level, level_findings in results.items():
             for finding in level_findings:
-                if hasattr(finding, 'to_dict'):
+                if hasattr(finding, "to_dict"):
                     finding_dict = finding.to_dict()
                 elif isinstance(finding, dict):
                     finding_dict = finding
                 else:
                     continue
-                    
+
                 structured_finding = {
                     "finding_id": f"SEC-{finding_id:04d}",
                     "status": level,
@@ -264,25 +256,19 @@ class SecurityExporter:
                     "result_columns": finding_dict.get("result_cols", []),
                     "result_rows": finding_dict.get("result_rows", []),
                     "remediation_required": level in ["Danger", "Warning"],
-                    "compliance_impact": self._assess_compliance_impact(level)
+                    "compliance_impact": self._assess_compliance_impact(level),
                 }
-                
+
                 findings.append(structured_finding)
                 finding_id += 1
-        
+
         return findings
-    
+
     def _map_level_to_severity(self, level: str) -> str:
         """Map security level to severity classification."""
-        mapping = {
-            "Danger": "CRITICAL",
-            "Warning": "HIGH", 
-            "Success": "PASS",
-            "Info": "INFO",
-            "Error": "ERROR"
-        }
+        mapping = {"Danger": "CRITICAL", "Warning": "HIGH", "Success": "PASS", "Info": "INFO", "Error": "ERROR"}
         return mapping.get(level, "UNKNOWN")
-    
+
     def _assess_compliance_impact(self, level: str) -> str:
         """Assess compliance impact of finding."""
         if level == "Danger":
@@ -291,7 +277,7 @@ class SecurityExporter:
             return "MEDIUM"
         else:
             return "LOW"
-    
+
     def _map_to_wa_framework(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Map findings to AWS Well-Architected framework."""
         return {
@@ -301,10 +287,10 @@ class SecurityExporter:
                 "identity_access_management": self._assess_iam_findings(results),
                 "detective_controls": self._assess_detective_findings(results),
                 "infrastructure_protection": self._assess_infrastructure_findings(results),
-                "data_protection": self._assess_data_findings(results)
-            }
+                "data_protection": self._assess_data_findings(results),
+            },
         }
-    
+
     def _map_to_soc2_framework(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Map findings to SOC2 compliance framework."""
         return {
@@ -314,10 +300,10 @@ class SecurityExporter:
                 "security": self._assess_soc2_security(results),
                 "availability": self._assess_soc2_availability(results),
                 "processing_integrity": self._assess_soc2_processing(results),
-                "confidentiality": self._assess_soc2_confidentiality(results)
-            }
+                "confidentiality": self._assess_soc2_confidentiality(results),
+            },
         }
-    
+
     def _map_to_enterprise_framework(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Map findings to enterprise baseline framework."""
         return {
@@ -327,72 +313,72 @@ class SecurityExporter:
                 "access_controls": self._assess_access_controls(results),
                 "monitoring_logging": self._assess_monitoring_controls(results),
                 "encryption_protection": self._assess_encryption_controls(results),
-                "incident_response": self._assess_incident_controls(results)
-            }
+                "incident_response": self._assess_incident_controls(results),
+            },
         }
-    
+
     def _calculate_framework_score(self, results: Dict[str, List], framework: str) -> float:
         """Calculate compliance score for specific framework."""
         # Simplified scoring - in production would map specific checks to framework requirements
         total_checks = sum(len(findings) for findings in results.values())
         successful = len(results.get("Success", []))
-        
+
         if total_checks > 0:
             return round((successful / total_checks) * 100, 1)
         return 0.0
-    
+
     def _assess_iam_findings(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess IAM-related findings."""
         return {"status": "ASSESSED", "findings_count": len(results.get("Success", [])), "risk_level": "LOW"}
-    
+
     def _assess_detective_findings(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess detective control findings."""
         return {"status": "ASSESSED", "findings_count": len(results.get("Warning", [])), "risk_level": "MEDIUM"}
-    
+
     def _assess_infrastructure_findings(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess infrastructure protection findings."""
         return {"status": "ASSESSED", "findings_count": len(results.get("Danger", [])), "risk_level": "HIGH"}
-    
+
     def _assess_data_findings(self, results: Dict[str, List]) -> Dict[str, Any]:
-        """Assess data protection findings.""" 
+        """Assess data protection findings."""
         return {"status": "ASSESSED", "findings_count": len(results.get("Info", [])), "risk_level": "LOW"}
-    
+
     def _assess_soc2_security(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess SOC2 security criteria."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_soc2_availability(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess SOC2 availability criteria."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_soc2_processing(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess SOC2 processing integrity."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_soc2_confidentiality(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess SOC2 confidentiality criteria."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_access_controls(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess access control compliance."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_monitoring_controls(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess monitoring and logging controls."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_encryption_controls(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess encryption and protection controls."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _assess_incident_controls(self, results: Dict[str, List]) -> Dict[str, Any]:
         """Assess incident response controls."""
         return {"status": "COMPLIANT", "findings_count": 0, "risk_level": "LOW"}
-    
+
     def _generate_executive_html(self, account_id: str, results: Dict[str, List], language: str) -> str:
         """Generate executive HTML report."""
         summary = self._calculate_summary_stats(results)
-        
+
         html_content = f"""
 <!DOCTYPE html>
 <html lang="{language.lower()}">
@@ -413,30 +399,30 @@ class SecurityExporter:
     <div class="header">
         <h1>🛡️ Security Assessment Executive Report</h1>
         <p><strong>Account ID:</strong> {account_id}</p>
-        <p><strong>Assessment Date:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
+        <p><strong>Assessment Date:</strong> {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}</p>
         <p><strong>Language:</strong> {language}</p>
     </div>
     
     <div class="summary">
         <h2>Executive Summary</h2>
-        <p><strong>Security Score:</strong> {summary['security_score']}%</p>
-        <p><strong>Total Checks:</strong> {summary['total_checks']}</p>
-        <p class="critical"><strong>Critical Issues:</strong> {summary['critical_issues']}</p>
-        <p class="warning"><strong>Warnings:</strong> {summary['warnings']}</p>
-        <p class="success"><strong>Successful Checks:</strong> {summary['successful_checks']}</p>
-        <p><strong>Compliance Status:</strong> {summary['compliance_status']}</p>
+        <p><strong>Security Score:</strong> {summary["security_score"]}%</p>
+        <p><strong>Total Checks:</strong> {summary["total_checks"]}</p>
+        <p class="critical"><strong>Critical Issues:</strong> {summary["critical_issues"]}</p>
+        <p class="warning"><strong>Warnings:</strong> {summary["warnings"]}</p>
+        <p class="success"><strong>Successful Checks:</strong> {summary["successful_checks"]}</p>
+        <p><strong>Compliance Status:</strong> {summary["compliance_status"]}</p>
     </div>
 </body>
 </html>
 """
         return html_content
-    
+
     def _display_export_summary(self, export_results: Dict[str, str], account_id: str):
         """Display export summary with Rich formatting."""
         if not export_results:
             print_warning("No files were exported successfully")
             return
-            
+
         # Create export summary table
         summary_table = create_table(
             title="📁 Export Summary",
@@ -444,19 +430,16 @@ class SecurityExporter:
                 {"name": "Format", "style": "bold cyan", "justify": "left"},
                 {"name": "File Path", "style": "dim", "justify": "left"},
                 {"name": "Status", "style": "bold", "justify": "center"},
-            ]
+            ],
         )
-        
+
         for format_type, file_path in export_results.items():
             summary_table.add_row(
-                format_type.upper(),
-                str(file_path),
-                f"{STATUS_INDICATORS['success']} Exported",
-                style="success"
+                format_type.upper(), str(file_path), f"{STATUS_INDICATORS['success']} Exported", style="success"
             )
-        
+
         console.print(summary_table)
-        
+
         # Display final export summary
         export_summary = f"""[bold green]Security Data Export Complete[/bold green]
 
@@ -466,12 +449,8 @@ class SecurityExporter:
 
 [dim]All exports completed successfully. Files are ready for analysis.[/dim]"""
 
-        console.print(create_panel(
-            export_summary,
-            title="✅ Export Complete",
-            border_style="green"
-        ))
+        console.print(create_panel(export_summary, title="✅ Export Complete", border_style="green"))
 
 
 # Export functionality for external use
-__all__ = ["SecurityExporter"]
+__all__ = ["SecurityExporter"]