INITIATE

#!/usr/bin/env python3
"""
SYNTAX Enterprise Security Platform v18.0
Pure Python Implementation - Terminal-Based Interactive Dashboard
Real-time threat intelligence, UEBA, and cloud security posture management

Copyright 2025 - Apache License 2.0
"""

import json
import hashlib
import random
import time
import os
import sys
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional

try:
    from cryptography.hazmat.primitives.asymmetric import rsa
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.backends import default_backend
    CRYPTO_AVAILABLE = True
except ImportError:
    CRYPTO_AVAILABLE = False
    print("Warning: cryptography library not installed. Install with: pip install cryptography")

# ============================================================================
# TERMINAL UI UTILITIES
# ============================================================================

class Colors:
    """ANSI color codes for terminal output"""
    RESET = '\033[0m'
    BOLD = '\033[1m'
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    MAGENTA = '\033[95m'
    CYAN = '\033[96m'
    WHITE = '\033[97m'

class TerminalUI:
    """Terminal-based user interface utilities"""
    
    @staticmethod
    def clear_screen():
        """Clear terminal screen"""
        os.system('cls' if os.name == 'nt' else 'clear')
    
    @staticmethod
    def print_header(text: str):
        """Print styled header"""
        print(f"\n{Colors.BOLD}{Colors.BLUE}{'='*80}{Colors.RESET}")
        print(f"{Colors.BOLD}{Colors.CYAN}{text.center(80)}{Colors.RESET}")
        print(f"{Colors.BOLD}{Colors.BLUE}{'='*80}{Colors.RESET}\n")
    
    @staticmethod
    def print_section(title: str):
        """Print section title"""
        print(f"\n{Colors.BOLD}{Colors.MAGENTA}{'▶'} {title}{Colors.RESET}")
        print(f"{Colors.BLUE}{'-'*80}{Colors.RESET}")
    
    @staticmethod
    def print_alert(severity: str, message: str):
        """Print color-coded alert"""
        color_map = {
            'critical': Colors.RED,
            'high': Colors.YELLOW,
            'medium': Colors.CYAN,
            'low': Colors.GREEN
        }
        color = color_map.get(severity.lower(), Colors.WHITE)
        symbol = '●'
        print(f"{color}{symbol} [{severity.upper()}]{Colors.RESET} {message}")
    
    @staticmethod
    def print_progress_bar(current: int, total: int, width: int = 50):
        """Print progress bar"""
        percent = (current / total) * 100
        filled = int(width * current / total)
        bar = '█' * filled + '░' * (width - filled)
        print(f"\r{Colors.CYAN}[{bar}] {percent:.1f}%{Colors.RESET}", end='', flush=True)
    
    @staticmethod
    def print_table(headers: List[str], rows: List[List[str]]):
        """Print formatted table"""
        col_widths = [max(len(str(h)), max(len(str(r[i])) for r in rows)) for i, h in enumerate(headers)]
        
        header_row = " │ ".join(f"{h:<{col_widths[i]}}" for i, h in enumerate(headers))
        print(f"{Colors.BOLD}{Colors.CYAN}┌{'─'*(len(header_row)+2)}┐{Colors.RESET}")
        print(f"{Colors.BOLD}{Colors.CYAN}│ {header_row} │{Colors.RESET}")
        print(f"{Colors.BOLD}{Colors.CYAN}├{'─'*(len(header_row)+2)}┤{Colors.RESET}")
        
        for row in rows:
            row_str = " │ ".join(f"{str(r):<{col_widths[i]}}" for i, r in enumerate(row))
            print(f"{Colors.WHITE}│ {row_str} │{Colors.RESET}")
        
        print(f"{Colors.BOLD}{Colors.CYAN}└{'─'*(len(header_row)+2)}┘{Colors.RESET}")

# ============================================================================
# CONFIGURATION
# ============================================================================

class SyntaxConfig:
    """Platform configuration"""
    VERSION = "18.0"
    PLATFORM_NAME = "SYNTAX Enterprise Security Platform"
    
    THREAT_INTEL_SOURCES = [
        "AlienVault OTX", "Abuse.ch", "Cisco Talos", "Emerging Threats",
        "PhishTank", "Spamhaus", "VirusTotal", "MalwareBazaar",
        "URLhaus", "ThreatFox", "Botvrij.eu", "OpenPhish",
        "CERT-EU", "US-CERT", "CISA AIS", "FBI InfraGard",
        "MITRE ATT&CK", "CrowdStrike Intel", "Mandiant Intel",
        "Palo Alto Unit 42", "Kaspersky", "Symantec", "FireEye"
    ]
    
    COMPLIANCE_FRAMEWORKS = {
        "ISO 27001": {"controls": 114, "category": "Information Security"},
        "PCI-DSS": {"controls": 78, "category": "Payment Card"},
        "SOC 2 Type II": {"controls": 64, "category": "Service Organization"},
        "HIPAA": {"controls": 45, "category": "Healthcare"},
        "GDPR": {"controls": 32, "category": "Data Protection"},
        "NIST CSF": {"controls": 98, "category": "Cybersecurity Framework"}
    }

