Update app.py

app.py

@@ -1,9 +1,14 @@
 
+# BÖLÜM 1: KODUN 1-7. BÖLÜMLERİ
+# Bu dosyayı app_part1.py olarak kaydedin
+
 ═══════════════════════════════════════════════════════════════════════════════
-    PRIVATE RED TEAM WEB RECONNAISSANCE FRAMEWORK v3.0
+    PRIVATE RED TEAM WEB RECONNAISSANCE FRAMEWORK v3.0 - PART 1
     ─────────────────────────────────────────────────────────────────────────
-    Advanced Web Application Security Assessment Tool - Private Space Edition
-═══════════════════════════════════════════════════════════
+    Bölümler: 1-7 (Configuration, Data Models, Stealth, OSINT, Active Recon, 
+    Threat Modeling, Attack Graph)
+═══════════════════════════════════════════════════════════════════════════════
+"""
 
 import gradio as gr
 import asyncio
@@ -36,11 +41,20 @@ from urllib.parse import urljoin, urlparse
 # ════════════════════════════════════════════════════════════════════════════
 
 class ThreatLevel(Enum):
+    """Threat/Risk Assessment Levels"""
     LOW = 0
     MEDIUM = 1
     HIGH = 2
     CRITICAL = 3
 
+class CVESSeverity(Enum):
+    """CVSS Severity Ratings"""
+    CRITICAL = (9.0, 10.0)
+    HIGH = (7.0, 8.9)
+    MEDIUM = (4.0, 6.9)
+    LOW = (0.1, 3.9)
+
+# STRIDE Threat Model
 STRIDE_THREATS = {
     "Spoofing": {
         "description": "Identity spoofing",
@@ -74,6 +88,7 @@ STRIDE_THREATS = {
     }
 }
 
+# Extended MITRE ATT&CK Matrix
 MITRE_TECHNIQUES = {
     "Reconnaissance": {
         "T1592": "Gather Victim Host Information",
@@ -135,6 +150,47 @@ MITRE_TECHNIQUES = {
     }
 }
 
+# Technology fingerprints - Extended
+TECH_FINGERPRINTS = {
+    "Web Servers": {
+        "Apache": [r"Server: Apache", r"X-Powered-By: Apache"],
+        "Nginx": [r"Server: nginx", r"X-Nginx"],
+        "IIS": [r"Server: Microsoft-IIS"],
+        "Cloudflare": [r"CF-RAY", r"Cloudflare"],
+        "AWS": [r"X-Amz", r"AmazonS3"],
+        "Azure": [r"Azure", r"Microsoft-IIS"]
+    },
+    "CMS": {
+        "WordPress": [r"/wp-admin", r"wp-content", r"wp_.*"],
+        "Drupal": [r"/sites/default", r"drupal\\.css"],
+        "Joomla": [r"/administrator", r"com_content"],
+        "Magento": [r"/skin/frontend", r"Mage.Cookies"],
+        "Shopify": [r"cdn.shopify.com", r"Shopify.theme"]
+    },
+    "Frameworks": {
+        "Django": [r"CSRF", r"django_session"],
+        "Flask": [r"werkzeug", r"Flask"],
+        "Laravel": [r"XSRF-TOKEN", r"laravel_session"],
+        "Spring": [r"JSESSIONID", r"spring"],
+        "Ruby on Rails": [r"_rails", r"authenticity_token"],
+        "ASP.NET": [r"ASP.NET_SessionId", r"__VIEWSTATE"]
+    },
+    "JavaScript": {
+        "React": [r"__REACT", r"react\\.js"],
+        "Vue": [r"__VUE", r"vue\\.js"],
+        "Angular": [r"ng-app", r"angular\\.js"],
+        "jQuery": [r"jquery", r"jQuery"],
+        "Bootstrap": [r"bootstrap", r"data-toggle"]
+    },
+    "Databases": {
+        "MySQL": [r"MySQL", r"sqlstate"],
+        "PostgreSQL": [r"PostgreSQL", r"pg_query"],
+        "MongoDB": [r"MongoDB", r"mongod"],
+        "Redis": [r"Redis", r"redis-cli"]
+    }
+}
+
+# Security Headers to check
 SECURITY_HEADERS = {
     "Strict-Transport-Security": "HSTS",
     "Content-Security-Policy": "CSP",
@@ -145,6 +201,7 @@ SECURITY_HEADERS = {
     "Permissions-Policy": "Feature Policy"
 }
 
+# Common endpoints for discovery
 COMMON_ENDPOINTS = [
     "", "admin", "api", "login", "test", "debug", "config",
     "api/users", "api/admin", "api/auth", "api/data", "api/v1",
@@ -162,6 +219,7 @@ COMMON_ENDPOINTS = [
 
 @dataclass
 class IntelligenceIndicator:
+    """IOC - Indicator of Compromise"""
     type: str
     value: str
     confidence: float
@@ -171,6 +229,7 @@ class IntelligenceIndicator:
 
 @dataclass
 class ThreatVector:
+    """Attack surface element"""
     category: str
     location: str
     risk_score: float
@@ -182,6 +241,7 @@ class ThreatVector:
 
 @dataclass
 class AttackPath:
+    """End-to-end attack chain"""
     entry_point: str
     intermediate_steps: List[str]
     objective: str
@@ -195,6 +255,7 @@ class AttackPath:
 
 @dataclass
 class Vulnerability:
+    """Vulnerability finding"""
     name: str
     description: str
     severity: str
@@ -216,6 +277,8 @@ class Vulnerability:
 # ════════════════════════════════════════════════════════════════════════════
 
 class StealthConfig:
+    """Anti-detection & evasion configuration"""
+    
     def __init__(self, threat_level: ThreatLevel = ThreatLevel.MEDIUM):
         self.threat_level = threat_level
         
@@ -246,10 +309,12 @@ class StealthConfig:
         self.current_proxy = 0
     
     def get_delay(self) -> float:
+        """Random delay to avoid pattern detection"""
         min_d, max_d = self.delay_ranges[self.threat_level]
         return random.uniform(min_d, max_d) / 1000
     
     def get_headers(self) -> Dict[str, str]:
+        """Anti-fingerprinting headers"""
         headers = {
             "User-Agent": random.choice(self.user_agents),
             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
@@ -265,12 +330,22 @@ class StealthConfig:
             "Sec-Fetch-User": "?1"
         }
         return headers
+    
+    def get_proxy(self) -> Optional[Dict]:
+        """Rotate proxies if available"""
+        if not self.proxies:
+            return None
+        proxy = self.proxies[self.current_proxy % len(self.proxies)]
+        self.current_proxy += 1
+        return proxy
 
 # ════════════════════════════════════════════════════════════════════════════
 # SECTION 4: PASSIVE OSINT ENGINE
 # ════════════════════════════════════════════════════════════════════════════
 
 class PassiveOSINTEngine:
+    """Passive reconnaissance without alerting target"""
+    
     def __init__(self, config: StealthConfig):
         self.config = config
         self.indicators: Dict[str, List[IntelligenceIndicator]] = defaultdict(list)
@@ -281,6 +356,7 @@ class PassiveOSINTEngine:
         return logging.getLogger("PassiveOSINT")
     
     async def gather_dns_intel(self, domain: str) -> Dict:
+        """DNS records, subdomains from public sources"""
         intel = {
             "subdomains": [],
             "mx_records": [],
@@ -294,6 +370,7 @@ class PassiveOSINTEngine:
         try:
             import dns.resolver
             
+            # Try common subdomains
             common_subs = [
                 "www", "mail", "ftp", "admin", "api", "dev", "staging",
                 "cdn", "test", "blog", "shop", "support", "docs", "app",
@@ -314,6 +391,7 @@ class PassiveOSINTEngine:
                 except:
                     pass
                 
+                # Try AAAA records
                 try:
                     full_domain = f"{sub}.{domain}"
                     result = dns.resolver.resolve(full_domain, 'AAAA')
@@ -325,18 +403,21 @@ class PassiveOSINTEngine:
                 except:
                     pass
             
+            # MX records
             try:
                 mx = dns.resolver.resolve(domain, 'MX')
                 intel["mx_records"] = [{"preference": r.preference, "exchange": str(r.exchange)} for r in mx]
             except:
                 pass
             
+            # NS records
             try:
                 ns = dns.resolver.resolve(domain, 'NS')
                 intel["ns_records"] = [str(r) for r in ns]
             except:
                 pass
             
+            # TXT records (SPF, DKIM, DMARC)
             try:
                 txt = dns.resolver.resolve(domain, 'TXT')
                 intel["txt_records"] = [str(r) for r in txt]
@@ -349,6 +430,7 @@ class PassiveOSINTEngine:
         return intel
     
     async def gather_ssl_cert_intel(self, domain: str) -> Dict:
+        """SSL certificate analysis for subdomains"""
         cert_intel = {
             "subject": None,
             "issuer": None,
@@ -379,11 +461,13 @@ class PassiveOSINTEngine:
                     cert_intel["version"] = version
                     cert_intel["cipher"] = cipher
                     
+                    # Check expiration
                     from datetime import datetime
                     expiry = datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
                     cert_intel["expired"] = expiry < datetime.now()
                     cert_intel["valid"] = True
                     
+                    # Extract SANs
                     for alt_name in cert.get('subjectAltName', []):
                         if alt_name[0] == 'DNS':
                             cert_intel["subjectAltNames"].append(alt_name[1])
@@ -393,6 +477,7 @@ class PassiveOSINTEngine:
         return cert_intel
     
     async def crt_sh_lookup(self, domain: str) -> List[str]:
+        """Query Certificate Transparency logs via crt.sh"""
         subdomains = set()
         try:
             url = f"https://crt.sh/?q=%.{domain}&output=json"
@@ -412,6 +497,7 @@ class PassiveOSINTEngine:
         return list(subdomains)
     
     async def github_reconnaissance(self, org_name: str) -> Dict:
+        """Search GitHub for organization info"""
         github_intel = {
             "repositories": [],
             "leaked_patterns": [],
@@ -421,6 +507,7 @@ class PassiveOSINTEngine:
         }
         
         try:
+            # Search repos
             endpoint = f"https://api.github.com/users/{org_name}/repos"
             headers = self.config.get_headers()
             
@@ -428,7 +515,7 @@ class PassiveOSINTEngine:
                 async with session.get(endpoint, headers=headers, timeout=10) as resp:
                     if resp.status == 200:
                         repos = await resp.json()
-                        for repo in repos[:20]:
+                        for repo in repos[:20]:  # Limit to 20
                             github_intel["repositories"].append({
                                 "name": repo.get("name"),
                                 "url": repo.get("html_url"),
@@ -442,6 +529,7 @@ class PassiveOSINTEngine:
                             if repo.get("language"):
                                 github_intel["technology_hints"].append(repo.get("language"))
                             
+                            # Check for common leaked patterns in repo names/descriptions
                             desc = (repo.get("description") or "").lower()
                             if any(x in desc for x in ['password', 'secret', 'key', 'token', 'credential']):
                                 github_intel["leaked_patterns"].append({
@@ -449,6 +537,7 @@ class PassiveOSINTEngine:
                                     "pattern": "Potential secret in description"
                                 })
             
+            # Search for gists
             gist_endpoint = f"https://api.github.com/users/{org_name}/gists"
             async with aiohttp.ClientSession() as session:
                 async with session.get(gist_endpoint, headers=headers, timeout=10) as resp:
@@ -466,6 +555,7 @@ class PassiveOSINTEngine:
         return github_intel
     
     async def wayback_machine_lookup(self, domain: str) -> List[str]:
+        """Query Wayback Machine for historical URLs"""
         urls = []
         try:
             endpoint = f"http://web.archive.org/cdx/search/cdx?url=*.{domain}/*&output=json&fl=original&collapse=urlkey"
@@ -475,24 +565,74 @@ class PassiveOSINTEngine:
                 async with session.get(endpoint, headers=headers, timeout=15) as resp:
                     if resp.status == 200:
                         data = await resp.json()
-                        if len(data) > 1:
+                        if len(data) > 1:  # First row is headers
                             urls = [row[0] for row in data[1:]]
         except Exception as e:
             self.logger.error(f"Wayback lookup failed: {e}")
         
-        return urls[:100]
+        return urls[:100]  # Limit to 100
+    
+    async def exposed_data_check(self, domain: str) -> List[Dict]:
+        """Check if domain in breach databases"""
+        breaches = []
+        
+        try:
+            # HIBP API (requires key in production, placeholder here)
+            # endpoint = f"https://haveibeenpwned.com/api/v3/breaches?domain={domain}"
+            # headers = {"User-Agent": "RedTeamFramework/3.0", "hibp-api-key": "YOUR_API_KEY"}
+            # resp = requests.get(endpoint, headers=headers, timeout=5)
+            # if resp.status_code == 200:
+            #     breaches = resp.json()
+            pass
+        except:
+            pass
+        
+        return breaches
+    
+    async def shodan_lookup(self, domain: str) -> Dict:
+        """Shodan host lookup (requires API key)"""
+        shodan_data = {
+            "ip": None,
+            "ports": [],
+            "services": [],
+            "vulnerabilities": [],
+            "hostnames": [],
+            "location": {}
+        }
+        
+        try:
+            # Placeholder - requires Shodan API key
+            # import shodan
+            # api = shodan.Shodan("YOUR_API_KEY")
+            # host = api.host(domain)
+            # shodan_data = {
+            #     "ip": host['ip_str'],
+            #     "ports": host['ports'],
+            #     "services": [match['product'] for match in host['data']],
+            #     "vulnerabilities": host.get('vulns', []),
+            #     "hostnames": host.get('hostnames', []),
+            #     "location": host.get('location', {})
+            # }
+            pass
+        except:
+            pass
+        
+        return shodan_data
 
 # ════════════════════════════════════════════════════════════════════════════
 # SECTION 5: ACTIVE RECONNAISSANCE ENGINE
 # ════════════════════════════════════════════════════════════════════════════
 
 class ActiveReconEngine:
+    """Active scanning with OPSEC measures"""
+    
     def __init__(self, config: StealthConfig):
         self.config = config
         self.findings = []
         self.logger = logging.getLogger("ActiveRecon")
     
     async def fingerprint_technologies(self, url: str) -> Dict:
+        """Identify technologies from headers, HTML, JS"""
         technologies = {
             "web_server": None,
             "cms": [],
@@ -509,18 +649,26 @@ class ActiveReconEngine:
             headers = self.config.get_headers()
             resp = requests.get(f"https://{url}", headers=headers, timeout=10, verify=False, allow_redirects=True)
             
+            # Server header analysis
             if "Server" in resp.headers:
-                technologies["web_server"] = resp.headers["Server"]
+                server = resp.headers["Server"]
+                technologies["web_server"] = server
             
+            # X-Powered-By
             if "X-Powered-By" in resp.headers:
                 technologies["frameworks"].append(resp.headers["X-Powered-By"])
             
+            # X-Generator (CMS)
             if "X-Generator" in resp.headers:
                 technologies["cms"].append(resp.headers["X-Generator"])
             
+            # CDN detection
             if "CF-RAY" in resp.headers or "Cloudflare" in resp.headers.get("Server", ""):
                 technologies["cdn"].append("Cloudflare")
+            if "X-Cache" in resp.headers or "Fastly" in str(resp.headers):
+                technologies["cdn"].append("Fastly")
             
+            # Security headers analysis
             for header, description in SECURITY_HEADERS.items():
                 if header in resp.headers:
                     technologies["security_headers"][header] = resp.headers[header]
@@ -529,6 +677,7 @@ class ActiveReconEngine:
             
             content = resp.text
             
+            # CMS/Framework detection
             patterns = {
                 "WordPress": r"wp-content|wp-includes|/wp-admin|wordpress",
                 "Drupal": r"sites/default/files|drupal\\.css|drupal.js",
@@ -562,6 +711,7 @@ class ActiveReconEngine:
                         if tech not in technologies["analytics"]:
                             technologies["analytics"].append(tech)
             
+            # Check for cookies
             if "Set-Cookie" in resp.headers:
                 cookies = resp.headers["Set-Cookie"]
                 if "PHPSESSID" in cookies:
@@ -575,10 +725,11 @@ class ActiveReconEngine:
         return technologies
     
     async def discover_endpoints(self, url: str, wordlist: List[str] = None) -> List[Dict]:
+        """Endpoint discovery with smart filtering"""
         discovered = []
         wordlist = wordlist or COMMON_ENDPOINTS
         
-        for path in wordlist[:50]:
+        for path in wordlist[:50]:  # Limit wordlist
             try:
                 full_url = f"https://{url.rstrip('/')}/{path.lstrip('/')}"
                 headers = self.config.get_headers()
@@ -602,6 +753,7 @@ class ActiveReconEngine:
         return discovered
     
     def _extract_title(self, html: str) -> str:
+        """Extract page title from HTML"""
         try:
             soup = BeautifulSoup(html, 'html.parser')
             title = soup.find('title')
@@ -610,6 +762,7 @@ class ActiveReconEngine:
             return "Error"
     
     async def analyze_forms(self, url: str) -> List[Dict]:
+        """Form detection and analysis"""
         forms = []
         
         try:
@@ -638,11 +791,13 @@ class ActiveReconEngine:
                     }
                     form_data["fields"].append(field_info)
                     
+                    # Check for potential vulnerabilities
                     if field.get('type') == 'password':
-                        form_data["vulnerabilities"].append("Password field detected")
+                        form_data["vulnerabilities"].append("Password field detected - check for brute force protection")
                     if field.get('type') == 'file':
-                        form_data["vulnerabilities"].append("File upload detected")
+                        form_data["vulnerabilities"].append("File upload - check for upload restrictions")
                 
+                # Check for CSRF protection
                 has_csrf = any('csrf' in str(f.get('name', '')).lower() or 
                               'token' in str(f.get('name', '')).lower() 
                               for f in form_data["fields"])
@@ -657,12 +812,14 @@ class ActiveReconEngine:
         return forms
     
     async def extract_javascript_endpoints(self, url: str) -> List[Dict]:
+        """Extract API endpoints from JavaScript"""
         endpoints = []
         
         try:
             headers = self.config.get_headers()
             resp = requests.get(f"https://{url}", headers=headers, timeout=10, verify=False)
             
+            # Find all script tags
             soup = BeautifulSoup(resp.text, 'html.parser')
             scripts = []
             
@@ -670,6 +827,7 @@ class ActiveReconEngine:
                 if script.string:
                     scripts.append(script.string)
                 elif script.get('src'):
+                    # Fetch external scripts
                     try:
                         src = script['src']
                         if src.startswith('http'):
@@ -682,6 +840,7 @@ class ActiveReconEngine:
                     except:
                         pass
             
+            # Extract API patterns
             api_patterns = [
                 r'["\']/(api|v[0-9]|rest|graphql)/[^"\'\\s]+["\']',
                 r'(https?://[^"\'\\s]+/api/[^"\'\\s]+)',
@@ -696,14 +855,15 @@ class ActiveReconEngine:
                     matches = re.findall(pattern, script_content)
                     for match in matches:
                         if isinstance(match, tuple):
-                            match = match[-1]
+                            match = match[-1]  # Get the last group
                         if match and match not in [e["endpoint"] for e in endpoints]:
                             endpoints.append({
                                 "endpoint": match,
-                                "source": "js_analysis",
+                                "source": "inline_js" if script_content in [s.string for s in soup.find_all('script') if s.string] else "external_js",
                                 "type": "api"
                             })
             
+            # Look for hardcoded secrets
             secret_patterns = [
                 (r'api[_-]?key["\']?\\s*[:=]\\s*["\']([a-zA-Z0-9_\\-]{16,})["\']', "API Key"),
                 (r'secret[_-]?key["\']?\\s*[:=]\\s*["\']([a-zA-Z0-9_\\-]{16,})["\']', "Secret Key"),
@@ -718,7 +878,7 @@ class ActiveReconEngine:
                     matches = re.findall(pattern, script_content, re.IGNORECASE)
                     for match in matches:
                         endpoints.append({
-                            "endpoint": f"[{secret_type} DETECTED]",
+                            "endpoint": f"[{secret_type} DETECTED - REDACTED]",
                             "source": "js_analysis",
                             "type": "secret",
                             "secret_type": secret_type
@@ -730,6 +890,7 @@ class ActiveReconEngine:
         return endpoints
     
     async def analyze_security_headers(self, url: str) -> Dict:
+        """Analyze security headers"""
         headers_analysis = {
             "present": {},
             "missing": [],
@@ -743,8 +904,8 @@ class ActiveReconEngine:
             security_headers = {
                 "Strict-Transport-Security": {"weight": 3, "recommendation": "Implement HSTS"},
                 "Content-Security-Policy": {"weight": 3, "recommendation": "Implement CSP"},
-                "X-Frame-Options": {"weight": 2, "recommendation": "Set X-Frame-Options"},
-                "X-Content-Type-Options": {"weight": 2, "recommendation": "Set X-Content-Type-Options"},
+                "X-Frame-Options": {"weight": 2, "recommendation": "Set X-Frame-Options to DENY or SAMEORIGIN"},
+                "X-Content-Type-Options": {"weight": 2, "recommendation": "Set X-Content-Type-Options to nosniff"},
                 "X-XSS-Protection": {"weight": 1, "recommendation": "Set X-XSS-Protection"},
                 "Referrer-Policy": {"weight": 1, "recommendation": "Implement Referrer-Policy"},
                 "Permissions-Policy": {"weight": 1, "recommendation": "Implement Permissions-Policy"}
@@ -769,113 +930,117 @@ class ActiveReconEngine:
         return headers_analysis
     
     async def check_common_vulnerabilities(self, url: str) -> List[Vulnerability]:
+        """Check for common vulnerability patterns"""
         vulnerabilities = []
         
         try:
             headers = self.config.get_headers()
             
-            # Check .env
+            # Check for exposed .env
             try:
                 env_resp = requests.get(f"https://{url}/.env", headers=headers, timeout=5, verify=False)
                 if env_resp.status_code == 200 and "=" in env_resp.text:
                     vuln = Vulnerability(
                         name="Exposed Environment File",
-                        description="The .env file is publicly accessible",
+                        description="The .env file is publicly accessible, potentially exposing sensitive configuration",
                         severity="CRITICAL",
                         cvss_score=7.5,
                         cvss_vector="CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
                         location=f"https://{url}/.env",
-                        evidence=".env file accessible",
-                        remediation="Restrict access to .env files",
+                        evidence=".env file accessible without authentication",
+                        remediation="Restrict access to .env files via web server configuration",
                         cwe_id="CWE-200",
-                        owasp_category="A01:2021",
+                        owasp_category="A01:2021 - Broken Access Control",
                         mitre_techniques=["T1083"]
                     )
                     vulnerabilities.append(vuln)
             except:
                 pass
             
-            # Check .git
+            # Check for exposed .git
             try:
                 git_resp = requests.get(f"https://{url}/.git/HEAD", headers=headers, timeout=5, verify=False)
                 if git_resp.status_code == 200 and "ref:" in git_resp.text:
                     vuln = Vulnerability(
                         name="Exposed Git Repository",
-                        description="Git repository is publicly accessible",
+                        description="Git repository is publicly accessible, potentially exposing source code",
                         severity="HIGH",
                         cvss_score=7.5,
                         cvss_vector="CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
                         location=f"https://{url}/.git/",
                         evidence="Git HEAD file accessible",
-                        remediation="Restrict access to .git directory",
+                        remediation="Restrict access to .git directory via web server configuration",
                         cwe_id="CWE-200",
-                        owasp_category="A01:2021",
+                        owasp_category="A01:2021 - Broken Access Control",
                         mitre_techniques=["T1083"]
                     )
                     vulnerabilities.append(vuln)
             except:
                 pass
             
-            # Check directory listing
+            # Check for directory listing
             try:
                 dir_resp = requests.get(f"https://{url}/images/", headers=headers, timeout=5, verify=False)
                 if dir_resp.status_code == 200 and "Index of" in dir_resp.text:
                     vuln = Vulnerability(
                         name="Directory Listing Enabled",
-                        description="Directory listing is enabled",
+                        description="Directory listing is enabled, exposing file structure",
                         severity="MEDIUM",
                         cvss_score=5.3,
                         cvss_vector="CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N",
                         location=f"https://{url}/images/",
-                        evidence="Directory index displayed",
-                        remediation="Disable directory listing",
+                        evidence="Directory index page displayed",
+                        remediation="Disable directory listing in web server configuration",
                         cwe_id="CWE-548",
-                        owasp_category="A01:2021",
+                        owasp_category="A01:2021 - Broken Access Control",
                         mitre_techniques=["T1083"]
                     )
                     vulnerabilities.append(vuln)
             except:
                 pass
             
-            # Check SQL injection
+            # Check for SQL injection in URL parameters
             test_url = f"https://{url}/?id=1'"
             try:
                 sql_resp = requests.get(test_url, headers=headers, timeout=5, verify=False)
-                sql_errors = ["sql syntax", "mysql_fetch", "pg_query", "ORA-", "Microsoft OLE DB", "ODBC SQL Server"]
+                sql_errors = [
+                    "sql syntax", "mysql_fetch", "pg_query", "ORA-",
+                    "Microsoft OLE DB", "ODBC SQL Server", "SQLite3::"
+                ]
                 if any(error.lower() in sql_resp.text.lower() for error in sql_errors):
                     vuln = Vulnerability(
                         name="SQL Injection",
-                        description="Potential SQL injection vulnerability",
+                        description="Potential SQL injection vulnerability detected in URL parameters",
                         severity="CRITICAL",
                         cvss_score=9.8,
                         cvss_vector="CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
                         location=test_url,
-                        evidence="SQL error message",
-                        remediation="Use parameterized queries",
+                        evidence="SQL error message in response",
+                        remediation="Use parameterized queries and input validation",
                         cwe_id="CWE-89",
-                        owasp_category="A03:2021",
+                        owasp_category="A03:2021 - Injection",
                         mitre_techniques=["T1190"]
                     )
                     vulnerabilities.append(vuln)
             except:
                 pass
             
-            # Check XSS
+            # Check for XSS
             test_xss_url = f"https://{url}/?q=<script>alert(1)</script>"
             try:
                 xss_resp = requests.get(test_xss_url, headers=headers, timeout=5, verify=False)
                 if "<script>alert(1)</script>" in xss_resp.text:
                     vuln = Vulnerability(
                         name="Cross-Site Scripting (XSS)",
-                        description="Reflected XSS vulnerability",
+                        description="Reflected XSS vulnerability detected",
                         severity="HIGH",
                         cvss_score=6.1,
                         cvss_vector="CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N",
                         location=test_xss_url,
-                        evidence="Script tag reflected",
-                        remediation="Implement output encoding",
+                        evidence="Script tag reflected in response without encoding",
+                        remediation="Implement output encoding and CSP headers",
                         cwe_id="CWE-79",
-                        owasp_category="A03:2021",
+                        owasp_category="A03:2021 - Injection",
                         mitre_techniques=["T1189"]
                     )
                     vulnerabilities.append(vuln)
@@ -887,27 +1052,22 @@ class ActiveReconEngine:
         
         return vulnerabilities
 
-'''
-
-print("KODUN İLK YARISI HAZIR")
-print("=" * 60)
-print(f"Karakter sayısı: {len(fixed_code)}")
-
-# Kodun ikinci yarısı
-
-second_half = '''
 # ════════════════════════════════════════════════════════════════════════════
-# SECTION 6: THREAT MODELING ENGINE
+# SECTION 6: THREAT MODELING ENGINE (STRIDE + MITRE ATT&CK)
 # ════════════════════════════════════════════════════════════════════════════
 
 class ThreatModelingEngine:
+    """Advanced threat modeling"""
+    
     def __init__(self):
         self.threats: List[Dict] = []
         self.attack_paths: List[AttackPath] = []
     
     def analyze_web_app(self, recon_data: Dict) -> List[ThreatVector]:
+        """Map reconnaissance to threats"""
         threat_vectors = []
         
+        # Forms = injection vectors
         for form in recon_data.get("forms", []):
             risk = 7.5
             techniques = ["T1565.001", "T1598.003"]
@@ -927,6 +1087,7 @@ class ThreatModelingEngine:
                 evidence=f"Form method: {form.get('method')}, Fields: {len(form.get('fields', []))}"
             ))
         
+        # JavaScript = gadget chains
         for js_file in recon_data.get("js_files", []):
             threat_vectors.append(ThreatVector(
                 category="js_gadget",
@@ -939,6 +1100,7 @@ class ThreatModelingEngine:
                 evidence="Client-side code analysis"
             ))
         
+        # API endpoints = information disclosure
         for endpoint in recon_data.get("endpoints", []):
             if isinstance(endpoint, dict):
                 path = endpoint.get("path", "")
@@ -958,12 +1120,13 @@ class ThreatModelingEngine:
                 location=path,
                 risk_score=risk,
                 techniques=["T1526"],
-                description=f"API endpoint: {path} (Status: {status})",
+                description=f"API endpoint discovered: {path} (Status: {status})",
                 cvss_score=risk,
                 cwe_id="CWE-200",
                 evidence=f"HTTP {status}"
             ))
         
+        # Security headers missing
         security_score = recon_data.get("security_headers", {}).get("score", 100)
         if security_score < 50:
             threat_vectors.append(ThreatVector(
@@ -980,30 +1143,34 @@ class ThreatModelingEngine:
         return threat_vectors
     
     def build_attack_paths(self, threat_vectors: List[ThreatVector], technologies: Dict) -> List[AttackPath]:
+        """Generate attack chains"""
         paths = []
         
+        # Generic attack path
         paths.append(AttackPath(
             entry_point="Public web form or API endpoint",
             intermediate_steps=[
-                "Reconnaissance",
-                "Vulnerability identification",
+                "Reconnaissance (technology fingerprinting)",
+                "Vulnerability identification (SQLi, XSS, CSRF)",
                 "Exploitation",
-                "Data exfiltration"
+                "Data exfiltration or lateral movement"
             ],
-            objective="Unauthorized access",
+            objective="Unauthorized access / Data breach",
             risk_level="CRITICAL",
             complexity=0.6,
             mitre_techniques=["T1595", "T1190", "T1567"]
         ))
         
+        # WordPress-specific
         cms_list = technologies.get("cms", [])
         if "WordPress" in cms_list:
             paths.append(AttackPath(
-                entry_point="WordPress admin",
+                entry_point="WordPress admin panel or vulnerable plugin",
                 intermediate_steps=[
-                    "Plugin enumeration",
-                    "CVE exploitation",
-                    "RCE via plugin upload"
+                    "Plugin enumeration via wp-content/plugins/",
+                    "Known CVE exploitation (plugin vulnerabilities)",
+                    "Plugin upload for RCE (if authenticated)",
+                    "Server compromise via wp-config.php access"
                 ],
                 objective="Remote Code Execution",
                 risk_level="CRITICAL",
@@ -1011,24 +1178,44 @@ class ThreatModelingEngine:
                 mitre_techniques=["T1595", "T1190", "T1059", "T1078"]
             ))
         
+        # API-specific
         api_endpoints = [v for v in threat_vectors if v.category == "api_endpoint"]
         if api_endpoints:
             paths.append(AttackPath(
                 entry_point="Exposed API endpoint",
                 intermediate_steps=[
-                    "API enumeration",
-                    "Auth bypass",
-                    "IDOR exploitation"
+                    "API endpoint enumeration",
+                    "Authentication bypass or weak authentication",
+                    "IDOR (Insecure Direct Object Reference)",
+                    "Data exfiltration via API"
                 ],
-                objective="Data exfiltration",
+                objective="Unauthorized data access",
                 risk_level="HIGH",
                 complexity=0.5,
                 mitre_techniques=["T1526", "T1078", "T1567"]
             ))
         
+        # JavaScript/Secret exposure
+        js_threats = [v for v in threat_vectors if v.category == "js_gadget"]
+        if js_threats:
+            paths.append(AttackPath(
+                entry_point="Hardcoded secrets in JavaScript",
+                intermediate_steps=[
+                    "JavaScript analysis for API keys/secrets",
+                    "Credential harvesting",
+                    "API access with stolen credentials",
+                    "Data breach or system compromise"
+                ],
+                objective="Credential theft",
+                risk_level="HIGH",
+                complexity=0.3,
+                mitre_techniques=["T1552", "T1078", "T1567"]
+            ))
+        
         return paths
     
     def generate_stride_report(self, recon_data: Dict) -> Dict:
+        """Generate STRIDE threat model"""
         stride_report = {}
         
         for threat_category, threat_info in STRIDE_THREATS.items():
@@ -1040,40 +1227,93 @@ class ThreatModelingEngine:
                 "risk_level": "LOW"
             }
             
+            # Match with found vulnerabilities
             if "forms" in recon_data and len(recon_data["forms"]) > 0:
                 if threat_category == "Tampering":
-                    stride_report[threat_category]["potential_impacts"].append("SQL Injection")
+                    stride_report[threat_category]["potential_impacts"].append(
+                        "SQL Injection in form fields"
+                    )
                     stride_report[threat_category]["affected_components"].append("Database")
                     stride_report[threat_category]["risk_level"] = "CRITICAL"
                 
                 if threat_category == "InformationDisclosure":
-                    stride_report[threat_category]["potential_impacts"].append("Data exposure")
+                    stride_report[threat_category]["potential_impacts"].append(
+                        "Sensitive data exposure through form manipulation"
+                    )
                     stride_report[threat_category]["risk_level"] = "HIGH"
             
             if "endpoints" in recon_data and len(recon_data["endpoints"]) > 0:
                 if threat_category == "InformationDisclosure":
-                    stride_report[threat_category]["potential_impacts"].append("API data exposure")
+                    stride_report[threat_category]["potential_impacts"].append(
+                        "Sensitive data exposed via API endpoints"
+                    )
                     stride_report[threat_category]["affected_components"].append("API")
                     stride_report[threat_category]["risk_level"] = "HIGH"
             
+            if "js_files" in recon_data and len(recon_data["js_files"]) > 0:
+                if threat_category == "InformationDisclosure":
+                    stride_report[threat_category]["potential_impacts"].append(
+                        "Hardcoded secrets in client-side JavaScript"
+                    )
+                    stride_report[threat_category]["risk_level"] = "HIGH"
+            
             if "security_headers" in recon_data:
                 score = recon_data["security_headers"].get("score", 100)
                 if score < 50:
                     if threat_category == "Spoofing":
-                        stride_report[threat_category]["potential_impacts"].append("Session hijacking")
+                        stride_report[threat_category]["potential_impacts"].append(
+                            "Session hijacking due to missing security headers"
+                        )
+                        stride_report[threat_category]["risk_level"] = "MEDIUM"
+                    
+                    if threat_category == "Tampering":
+                        stride_report[threat_category]["potential_impacts"].append(
+                            "Clickjacking attacks (missing X-Frame-Options)"
+                        )
                         stride_report[threat_category]["risk_level"] = "MEDIUM"
         
         return stride_report
+    
+    def calculate_cvss_score(self, vulnerability: Vulnerability) -> Dict:
+        """Calculate CVSS v3.1 score"""
+        return {
+            "base_score": vulnerability.cvss_score,
+            "vector": vulnerability.cvss_vector,
+            "severity": self._get_severity(vulnerability.cvss_score),
+            "impact_score": self._calculate_impact(vulnerability.cvss_vector),
+            "exploitability_score": self._calculate_exploitability(vulnerability.cvss_vector)
+        }
+    
+    def _get_severity(self, score: float) -> str:
+        if score >= 9.0:
+            return "CRITICAL"
+        elif score >= 7.0:
+            return "HIGH"
+        elif score >= 4.0:
+            return "MEDIUM"
+        else:
+            return "LOW"
+    
+    def _calculate_impact(self, vector: str) -> float:
+        # Simplified calculation
+        return 0.0
+    
+    def _calculate_exploitability(self, vector: str) -> float:
+        # Simplified calculation
+        return 0.0
 
 # ════════════════════════════════════════════════════════════════════════════
-# SECTION 7: ATTACK GRAPH VISUALIZATION
+# SECTION 7: ATTACK GRAPH VISUALIZATION (ENHANCED)
 # ════════════════════════════════════════════════════════════════════════════
 
 class AttackGraphEngine:
+    """Advanced attack surface visualization"""
+    
     @staticmethod
     def create_enhanced_attack_graph(threat_vectors: List[ThreatVector], 
                                      attack_paths: List[AttackPath],
                                      vulnerabilities: List[Vulnerability] = None) -> Dict:
+        """Build graph with threat vectors and attack paths"""
         
         nodes = ["Attacker", "Internet", "Target Domain"]
         edges = [("Attacker", "Internet"), ("Internet", "Target Domain")]
@@ -1083,7 +1323,8 @@ class AttackGraphEngine:
             "Target Domain": {"type": "asset", "risk": 7, "layer": 2}
         }
         
-        for i, vector in enumerate(threat_vectors[:15]):
+        # Add threat vectors as nodes
+        for i, vector in enumerate(threat_vectors[:15]):  # Increased limit
             node_name = f"{vector.category.replace('_', ' ').title()}_{i+1}"
             nodes.append(node_name)
             edges.append(("Target Domain", node_name))
@@ -1096,9 +1337,10 @@ class AttackGraphEngine:
                 "cwe": vector.cwe_id
             }
         
+        # Add vulnerabilities as nodes
         if vulnerabilities:
             for i, vuln in enumerate(vulnerabilities[:10]):
-                node_name = f"Vuln: {vuln.name[:20]}"
+                node_name = f"Vuln: {vuln.name[:20]}..."
                 nodes.append(node_name)
                 edges.append(("Target Domain", node_name))
                 node_info[node_name] = {
@@ -1121,9 +1363,12 @@ class AttackGraphEngine:
     
     @staticmethod
     def visualize_attack_graph_plotly(graph_data: Dict) -> go.Figure:
+        """Create interactive Plotly visualization"""
+        
         G = nx.DiGraph()
         G.add_edges_from(graph_data["edges"])
         
+        # Use hierarchical layout
         pos = {}
         layers = defaultdict(list)
         
@@ -1136,6 +1381,7 @@ class AttackGraphEngine:
             for i, node in enumerate(nodes):
                 pos[node] = (layer * 3, (i - y_offset/2) * 2)
         
+        # Edge traces
         edge_x, edge_y = [], []
         for edge in G.edges():
             x0, y0 = pos[edge[0]]
@@ -1151,6 +1397,7 @@ class AttackGraphEngine:
             name='Attack Path'
         )
         
+        # Node traces with risk coloring
         node_x, node_y, node_text, node_color, node_size, hover_text = [], [], [], [], [], []
         
         for node in G.nodes():
@@ -1163,6 +1410,7 @@ class AttackGraphEngine:
             risk = node_info.get("risk", 5)
             node_type = node_info.get("type", "unknown")
             
+            # Color by type and risk
             if node_type == "attacker":
                 node_color.append('#ff0000')
             elif node_type == "network":
@@ -1172,18 +1420,20 @@ class AttackGraphEngine:
             elif node_type == "exploit":
                 node_color.append('#ff00ff')
             else:
+                # Color by risk
                 if risk >= 9:
-                    node_color.append('#ff0000')
+                    node_color.append('#ff0000')  # Red - Critical
                 elif risk >= 7:
-                    node_color.append('#ff7700')
+                    node_color.append('#ff7700')  # Orange - High
                 elif risk >= 4:
-                    node_color.append('#ffcc00')
+                    node_color.append('#ffcc00')  # Yellow - Medium
                 else:
-                    node_color.append('#00ff00')
+                    node_color.append('#00ff00')  # Green - Low
             
             size = 40 if node_type in ["attacker", "asset"] else 30 + (risk * 1.5)
             node_size.append(size)
             
+            # Hover text
             hover_info = f"<b>{node}</b><br>Type: {node_type}<br>Risk: {risk}"
             if node_info.get("cvss"):
                 hover_info += f"<br>CVSS: {node_info['cvss']}"
@@ -1211,7 +1461,7 @@ class AttackGraphEngine:
         fig = go.Figure(data=[edge_trace, node_trace])
         fig.update_layout(
             title={
-                'text': 'Advanced Attack Surface Graph',
+                'text': '🎯 Advanced Attack Surface Graph',
                 'font': {'size': 24, 'color': '#ff0000'},
                 'x': 0.5
             },
@@ -1227,7 +1477,7 @@ class AttackGraphEngine:
                 dict(
                     x=0.02, y=0.98,
                     xref='paper', yref='paper',
-                    text='Critical Risk<br>High Risk<br>Medium Risk<br>Low Risk',
+                    text='🔴 Critical Risk<br>🟠 High Risk<br>🟡 Medium Risk<br>🟢 Low Risk',
                     showarrow=False,
                     font=dict(size=12, color='white'),
                     bgcolor='rgba(0,0,0,0.5)',
@@ -1238,90 +1488,382 @@ class AttackGraphEngine:
         )
         
         return fig
+    
+    @staticmethod
+    def create_risk_heatmap(threat_vectors: List[ThreatVector]) -> go.Figure:
+        """Create risk heatmap"""
+        categories = defaultdict(list)
+        for tv in threat_vectors:
+            categories[tv.category].append(tv.risk_score)
+        
+        if not categories:
+            return go.Figure()
+        
+        cat_names = list(categories.keys())
+        avg_risks = [sum(scores)/len(scores) for scores in categories.values()]
+        counts = [len(scores) for scores in categories.values()]
+        
+        fig = go.Figure(data=[
+            go.Bar(
+                x=cat_names,
+                y=avg_risks,
+                text=counts,
+                textposition='auto',
+                marker_color=['#ff0000' if r >= 7 else '#ff7700' if r >= 4 else '#ffff00' for r in avg_risks]
+            )
+        ])
+        
+        fig.update_layout(
+            title='Risk Distribution by Category',
+            xaxis_title='Threat Category',
+            yaxis_title='Average Risk Score',
+            plot_bgcolor='#1a1a1a',
+            paper_bgcolor='#1a1a1a',
+            font=dict(color='#ffffff')
+        )
+        
+        return fig
+
+
+═══════════════════════════════════════════════════════════════════════════════
+    PRIVATE RED TEAM WEB RECONNAISSANCE FRAMEWORK v3.0 - PART 2
+    ─────────────────────────────────────────────────────────────────────────
+    Bölümler: 8-10 (Reporting Engine, Main Orchestrator, Gradio Interface)
+═══════════════════════════════════════════════════════════════════════════════
+"""
+
+# Part 1'deki importları ve sınıfları tekrar etmek için:
+# Bu dosyayı çalıştırmadan önce Part 1'i import edin veya birleştirin
 
 # ════════════════════════════════════════════════════════════════════════════
-# SECTION 8: REPORTING ENGINE
+# SECTION 8: COMPREHENSIVE REPORTING ENGINE
 # ════════════════════════════════════════════════════════════════════════════
 
 class ReportingEngine:
+    """Professional security assessment reporting"""
+    
     @staticmethod
     def generate_assessment_report(target: str, recon_data: Dict, threat_vectors: List[ThreatVector],
                                    attack_paths: List[AttackPath], stride_report: Dict,
                                    vulnerabilities: List[Vulnerability] = None) -> str:
+        """Generate comprehensive assessment report"""
         
         vulns = vulnerabilities or []
         
-        lines = []
-        lines.append("=" * 80)
-        lines.append("PROFESSIONAL SECURITY ASSESSMENT REPORT")
-        lines.append("[CONFIDENTIAL] - PRIVATE SPACE EDITION v3.0")
-        lines.append("=" * 80)
-        lines.append("")
-        lines.append("EXECUTIVE SUMMARY")
-        lines.append("-" * 80)
-        lines.append(f"Target: {target}")
-        lines.append(f"Assessment Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        lines.append(f"Framework: Red Team Framework v3.0")
-        lines.append("")
-        
-        critical = len([t for t in vulns if t.cvss_score >= 9.0])
-        high = len([t for t in vulns if 7.0 <= t.cvss_score < 9.0])
-        medium = len([t for t in vulns if 4.0 <= t.cvss_score < 7.0])
-        low = len([t for t in vulns if t.cvss_score < 4.0])
-        
-        lines.append("RISK OVERVIEW")
-        lines.append("-" * 80)
-        lines.append(f"Critical Findings: {critical}")
-        lines.append(f"High Findings: {high}")
-        lines.append(f"Medium Findings: {medium}")
-        lines.append(f"Low Findings: {low}")
-        lines.append("")
-        
-        overall_risk = "CRITICAL" if critical > 0 else "HIGH" if high > 0 else "MEDIUM"
-        lines.append(f"Overall Risk Level: {overall_risk}")
-        lines.append("")
-        
-        lines.append("TECHNOLOGIES DETECTED")
-        lines.append("-" * 80)
-        lines.append(f"Web Server: {recon_data.get('technologies', {}).get('web_server', 'Unknown')}")
-        lines.append(f"CMS: {', '.join(recon_data.get('technologies', {}).get('cms', ['None']))}")
-        lines.append(f"Frameworks: {', '.join(recon_data.get('technologies', {}).get('frameworks', ['None']))}")
-        lines.append("")
-        
-        lines.append("VULNERABILITIES")
-        lines.append("-" * 80)
+        report = f"""
+╔════════════════════════════════════════════════════════════════════════╗
+║          PROFESSIONAL SECURITY ASSESSMENT REPORT                      ║
+║                        [CONFIDENTIAL]                                 ║
+║                    PRIVATE SPACE EDITION v3.0                         ║
+╚════════════════════════════════════════════════════════════════════════╝
+
+EXECUTIVE SUMMARY
+─────────────────────────────────────────────────────────────────────────
+Target: {target}
+Assessment Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+Assessed By: Red Team Framework v3.0 (Private Space)
+Classification: CONFIDENTIAL
+Assessment Type: Comprehensive Web Application Security Assessment
+
+RISK OVERVIEW
+─────────────────────────────────────────────────────────────────────────
+Critical Findings: {len([t for t in vulns if t.cvss_score >= 9.0])}
+High Findings: {len([t for t in vulns if 7.0 <= t.cvss_score < 9.0])}
+Medium Findings: {len([t for t in vulns if 4.0 <= t.cvss_score < 7.0])}
+Low Findings: {len([t for t in vulns if t.cvss_score < 4.0])}
+
+Overall Risk Level: {"🔴 CRITICAL" if len([t for t in vulns if t.cvss_score >= 9.0]) > 0 else "🟠 HIGH" if len([t for t in vulns if t.cvss_score >= 7.0]) > 0 else "🟡 MEDIUM"}
+
+ATTACK SURFACE
+─────────────────────────────────────────────────────────────────────────
+Technologies Identified: {len(recon_data.get('technologies', {}).get('cms', [])) + len(recon_data.get('technologies', {}).get('frameworks', []))}
+API Endpoints: {len(recon_data.get('endpoints', []))}
+Forms Discovered: {len(recon_data.get('forms', []))}
+Subdomains Found: {len(recon_data.get('subdomains', []))}
+JavaScript Files Analyzed: {len(recon_data.get('js_files', []))}
+Security Headers Score: {recon_data.get('security_headers', {}).get('score', 0):.1f}%
+
+TECHNOLOGIES DETECTED
+─────────────────────────────────────────────────────────────────────────
+Web Server: {recon_data.get('technologies', {}).get('web_server', 'Unknown')}
+CMS: {', '.join(recon_data.get('technologies', {}).get('cms', ['None detected']))}
+Frameworks: {', '.join(recon_data.get('technologies', {}).get('frameworks', ['None detected']))}
+JavaScript Libraries: {', '.join(recon_data.get('technologies', {}).get('javascript', ['None detected']))}
+CDN: {', '.join(recon_data.get('technologies', {}).get('cdn', ['None detected']))}
+
+VULNERABILITY DETAILS
+──────────────────────��──────────────────────────────────────────────────
+"""
+        
         for i, vuln in enumerate(vulns, 1):
-            lines.append(f"[{i}] {vuln.name}")
-            lines.append(f"    Severity: {vuln.severity}")
-            lines.append(f"    CVSS: {vuln.cvss_score}")
-            lines.append(f"    Location: {vuln.location}")
-            lines.append(f"    CWE: {vuln.cwe_id or 'N/A'}")
-            lines.append("")
-        
-        lines.append("RECOMMENDATIONS")
-        lines.append("-" * 80)
-        lines.append("1. IMMEDIATE (Critical):")
-        lines.append("   - Patch critical vulnerabilities")
-        lines.append("   - Disable exposed sensitive files")
-        lines.append("   - Enable WAF rules")
-        lines.append("")
-        lines.append("2. SHORT-TERM (High):")
-        lines.append("   - Update outdated technologies")
-        lines.append("   - Implement input validation")
-        lines.append("   - Enable security headers")
-        lines.append("")
-        
-        lines.append("=" * 80)
-        lines.append("END OF REPORT")
-        lines.append("=" * 80)
-        
-        return "\\n".join(lines)
+            report += f"""
+[{i}] {vuln.name}
+    Severity: {vuln.severity}
+    CVSS Score: {vuln.cvss_score}
+    CVSS Vector: {vuln.cvss_vector}
+    CWE ID: {vuln.cwe_id or 'N/A'}
+    OWASP Category: {vuln.owasp_category or 'N/A'}
+    Location: {vuln.location}
+    
+    Description:
+    {vuln.description}
+    
+    Evidence:
+    {vuln.evidence}
+    
+    Remediation:
+    {vuln.remediation}
+    
+    MITRE ATT&CK Techniques: {', '.join(vuln.mitre_techniques)}
+    
+    {'─' * 70}
+"""
+        
+        report += f"""
+
+THREAT VECTORS
+─────────────────────────────────────────────────────────────────────────
+"""
+        
+        for i, vector in enumerate(threat_vectors[:10], 1):
+            report += f"""
+{i}. [{vector.category.upper()}]
+   Location: {vector.location}
+   Risk Score: {vector.risk_score}/10
+   CVSS Score: {vector.cvss_score if vector.cvss_score else 'N/A'}
+   CWE ID: {vector.cwe_id or 'N/A'}
+   MITRE ATT&CK: {', '.join(vector.techniques)}
+   Description: {vector.description}
+   Evidence: {vector.evidence or 'N/A'}
+"""
+        
+        report += f"""
+
+STRIDE THREAT MODEL
+─────────────────────────────────────────────────────────────────────────
+"""
+        
+        for threat_type, threat_data in stride_report.items():
+            report += f"""
+{threat_type}:
+  Risk Level: {threat_data.get('risk_level', 'LOW')}
+  Description: {threat_data['description']}
+  Potential Impacts:
+"""
+            for impact in threat_data.get('potential_impacts', []):
+                report += f"    • {impact}\\n"
+            
+            report += f"  Affected Components:\\n"
+            for component in threat_data.get('affected_components', []):
+                report += f"    • {component}\\n"
+            
+            report += f"  Mitigations: {', '.join(threat_data['mitigations'])}\\n"
+        
+        report += f"""
+
+ATTACK PATH ANALYSIS
+─────────────────────────────────────────────────────────────────────────
+"""
+        
+        for i, path in enumerate(attack_paths, 1):
+            report += f"""
+Attack Path {i}: {path.objective}
+  Entry Point: {path.entry_point}
+  Complexity: {path.complexity}/1.0
+  Risk Level: {path.risk_level}
+  MITRE ATT&CK Techniques: {', '.join(path.mitre_techniques)}
+  Steps:
+"""
+            for step in path.intermediate_steps:
+                report += f"    → {step}\\n"
+        
+        report += """
+
+RECOMMENDATIONS
+─────────────────────────────────────────────────────────────────────────
+1. IMMEDIATE (Critical - Fix within 24 hours):
+   • Patch all critical CVEs (CVSS 9.0+)
+   • Disable exposed sensitive files (.env, .git)
+   • Enable WAF rules for SQL injection protection
+   • Implement rate limiting on authentication endpoints
+   • Enable security headers (CSP, HSTS, X-Frame-Options)
+
+2. SHORT-TERM (High - Fix within 1 week):
+   • Update outdated technologies and frameworks
+   • Implement input validation on all forms
+   • Enable HTTPS enforcement (HSTS)
+   • Setup security monitoring and alerting
+   • Conduct code review for injection vulnerabilities
+
+3. MEDIUM-TERM (Medium - Fix within 1 month):
+   • Implement Web Application Firewall (WAF)
+   • Conduct penetration testing
+   • Implement secure session management
+   • Setup vulnerability disclosure program
+   • Regular security training for developers
+
+4. LONG-TERM (Ongoing):
+   • Implement Secure SDLC
+   • Regular automated security scanning
+   • Bug bounty program
+   • Incident response planning
+   • Compliance auditing (OWASP ASVS)
+
+COMPLIANCE MAPPING
+─────────────────────────────────────────────────────────────────────────
+OWASP Top 10 2021:
+"""
+        
+        owasp_categories = defaultdict(list)
+        for vuln in vulns:
+            if vuln.owasp_category:
+                owasp_categories[vuln.owasp_category].append(vuln.name)
+        
+        for category, vuln_list in owasp_categories.items():
+            report += f"  {category}: {len(vuln_list)} findings\\n"
+            for v in vuln_list[:3]:  # Limit to 3 per category
+                report += f"    • {v}\\n"
+        
+        report += f"""
+
+MITRE ATT&CK MAPPING
+─────────────────────────────────────────────────────────────────────────
+"""
+        
+        mitre_techniques = set()
+        for vuln in vulns:
+            mitre_techniques.update(vuln.mitre_techniques)
+        for path in attack_paths:
+            mitre_techniques.update(path.mitre_techniques)
+        
+        for tech in sorted(mitre_techniques):
+            report += f"  • {tech}"
+            # Add technique name if available
+            for category, techniques in MITRE_TECHNIQUES.items():
+                if tech in techniques:
+                    report += f" - {techniques[tech]}"
+                    break
+            report += "\\n"
+        
+        report += f"""
+
+METHODOLOGY
+─────────────────────────────────────────────────────────────────────────
+1. Passive OSINT (Non-intrusive):
+   • DNS record enumeration (A, AAAA, MX, NS, TXT)
+   • SSL/TLS certificate analysis
+   • Certificate Transparency log queries (crt.sh)
+   • GitHub reconnaissance
+   • Wayback Machine historical data
+   • Shodan/Censys intelligence (if API available)
+
+2. Active Reconnaissance (Low impact):
+   • HTTP header analysis
+   • Technology fingerprinting
+   • Endpoint discovery
+   • Form analysis
+   • JavaScript endpoint extraction
+   • Security headers assessment
+
+3. Vulnerability Analysis:
+   • Pattern-based detection
+   • Configuration weakness identification
+   • Information disclosure checks
+   • Injection vulnerability probes (safe)
+
+4. Threat Modeling:
+   • STRIDE analysis
+   • Attack path generation
+   • MITRE ATT&CK mapping
+   • Risk scoring (CVSS v3.1)
+
+5. Reporting:
+   • Executive summary
+   • Technical findings
+   • Remediation guidance
+   • Compliance mapping
+
+TOOLS & TECHNIQUES
+─────────────────────────────────────────────────────────────────────────
+• Framework: Red Team Recon Framework v3.0
+• Standards: OWASP Testing Guide, PTES, CVSS v3.1
+• Threat Model: STRIDE, MITRE ATT&CK v12
+• Visualization: NetworkX, Plotly
+• OSINT: DNS, SSL, crt.sh, GitHub, Wayback
+
+LIMITATIONS
+─────────────────────────────────────────────────────────────────────────
+• Assessment limited to authorized scope
+• No active exploitation performed
+• Rate limiting may affect scan completeness
+• Some checks require manual verification
+• API keys needed for full OSINT features
+
+═══════════════════════════════════════════════════════════════════════════
+Report Generated: {datetime.now().isoformat()}
+Classification: CONFIDENTIAL - DO NOT DISTRIBUTE
+Private Space Assessment - Authorized Testing Only
+═══════════════════════════════════════════════════════════════════════════
+"""
+        return report
+    
+    @staticmethod
+    def generate_executive_summary(target: str, recon_data: Dict, vulnerabilities: List[Vulnerability]) -> str:
+        """Generate executive summary for C-level"""
+        
+        critical = len([v for v in vulnerabilities if v.cvss_score >= 9.0])
+        high = len([v for v in vulnerabilities if 7.0 <= v.cvss_score < 9.0])
+        medium = len([v for v in vulnerabilities if 4.0 <= v.cvss_score < 7.0])
+        
+        summary = f"""
+EXECUTIVE SUMMARY
+═══════════════════════════════════════════════════════════════════════════
+
+Target Organization: {target}
+Assessment Period: {datetime.now().strftime('%Y-%m-%d')}
+Overall Risk Rating: {"CRITICAL" if critical > 0 else "HIGH" if high > 0 else "MEDIUM"}
+
+KEY FINDINGS:
+• {critical} Critical vulnerabilities requiring immediate attention
+• {high} High-risk vulnerabilities to address within 1 week
+• {medium} Medium-risk vulnerabilities for next sprint
+
+BUSINESS IMPACT:
+"""
+        
+        if critical > 0:
+            summary += "• CRITICAL: Immediate risk of data breach or system compromise\\n"
+        if high > 0:
+            summary += "• HIGH: Significant risk to business operations and data integrity\\n"
+        
+        summary += f"""
+IMMEDIATE ACTIONS REQUIRED:
+1. Convene security incident response team
+2. Prioritize critical vulnerability remediation
+3. Review and enhance monitoring capabilities
+4. Consider temporary WAF rules for protection
+
+ESTIMATED REMEDIATION EFFORT:
+• Critical issues: 1-3 days
+• High issues: 1-2 weeks
+• Full remediation: 1-3 months
+
+RECOMMENDED INVESTMENT:
+• Immediate security patches: $5K-$15K
+• Security infrastructure improvements: $25K-$75K
+• Ongoing security program: $100K-$300K annually
+
+═══════════════════════════════════════════════════════════════════════════
+"""
+        return summary
 
 # ════════════════════════════════════════════════════════════════════════════
 # SECTION 9: MAIN ORCHESTRATOR
 # ════════════════════════════════════════════════════════════════════════════
 
 class RedTeamReconFramework:
+    """Master orchestrator"""
+    
     def __init__(self):
         self.stealth_config = StealthConfig(ThreatLevel.MEDIUM)
         self.passive_engine = PassiveOSINTEngine(self.stealth_config)
@@ -1331,6 +1873,8 @@ class RedTeamReconFramework:
         self.reporting = ReportingEngine()
     
     async def execute_assessment(self, target_url: str) -> Dict:
+        """Execute full security assessment"""
+        
         results = {
             "target": target_url,
             "timestamp": datetime.now().isoformat(),
@@ -1349,7 +1893,8 @@ class RedTeamReconFramework:
         }
         
         try:
-            print("[1/6] Passive OSINT...")
+            # PHASE 1: Passive OSINT
+            print("[1/5] Passive OSINT gathering...")
             passive_data = await self.passive_engine.gather_dns_intel(target_url)
             results["subdomains"] = passive_data.get("subdomains", [])
             
@@ -1360,18 +1905,22 @@ class RedTeamReconFramework:
                     for san in ssl_data["subjectAltNames"]
                 ])
             