# ============================================================================
# ENGINES
# ============================================================================

class ThreatIntelligenceEngine:
    """Threat intelligence aggregation"""
    
    def aggregate_feeds(self) -> List[Dict[str, Any]]:
        feeds = []
        print(f"\n{Colors.CYAN}Aggregating threat intelligence feeds...{Colors.RESET}")
        sources = random.sample(SyntaxConfig.THREAT_INTEL_SOURCES, 10)
        
        for i, source in enumerate(sources):
            TerminalUI.print_progress_bar(i + 1, len(sources))
            time.sleep(0.1)
            
            feeds.append({
                "source": source,
                "iocs": random.randint(100, 5000),
                "confidence": round(random.uniform(0.6, 0.99), 2),
                "severity": random.choice(["critical", "high", "medium", "low"]),
                "last_update": f"{random.randint(1, 60)}m ago"
            })
        
        print()
        return feeds
    
    def correlate_threats(self, feeds: List[Dict]) -> Dict[str, Any]:
        total_iocs = sum(f["iocs"] for f in feeds)
        unique_iocs = int(total_iocs * 0.73)
        
        return {
            "total_iocs": total_iocs,
            "unique_iocs": unique_iocs,
            "duplicate_rate": round((1 - unique_iocs/total_iocs) * 100, 1),
            "critical_threats": random.randint(15, 40),
            "high_threats": random.randint(50, 150),
            "confidence_score": round(random.uniform(0.75, 0.95), 2)
        }

class UEBAEngine:
    """User behavior analytics"""
    
    def analyze_behavior(self) -> List[Dict[str, Any]]:
        print(f"\n{Colors.CYAN}Analyzing user behavior patterns...{Colors.RESET}")
        
        high_risk_users = []
        activities = [
            "Multiple failed login attempts",
            "Access from new geographic location",
            "Unusual file download volume",
            "After-hours database access",
            "Privilege escalation attempt",
            "Suspicious API usage"
        ]
        
        for i in range(10):
            TerminalUI.print_progress_bar(i + 1, 10)
            time.sleep(0.1)
            
            risk_score = random.randint(25, 95)
            if risk_score > 60:
                high_risk_users.append({
                    "email": f"user.{i+1}@company.com",
                    "risk_score": risk_score,
                    "anomalies": int(risk_score / 15),
                    "primary_activity": random.choice(activities),
                    "threat_level": "Critical" if risk_score >= 80 else "High",
                    "last_seen": f"{random.randint(0, 23):02d}:{random.randint(0, 59):02d}"
                })
        
        print()
        return sorted(high_risk_users, key=lambda x: x["risk_score"], reverse=True)

class CSPMEngine:
    """Cloud security posture management"""
    
    def scan_infrastructure(self) -> Dict[str, Any]:
        print(f"\n{Colors.CYAN}Scanning cloud infrastructure...{Colors.RESET}")
        
        findings = [
            {
                "provider": "AWS",
                "resource": "S3 Bucket: prod-data-2024",
                "issue": "Public read access enabled",
                "severity": "critical",
                "compliance": ["PCI-DSS", "SOC 2"],
                "remediation": "aws s3api put-bucket-acl --bucket prod-data-2024 --acl private"
            },
            {
                "provider": "AWS",
                "resource": "EC2 Security Group: web-sg",
                "issue": "Unrestricted inbound SSH",
                "severity": "high",
                "compliance": ["ISO 27001"],
                "remediation": "Restrict SSH access to specific IPs"
            },
            {
                "provider": "Azure",
                "resource": "Storage Account: backups",
                "issue": "Encryption at rest disabled",
                "severity": "high",
                "compliance": ["HIPAA"],
                "remediation": "Enable storage encryption"
            },
            {
                "provider": "GCP",
                "resource": "VM Instance: web-server-01",
                "issue": "Unrestricted SSH access",
                "severity": "high",
                "compliance": ["CIS Benchmark"],
                "remediation": "Update firewall rules"
            }
        ]
        
        for i in range(len(findings)):
            TerminalUI.print_progress_bar(i + 1, len(findings))
            time.sleep(0.1)
        
        print()
        
        return {
            "total_resources": random.randint(1500, 3000),
            "total_findings": len(findings) + random.randint(140, 200),
            "critical": random.randint(10, 20),
            "high": random.randint(40, 70),
            "medium": random.randint(50, 100),
            "low": random.randint(40, 80),
            "findings": findings
        }
    
    def assess_compliance(self) -> Dict[str, Any]:
        compliance_status = {}
        
        for framework, info in SyntaxConfig.COMPLIANCE_FRAMEWORKS.items():
            total = info["controls"]
            passed = int(total * random.uniform(0.75, 0.95))
            pct = round((passed / total) * 100, 1)
            
            compliance_status[framework] = {
                "compliance_percentage": pct,
                "total_controls": total,
                "passed": passed,
                "failed": total - passed,
                "category": info["category"],
                "status": "Compliant" if pct >= 80 else "Non-Compliant"
            }
        
        return compliance_status