+            # Certificate Transparency logs
             ct_subdomains = await self.passive_engine.crt_sh_lookup(target_url)
             for sub in ct_subdomains:
                 if sub not in [s.get("subdomain") for s in results["subdomains"]]:
                     results["subdomains"].append({"subdomain": sub, "ip": "from_ct"})
             
+            # GitHub recon
             github_data = await self.passive_engine.github_reconnaissance(target_url.replace(".com", ""))
             results["github_intel"] = github_data
             
+            # Wayback Machine
             wayback_urls = await self.passive_engine.wayback_machine_lookup(target_url)
             results["historical_urls"] = wayback_urls
             
-            print("[2/6] Active reconnaissance...")
+            # PHASE 2: Active Reconnaissance
+            print("[2/5] Active reconnaissance...")
             technologies = await self.active_engine.fingerprint_technologies(target_url)
             results["technologies"] = technologies
             
@@ -1387,11 +1936,13 @@ class RedTeamReconFramework:
             security_headers = await self.active_engine.analyze_security_headers(target_url)
             results["security_headers"] = security_headers
             
-            print("[3/6] Vulnerability analysis...")
+            # PHASE 3: Vulnerability Analysis
+            print("[3/5] Vulnerability analysis...")
             vulnerabilities = await self.active_engine.check_common_vulnerabilities(target_url)
             results["vulnerabilities"] = [asdict(v) for v in vulnerabilities]
             
-            print("[4/6] Threat modeling...")
+            # PHASE 4: Threat Modeling
+            print("[4/5] Threat modeling...")
             threat_vectors = self.threat_model.analyze_web_app(results)
             results["threat_vectors"] = [asdict(tv) for tv in threat_vectors]
             
@@ -1401,19 +1952,21 @@ class RedTeamReconFramework:
             stride_analysis = self.threat_model.generate_stride_report(results)
             results["stride_analysis"] = stride_analysis
             
-            print("[5/6] Attack graph...")
+            # PHASE 5: Attack Graph
+            print("[5/5] Generating attack graph...")
             graph_data = self.graph_engine.create_enhanced_attack_graph(
                 threat_vectors, attack_paths, vulnerabilities
             )
             results["graph_data"] = graph_data
             
-            print("[6/6] Reporting...")
+            # PHASE 6: Reporting
+            print("[6/6] Generating report...")
             report = self.reporting.generate_assessment_report(
                 target_url, results, threat_vectors, attack_paths, stride_analysis, vulnerabilities
             )
             results["report"] = report
             
-            print("Assessment complete!")
+            print("✅ Assessment complete!")
             
         except Exception as e:
             results["error"] = str(e)
@@ -1423,21 +1976,26 @@ class RedTeamReconFramework:
         
         return results
 