class QuantumCrypto:
    """Quantum-safe cryptography"""
    
    def generate_keypair(self):
        print(f"\n{Colors.CYAN}Generating quantum-safe keys...{Colors.RESET}")
        
        for i in range(10):
            TerminalUI.print_progress_bar(i + 1, 10)
            time.sleep(0.05)
        
        print()
        
        if CRYPTO_AVAILABLE:
            rsa.generate_private_key(
                public_exponent=65537,
                key_size=4096,
                backend=default_backend()
            )
        
        return {
            "algorithm": "ML-DSA-256",
            "key_size": 256,
            "status": "Active",
            "rotation_schedule": "Hourly",
            "last_rotation": datetime.now().isoformat()
        }

# ============================================================================
# INTERACTIVE DASHBOARD
# ============================================================================

class InteractiveDashboard:
    """Main interactive dashboard"""
    
    def __init__(self):
        self.threat_intel = ThreatIntelligenceEngine()
        self.ueba = UEBAEngine()
        self.cspm = CSPMEngine()
        self.crypto = QuantumCrypto()
        
        self.threat_feeds = None
        self.threat_correlations = None
        self.high_risk_users = None
        self.cspm_results = None
        self.compliance = None
        self.crypto_status = None
    
    def show_main_menu(self):
        """Display main menu"""
        while True:
            TerminalUI.clear_screen()
            TerminalUI.print_header(f"{SyntaxConfig.PLATFORM_NAME} v{SyntaxConfig.VERSION}")
            
            print(f"{Colors.BOLD}{Colors.CYAN}Main Menu:{Colors.RESET}\n")
            print(f"{Colors.GREEN}1.{Colors.RESET} Dashboard Overview")
            print(f"{Colors.GREEN}2.{Colors.RESET} Threat Intelligence")
            print(f"{Colors.GREEN}3.{Colors.RESET} User Behavior Analytics (UEBA)")
            print(f"{Colors.GREEN}4.{Colors.RESET} Cloud Security (CSPM)")
            print(f"{Colors.GREEN}5.{Colors.RESET} Compliance Status")
            print(f"{Colors.GREEN}6.{Colors.RESET} Quantum Cryptography")
            print(f"{Colors.GREEN}7.{Colors.RESET} Generate Full Report")
            print(f"{Colors.GREEN}8.{Colors.RESET} Real-Time Monitor")
            print(f"{Colors.RED}9.{Colors.RESET} Exit")
            
            choice = input(f"\n{Colors.BOLD}Select option (1-9): {Colors.RESET}")
            
            if choice == "1":
                self.show_dashboard()
            elif choice == "2":
                self.show_threat_intel()
            elif choice == "3":
                self.show_ueba()
            elif choice == "4":
                self.show_cspm()
            elif choice == "5":
                self.show_compliance()
            elif choice == "6":
                self.show_crypto()
            elif choice == "7":
                self.generate_full_report()
            elif choice == "8":
                self.show_realtime_monitor()
            elif choice == "9":
                print(f"\n{Colors.GREEN}Thank you for using SYNTAX!{Colors.RESET}\n")
                sys.exit(0)
            else:
                print(f"{Colors.RED}Invalid option. Press Enter to continue...{Colors.RESET}")
                input()
    
    def load_data(self):
        """Pre-load all data"""
        if not self.threat_feeds:
            self.threat_feeds = self.threat_intel.aggregate_feeds()
            self.threat_correlations = self.threat_intel.correlate_threats(self.threat_feeds)
        
        if not self.high_risk_users:
            self.high_risk_users = self.ueba.analyze_behavior()
        
        if not self.cspm_results:
            self.cspm_results = self.cspm.scan_infrastructure()
        
        if not self.compliance:
            self.compliance = self.cspm.assess_compliance()
        
        if not self.crypto_status:
            self.crypto_status = self.crypto.generate_keypair()
    
    def show_dashboard(self):
        """Show main dashboard"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Security Dashboard Overview")
        
        self.load_data()
        
        print(f"\n{Colors.BOLD}Key Performance Indicators:{Colors.RESET}\n")
        
        print(f"{Colors.RED}┌──────────────────────────────────────┐{Colors.RESET}")
        print(f"{Colors.RED}│ Critical Threats: {self.threat_correlations['critical_threats']:<18} │{Colors.RESET}")
        print(f"{Colors.RED}│ Status: IMMEDIATE ACTION REQUIRED    │{Colors.RESET}")
        print(f"{Colors.RED}└──────────────────────────────────────┘{Colors.RESET}")
        
        print(f"\n{Colors.YELLOW}┌──────────────────────────────────────┐{Colors.RESET}")
        print(f"{Colors.YELLOW}│ High-Risk Users: {len(self.high_risk_users):<18} │{Colors.RESET}")
        print(f"{Colors.YELLOW}│ Status: MONITORING REQUIRED          │{Colors.RESET}")
        print(f"{Colors.YELLOW}└──────────────────────────────────────┘{Colors.RESET}")
        
        print(f"\n{Colors.CYAN}┌──────────────────────────────────────┐{Colors.RESET}")
        print(f"{Colors.CYAN}│ Cloud Findings: {self.cspm_results['total_findings']:<18} │{Colors.RESET}")
        print(f"{Colors.CYAN}│ Critical: {self.cspm_results['critical']:<26} │{Colors.RESET}")
        print(f"{Colors.CYAN}└──────────────────────────────────────┘{Colors.RESET}")
        
        print(f"\n{Colors.GREEN}┌──────────────────────────────────────┐{Colors.RESET}")
        print(f"{Colors.GREEN}│ Security Score: {random.randint(72, 88)}/100               │{Colors.RESET}")
        print(f"{Colors.GREEN}│ Status: GOOD                         │{Colors.RESET}")
        print(f"{Colors.GREEN}└──────────────────────────────────────┘{Colors.RESET}")
        
        input(f"\n{Colors.BOLD}Press Enter to return to menu...{Colors.RESET}")
    
    def show_threat_intel(self):
        """Show threat intelligence"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Threat Intelligence Overview")
        
        self.load_data()
        
        TerminalUI.print_section("Summary Statistics")
        print(f"Total IOCs: {Colors.BOLD}{self.threat_correlations['total_iocs']:,}{Colors.RESET}")
        print(f"Unique IOCs: {Colors.BOLD}{self.threat_correlations['unique_iocs']:,}{Colors.RESET}")
        print(f"Critical Threats: {Colors.RED}{self.threat_correlations['critical_threats']}{Colors.RESET}")
        
        TerminalUI.print_section("Top Sources")
        headers = ["Source", "IOCs", "Severity", "Last Update"]
        rows = [[f["source"], f"{f['iocs']:,}", f["severity"].upper(), f["last_update"]] 
                for f in self.threat_feeds[:5]]
        TerminalUI.print_table(headers, rows)
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def show_ueba(self):
        """Show UEBA"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("User & Entity Behavior Analytics")
        
        self.load_data()
        
        for user in self.high_risk_users[:5]:
            print(f"\n{Colors.CYAN}Email:{Colors.RESET} {user['email']}")
            color = Colors.RED if user['risk_score'] >= 80 else Colors.YELLOW
            print(f"{Colors.CYAN}Risk:{Colors.RESET} {color}{user['risk_score']}/100{Colors.RESET} [{user['threat_level']}]")
            print(f"{Colors.CYAN}Activity:{Colors.RESET} {user['primary_activity']}")
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def show_cspm(self):
        """Show cloud security"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Cloud Security Posture Management")
        
        self.load_data()
        
        print(f"Total Resources: {self.cspm_results['total_resources']:,}")
        print(f"Findings: {self.cspm_results['total_findings']}")
        print(f"  {Colors.RED}● Critical: {self.cspm_results['critical']}{Colors.RESET}")
        print(f"  {Colors.YELLOW}● High: {self.cspm_results['high']}{Colors.RESET}")
        
        print(f"\n{Colors.BOLD}Critical Issues:{Colors.RESET}")
        for f in [x for x in self.cspm_results['findings'] if x['severity'] == 'critical']:
            print(f"\n{Colors.RED}▼{Colors.RESET} [{f['provider']}] {f['resource']}")
            print(f"  {f['issue']}")
            print(f"  Remediation: {f['remediation']}")
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def show_compliance(self):
        """Show compliance"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Compliance Status")
        
        self.load_data()
        
        for framework, status in self.compliance.items():
            pct = status['compliance_percentage']
            color = Colors.GREEN if pct >= 90 else Colors.YELLOW if pct >= 80 else Colors.RED
            symbol = "✓" if status['status'] == "Compliant" else "✗"
            
            print(f"\n{color}{symbol} {framework}{Colors.RESET}")
            print(f"   Compliance: {color}{pct}%{Colors.RESET}")
            filled = int(50 * pct / 100)
            print(f"   [{color}{'█' * filled}{'░' * (50 - filled)}{Colors.RESET}]")
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def show_crypto(self):
        """Show cryptography"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Quantum-Safe Cryptography")
        
        self.load_data()
        
        print(f"{Colors.BOLD}Algorithm:{Colors.RESET} {self.crypto_status['algorithm']} (NIST PQC)")
        print(f"{Colors.BOLD}Key Size:{Colors.RESET} {self.crypto_status['key_size']}-bit")
        print(f"{Colors.BOLD}Status:{Colors.RESET} {Colors.GREEN}{self.crypto_status['status']}{Colors.RESET}")
        print(f"{Colors.BOLD}Rotation:{Colors.RESET} {self.crypto_status['rotation_schedule']}")
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def generate_full_report(self):
        """Generate full report"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Comprehensive Security Report")
        
        self.load_data()
        
        print(f"\n{Colors.BOLD}Overall Security Score: {random.randint(72, 88)}/100{Colors.RESET}\n")
        
        print(f"{Colors.MAGENTA}THREAT INTELLIGENCE{Colors.RESET}")
        print(f"  IOCs: {self.threat_correlations['total_iocs']:,}")
        print(f"  Critical: {self.threat_correlations['critical_threats']}")
        
        print(f"\n{Colors.MAGENTA}USER BEHAVIOR{Colors.RESET}")
        print(f"  High-Risk Users: {len(self.high_risk_users)}")
        
        print(f"\n{Colors.MAGENTA}CLOUD SECURITY{Colors.RESET}")
        print(f"  Resources: {self.cspm_results['total_resources']:,}")
        print(f"  Critical Issues: {self.cspm_results['critical']}")
        
        print(f"\n{Colors.MAGENTA}COMPLIANCE{Colors.RESET}")
        for fw, s in list(self.compliance.items())[:3]:
            print(f"  {fw}: {s['compliance_percentage']}%")
        
        print(f"\n{Colors.BOLD}Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}{Colors.RESET}")
        
        input(f"\n{Colors.BOLD}Press Enter to return...{Colors.RESET}")
    
    def show_realtime_monitor(self):
        """Real-time monitor"""
        TerminalUI.clear_screen()
        TerminalUI.print_header("Real-Time Security Monitor")
        
        print(f"{Colors.CYAN}Monitoring events... (Press Ctrl+C to stop){Colors.RESET}\n")
        
        events = [
            ("critical", "Malicious IP blocked: 185.220.101.47"),
            ("high", "Anomalous login detected: admin@company.com"),
            ("high", "AWS S3 bucket misconfiguration detected"),
            ("medium", "Phishing email quarantined"),
            ("low", "Routine security scan completed")
        ]
        
        try:
            while True:
                event = random.choice(events)
                timestamp = datetime.now().strftime("%H:%M:%S")
                TerminalUI.print_alert(event[0], f"[{timestamp}] {event[1]}")
                time.sleep(random.uniform(1, 3))
        except KeyboardInterrupt:
            print(f"\n\n{Colors.YELLOW}Monitor stopped.{Colors.RESET}")
            input(f"{Colors.BOLD}Press Enter to return...{Colors.RESET}")

# ============================================================================
# MAIN ENTRY POINT
# ============================================================================

def main():
    """Main entry point"""
    try:
        dashboard = InteractiveDashboard()
        dashboard.show_main_menu()
    except KeyboardInterrupt:
        print(f"\n\n{Colors.GREEN}Thank you for using SYNTAX!{Colors.RESET}\n")
        sys.exit(0)
    except Exception as e:
        print(f"\n{Colors.RED}Error: {str(e)}{Colors.RESET}\n")
        sys.exit(1)

if __name__ == "__main__":
    main()