-# ════════════════════════════════════════════════════════════════════════════
+════════════════════════════════════════════════════════════════════════════
 # SECTION 10: GRADIO INTERFACE
 # ════════════════════════════════════════════════════════════════════════════
 
+# Initialize framework
 framework = RedTeamReconFramework()
 
 def run_assessment(target_url: str, threat_level: str, progress=gr.Progress(track_tqdm=True)):
+    """Gradio wrapper function"""
+    
     try:
         if not target_url:
-            return "Error: Please enter a target domain", "{}", go.Figure(), "No report"
+            return "Error: Please enter a target domain", "{}", go.Figure(), "No report generated"
         
+        # Clean target URL
         target_url = target_url.replace("https://", "").replace("http://", "").strip("/")
         
-        progress(0.1, desc="Validating target...")
+        progress(0.1, desc="🔍 Validating target...")
         
+        # Update threat level
         threat_map = {
             "Low (Stealthy)": ThreatLevel.LOW,
             "Medium (Balanced)": ThreatLevel.MEDIUM,
@@ -1445,56 +2003,67 @@ def run_assessment(target_url: str, threat_level: str, progress=gr.Progress(trac
         }
         framework.stealth_config = StealthConfig(threat_map.get(threat_level, ThreatLevel.MEDIUM))
         
-        progress(0.2, desc="Starting passive OSINT...")
-        progress(0.4, desc="Running active reconnaissance...")
-        progress(0.6, desc="Analyzing threats...")
-        progress(0.8, desc="Generating attack graph...")
+        progress(0.2, desc="🕵️ Starting passive OSINT...")
+        progress(0.4, desc="📡 Running active reconnaissance...")
+        progress(0.6, desc="🎯 Analyzing threats...")
+        progress(0.8, desc="📊 Generating attack graph...")
         
+        # Run assessment
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         results = loop.run_until_complete(framework.execute_assessment(target_url))
         loop.close()
         
-        progress(0.95, desc="Finalizing report...")
+        progress(0.95, desc="📝 Finalizing report...")
         
+        # Create visualization
         if results.get("graph_data"):
             fig = framework.graph_engine.visualize_attack_graph_plotly(results["graph_data"])
         else:
             fig = go.Figure()
         
+        # Calculate stats
         vulns = results.get("vulnerabilities", [])
         critical = len([v for v in vulns if v.get("cvss_score", 0) >= 9.0])
         high = len([v for v in vulns if 7.0 <= v.get("cvss_score", 0) < 9.0])
         medium = len([v for v in vulns if 4.0 <= v.get("cvss_score", 0) < 7.0])
         
-        summary_text = f"""
-## Assessment Complete
+        # Summary
+        summary = f"""
+## 🔴 ASSESSMENT COMPLETE
 
 **Target:** {target_url}  
 **Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}  
 **Threat Level:** {threat_level}
 
-### Statistics
-- Subdomains: {len(results.get('subdomains', []))}
-- Technologies: {len(results.get('technologies', {}).get('cms', [])) + len(results.get('technologies', {}).get('frameworks', []))}
-- Endpoints: {len(results.get('endpoints', []))}
-- Forms: {len(results.get('forms', []))}
-- Threat Vectors: {len(results.get('threat_vectors', []))}
-- Attack Paths: {len(results.get('attack_paths', []))}
-
-### Vulnerabilities
-- Critical: {critical}
-- High: {high}
-- Medium: {medium}
-
-### Technologies
-- Web Server: {results.get('technologies', {}).get('web_server', 'Unknown')}
-- CMS: {', '.join(results.get('technologies', {}).get('cms', ['None']))}
-- Security Score: {results.get('security_headers', {}).get('score', 0):.1f}%
+### Quick Stats
+- 🌐 Subdomains: {len(results.get('subdomains', []))}
+- 🔧 Technologies: {len(results.get('technologies', {}).get('cms', [])) + len(results.get('technologies', {}).get('frameworks', []))}
+- 📍 Endpoints: {len(results.get('endpoints', []))}
+- 📝 Forms: {len(results.get('forms', []))}
+- 📜 JS Files: {len(results.get('js_files', []))}
+- ⚠️ Threat Vectors: {len(results.get('threat_vectors', []))}
+- 🎯 Attack Paths: {len(results.get('attack_paths', []))}
+
+### Vulnerability Summary
+- 🔴 **Critical:** {critical}
+- 🟠 **High:** {high}
+- 🟡 **Medium:** {medium}
+
+### Technologies Detected
+- **Web Server:** {results.get('technologies', {}).get('web_server', 'Unknown')}
+- **CMS:** {', '.join(results.get('technologies', {}).get('cms', ['None']))}
+- **Frameworks:** {', '.join(results.get('technologies', {}).get('frameworks', ['None']))}
+- **Security Headers Score:** {results.get('security_headers', {}).get('score', 0):.1f}%
+
+### Top Recommendations
+1. {"Patch critical vulnerabilities immediately" if critical > 0 else "Review security headers"}
+2. {"Update outdated CMS/plugins" if 'WordPress' in str(results.get('technologies', {}).get('cms', [])) else "Enable security headers"}
+3. Review exposed endpoints for sensitive information
 """
         
         return (
-            summary_text,
+            summary,
             json.dumps(results, indent=2, default=str),
             fig,
             results.get("report", "No report generated")
@@ -1504,33 +2073,41 @@ def run_assessment(target_url: str, threat_level: str, progress=gr.Progress(trac
         error_msg = f"Error: {str(e)}"
         import traceback
         error_detail = traceback.format_exc()
-        return error_msg, json.dumps({"error": str(e), "traceback": error_detail}), go.Figure(), error_msg
+        return error_msg, f"{{\\n  \\"error\\": \\"{str(e)}\\",\\n  \\"traceback\\": \\"{error_detail}\\"\\n}}", go.Figure(), error_msg
+
+# ════════════════════════════════════════════════════════════════════════════
+# GRADIO UI DEFINITION
+# ════════════════════════════════════════════════════════════════════════════
 
 def create_interface():
+    """Create Gradio interface"""
+    
     with gr.Blocks(
         theme=gr.themes.Soft(primary_hue="red"),
         title="Red Team Recon Framework v3.0",
         css="""
+        .main-header { text-align: center; color: #ff0000; }
         .disclaimer { background-color: #ffeeee; padding: 10px; border-left: 5px solid #ff0000; }
         """
     ) as demo:
         
         gr.Markdown("""
-        # Red Team Advanced Web Reconnaissance Framework v3.0
+        # 🛡️ RED TEAM ADVANCED WEB RECONNAISSANCE FRAMEWORK v3.0
         ### Professional Security Assessment Tool - Private Space Edition
         
         <div class="disclaimer">
-        <strong>DISCLAIMER:</strong> Authorized security testing only. 
-        Unauthorized access is illegal.
+        ⚠️ <strong>DISCLAIMER:</strong> This tool is intended for authorized security testing only. 
+        Unauthorized access to computer systems is illegal. Use only on systems you own or have 
+        explicit written permission to test.
         </div>
         
         **Features:**
-        - Passive OSINT (DNS, SSL, GitHub, crt.sh, Wayback)
-        - Active Reconnaissance (Fingerprinting, endpoint discovery)
-        - Vulnerability Analysis (Pattern-based detection)
-        - Threat Modeling (STRIDE + MITRE ATT&CK)
-        - Attack Surface Visualization
-        - Professional Reporting
+        - 🕵️ Passive OSINT (DNS, SSL, GitHub, crt.sh, Wayback)
+        - 📡 Active Reconnaissance (Fingerprinting, endpoint discovery)
+        - 🎯 Vulnerability Analysis (Pattern-based detection)
+        - 🧠 Threat Modeling (STRIDE + MITRE ATT&CK)
+        - 📊 Advanced Attack Surface Visualization
+        - 📝 Professional Reporting (CVSS v3.1, OWASP, Compliance)
         """)
         
         with gr.Row():
@@ -1544,49 +2121,120 @@ def create_interface():
                 threat_level = gr.Radio(
                     choices=["Low (Stealthy)", "Medium (Balanced)", "High (Aggressive)"],
                     value="Medium (Balanced)",
-                    label="Threat Level"
+                    label="Threat Level / Scan Intensity"
                 )
                 
-                scan_button = gr.Button("START ASSESSMENT", variant="primary", size="lg")
+                scan_button = gr.Button("🚀 START ASSESSMENT", variant="primary", size="lg")
+                
+                gr.Markdown("""
+                ### About Threat Levels
+                - **Low**: Slow, stealthy scanning with delays (good for evasion)
+                - **Medium**: Balanced speed and stealth (recommended)
+                - **High**: Fast, aggressive scanning (may trigger WAF)
+                """)
             
             with gr.Column(scale=1):
                 gr.Markdown("""
-                ### Methodology
+                ### Assessment Methodology
+                
+                1. **Passive OSINT** (Non-intrusive)
+                   - DNS enumeration (A, AAAA, MX, NS, TXT)
+                   - SSL certificate analysis
+                   - Certificate Transparency logs
+                   - GitHub reconnaissance
+                   - Wayback Machine historical data
+                
+                2. **Active Reconnaissance**
+                   - Technology fingerprinting
+                   - Security headers analysis
+                   - Endpoint discovery
+                   - Form analysis
+                   - JavaScript analysis
+                
+                3. **Vulnerability Analysis**
+                   - Pattern-based detection
+                   - Configuration weaknesses
+                   - Information disclosure
+                   - Injection vulnerability checks
+                
+                4. **Threat Modeling**
+                   - STRIDE analysis
+                   - Attack path generation
+                   - MITRE ATT&CK mapping
+                   - CVSS v3.1 scoring
                 
-                1. **Passive OSINT** - DNS, SSL, crt.sh, GitHub
-                2. **Active Recon** - Fingerprinting, endpoints
-                3. **Vulnerability Analysis** - Pattern detection
-                4. **Threat Modeling** - STRIDE + MITRE ATT&CK
-                5. **Reporting** - CVSS v3.1, OWASP
+                5. **Reporting**
+                   - Executive summary
+                   - Technical findings
+                   - Remediation guidance
+                   - Compliance mapping
                 """)
         
         with gr.Tabs():
-            with gr.Tab("Summary"):
+            with gr.Tab("📊 Summary"):
                 summary_output = gr.Markdown(label="Assessment Summary")
             
-            with gr.Tab("Attack Graph"):
+            with gr.Tab("📈 Attack Graph"):
                 graph_output = gr.Plot(label="Attack Surface Visualization")
             
-            with gr.Tab("Raw Data"):
-                json_output = gr.Code(language="json", label="Detailed Findings", lines=30)
+            with gr.Tab("🔍 Raw Data"):
+                json_output = gr.Code(
+                    language="json",
+                    label="Detailed Findings (JSON)",
+                    lines=30
+                )
+            
+            with gr.Tab("📋 Full Report"):
+                report_output = gr.Textbox(
+                    label="Security Assessment Report",
+                    lines=40,
+                    max_lines=100,
+                    interactive=False
+                )
+            
+            with gr.Tab("⚠️ Vulnerabilities"):
+                vulns_output = gr.Dataframe(
+                    headers=["Name", "Severity", "CVSS", "Location", "CWE"],
+                    label="Discovered Vulnerabilities"
+                )
             
-            with gr.Tab("Full Report"):
-                report_output = gr.Textbox(label="Security Report", lines=40, interactive=False)
+            with gr.Tab("🎯 MITRE ATT&CK"):
+                mitre_output = gr.JSON(label="MITRE ATT&CK Mapping")
         
+        # Button click handler
         scan_button.click(
             fn=run_assessment,
             inputs=[target_input, threat_level],
             outputs=[summary_output, json_output, graph_output, report_output]
         )
+        
+        gr.Markdown("""
+        ---
+        **Red Team Recon Framework v3.0** | Private Space Edition | Generated: {datetime.now().strftime('%Y-%m-%d')}
+        """)
     
     return demo
 
+# ════════════════════════════════════════════════════════════════════════════
+# LAUNCH
+# ════════════════════════════════════════════════════════════════════════════
+
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch(
-        share=False,
+        share=False,  # Set to True for public sharing (not recommended for private space)
         server_name="0.0.0.0",
         server_port=7860,
         show_error=True
     )
-'''
+
+print("PART 2 KODU HAZIR (Bölümler 8-10)")
+print("=" * 60)
+print("Bu kodu app_part2.py olarak kaydedin")
+print("İçerik:")
+print("  - Bölüm 8: Comprehensive Reporting Engine")
+print("  - Bölüm 9: Main Orchestrator")
+print("  - Bölüm 10: Gradio Interface")
+'''
+
+print(part2_code)