streamlit-launcher 2.0.0__py3-none-any.whl

streamlit_launcher/mas.py

@@ -0,0 +1,1938 @@
+import tkinter as tk
+from tkinter import ttk, messagebox, scrolledtext, filedialog
+import requests
+from urllib.parse import urlparse, parse_qs, urljoin
+import socket
+import ssl
+import datetime
+from bs4 import BeautifulSoup
+import threading
+import re
+import os
+from PIL import Image, ImageTk
+import sys
+import subprocess
+import webbrowser
+import json
+import time
+import xml.etree.ElementTree as ET
+from http.client import HTTPConnection
+import ipaddress
+import whois 
+import nmap
+import socket
+import dns
+
+class AdvancedVulnerabilityScanner:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Advanced Vulnerability Scanner Pro")
+        self.root.geometry("900x700")
+        self.root.configure(bg='#f0f0f0')
+        self.icon_path = os.path.join(os.path.dirname(__file__), "icon.ico")
+        if os.path.exists(self.icon_path):
+            self.root.iconbitmap(self.icon_path)
+        
+        # Scan configuration
+        self.scan_config = {
+            'timeout': 10,
+            'max_pages': 20,
+            'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'threads': 5
+        }
+        
+        # Configure styles
+        self.style = ttk.Style()
+        self.style.configure('TFrame', background='#f0f0f0')
+        self.style.configure('TLabel', background='#f0f0f0', font=('Arial', 9))
+        self.style.configure('TButton', font=('Arial', 9))
+        self.style.configure('Treeview', font=('Arial', 9), rowheight=25)
+        self.style.configure('TNotebook', background='#f0f0f0')
+        self.style.configure('TNotebook.Tab', padding=[10, 5])
+        
+        # Main UI components
+        self.create_widgets()
+        self.create_menu()
+        
+        # Initialize nmap scanner
+        self.nm = nmap.PortScanner() if self.check_nmap_installed() else None
+        
+    def check_nmap_installed(self):
+        try:
+            subprocess.run(["nmap", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            return True
+        except:
+            return False
+    
+    def create_menu(self):
+        menubar = tk.Menu(self.root)
+        
+        # File menu
+        file_menu = tk.Menu(menubar, tearoff=0)
+        file_menu.add_command(label="Save Report", command=self.save_report)
+        file_menu.add_command(label="Load Config", command=self.load_config)
+        file_menu.add_command(label="Save Config", command=self.save_config)
+        file_menu.add_separator()
+        file_menu.add_command(label="Exit", command=self.root.quit)
+        menubar.add_cascade(label="File", menu=file_menu)
+        
+        # Tools menu
+        tools_menu = tk.Menu(menubar, tearoff=0)
+        tools_menu.add_command(label="Port Scanner", command=self.open_port_scanner)
+        tools_menu.add_command(label="WHOIS Lookup", command=self.open_whois_tool)
+        tools_menu.add_command(label="DNS Lookup", command=self.open_dns_tool)
+        tools_menu.add_command(label="Ping Tool", command=self.open_ping_tool)
+        menubar.add_cascade(label="Tools", menu=tools_menu)
+        
+        # Help menu
+        help_menu = tk.Menu(menubar, tearoff=0)
+        help_menu.add_command(label="Documentation", command=self.open_documentation)
+        help_menu.add_command(label="About", command=self.show_about)
+        menubar.add_cascade(label="Help", menu=help_menu)
+        
+        self.root.config(menu=menubar)
+    
+    def create_widgets(self):
+        # Header
+        header_frame = ttk.Frame(self.root)
+        header_frame.pack(pady=5, fill=tk.X)
+        
+        try:
+            icon_path = os.path.join(os.path.dirname(__file__), "icon.ico")
+            if os.path.exists(icon_path):
+                img = Image.open(icon_path)
+                img = img.resize((32, 32), Image.LANCZOS)
+                self.tk_icon = ImageTk.PhotoImage(img)
+                icon_label = ttk.Label(header_frame, image=self.tk_icon)
+                icon_label.pack(side=tk.LEFT, padx=(0, 8))
+        except Exception:
+            pass
+        
+        ttk.Label(header_frame, text="Advanced Vulnerability Scanner Pro", 
+                 font=('Arial', 14, 'bold')).pack(side=tk.LEFT)
+        
+        # Input section
+        input_frame = ttk.Frame(self.root)
+        input_frame.pack(pady=5, fill=tk.X, padx=10)
+        
+        ttk.Label(input_frame, text="Target URL/IP:").grid(row=0, column=0, sticky=tk.W)
+        self.url_entry = ttk.Entry(input_frame, width=50)
+        self.url_entry.grid(row=0, column=1, padx=5)
+        self.url_entry.insert(0, "https://")
+        
+        self.scan_btn = ttk.Button(input_frame, text="Scan", command=self.start_scan)
+        self.scan_btn.grid(row=0, column=2, padx=5)
+        
+        # Quick tools buttons
+        self.wsl_btn = ttk.Button(input_frame, text="WSL", command=self.open_wsl_linux)
+        self.wsl_btn.grid(row=0, column=3, padx=5)
+        
+        self.terminal_btn = ttk.Button(input_frame, text="Terminal", command=self.open_terminal)
+        self.terminal_btn.grid(row=0, column=4, padx=5)
+        
+        # Scan options notebook
+        options_notebook = ttk.Notebook(self.root)
+        options_notebook.pack(pady=5, fill=tk.X, padx=10)
+        
+        # Basic scan options
+        basic_frame = ttk.Frame(options_notebook)
+        self.sql_var = tk.BooleanVar(value=True)
+        self.xss_var = tk.BooleanVar(value=True)
+        self.headers_var = tk.BooleanVar(value=True)
+        self.ssl_var = tk.BooleanVar(value=True)
+        self.crawl_var = tk.BooleanVar(value=True)
+        
+        ttk.Checkbutton(basic_frame, text="SQL Injection", variable=self.sql_var).grid(row=0, column=0, sticky=tk.W)
+        ttk.Checkbutton(basic_frame, text="XSS", variable=self.xss_var).grid(row=0, column=1, sticky=tk.W)
+        ttk.Checkbutton(basic_frame, text="Headers", variable=self.headers_var).grid(row=0, column=2, sticky=tk.W)
+        ttk.Checkbutton(basic_frame, text="SSL/TLS", variable=self.ssl_var).grid(row=1, column=0, sticky=tk.W)
+        ttk.Checkbutton(basic_frame, text="Crawl Pages", variable=self.crawl_var).grid(row=1, column=1, sticky=tk.W)
+        
+        options_notebook.add(basic_frame, text="Basic")
+        
+        # Advanced scan options
+        adv_frame = ttk.Frame(options_notebook)
+        self.csrf_var = tk.BooleanVar(value=True)
+        self.dir_trav_var = tk.BooleanVar(value=True)
+        self.cmdi_var = tk.BooleanVar(value=True)
+        self.file_exp_var = tk.BooleanVar(value=True)
+        self.ssrf_var = tk.BooleanVar(value=False)
+        self.xxe_var = tk.BooleanVar(value=False)
+        self.idor_var = tk.BooleanVar(value=False)
+        
+        ttk.Checkbutton(adv_frame, text="CSRF", variable=self.csrf_var).grid(row=0, column=0, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="Directory Traversal", variable=self.dir_trav_var).grid(row=0, column=1, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="Command Injection", variable=self.cmdi_var).grid(row=0, column=2, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="Exposed Files", variable=self.file_exp_var).grid(row=1, column=0, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="SSRF", variable=self.ssrf_var).grid(row=1, column=1, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="XXE", variable=self.xxe_var).grid(row=1, column=2, sticky=tk.W)
+        ttk.Checkbutton(adv_frame, text="IDOR", variable=self.idor_var).grid(row=2, column=0, sticky=tk.W)
+        
+        options_notebook.add(adv_frame, text="Advanced")
+        
+        # Network scan options
+        net_frame = ttk.Frame(options_notebook)
+        self.port_scan_var = tk.BooleanVar(value=False)
+        self.os_detect_var = tk.BooleanVar(value=False)
+        self.service_scan_var = tk.BooleanVar(value=False)
+        
+        ttk.Checkbutton(net_frame, text="Port Scan", variable=self.port_scan_var).grid(row=0, column=0, sticky=tk.W)
+        ttk.Checkbutton(net_frame, text="OS Detection", variable=self.os_detect_var).grid(row=0, column=1, sticky=tk.W)
+        ttk.Checkbutton(net_frame, text="Service Scan", variable=self.service_scan_var).grid(row=0, column=2, sticky=tk.W)
+        
+        options_notebook.add(net_frame, text="Network")
+        
+        # Progress bar
+        self.progress = ttk.Progressbar(self.root, orient=tk.HORIZONTAL, mode='determinate')
+        self.progress.pack(pady=5, fill=tk.X, padx=10)
+        self.status = ttk.Label(self.root, text="Ready to scan")
+        self.status.pack()
+        
+        # Results display
+        notebook = ttk.Notebook(self.root)
+        notebook.pack(pady=5, fill=tk.BOTH, expand=True, padx=10)
+        
+        # Vulnerabilities tab
+        vuln_frame = ttk.Frame(notebook)
+        self.results_tree = ttk.Treeview(vuln_frame, columns=('severity', 'type', 'details'), show='headings')
+        self.results_tree.heading('severity', text='Severity')
+        self.results_tree.heading('type', text='Vulnerability')
+        self.results_tree.heading('details', text='Details')
+        self.results_tree.column('severity', width=80, anchor=tk.CENTER)
+        self.results_tree.column('type', width=150)
+        self.results_tree.column('details', width=500)
+        
+        scrollbar = ttk.Scrollbar(vuln_frame, orient=tk.VERTICAL, command=self.results_tree.yview)
+        self.results_tree.configure(yscroll=scrollbar.set)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        self.results_tree.pack(fill=tk.BOTH, expand=True)
+        
+        # Add context menu for vulnerabilities
+        self.vuln_menu = tk.Menu(self.root, tearoff=0)
+        self.vuln_menu.add_command(label="View Details", command=self.show_vuln_details)
+        self.vuln_menu.add_command(label="Copy Details", command=self.copy_vuln_details)
+        self.vuln_menu.add_command(label="Export to Report", command=self.export_vuln_to_report)
+        self.results_tree.bind("<Button-3>", self.show_vuln_context_menu)
+        
+        notebook.add(vuln_frame, text='Vulnerabilities')
+        
+        # Details tab
+        details_frame = ttk.Frame(notebook)
+        self.details_text = scrolledtext.ScrolledText(details_frame, wrap=tk.WORD, font=('Consolas', 9))
+        self.details_text.pack(fill=tk.BOTH, expand=True)
+        notebook.add(details_frame, text='Scan Details')
+        
+        # Exposed Files tab
+        files_frame = ttk.Frame(notebook)
+        self.files_tree = ttk.Treeview(files_frame, columns=('type', 'url', 'status', 'size'), show='headings')
+        self.files_tree.heading('type', text='Type')
+        self.files_tree.heading('url', text='URL')
+        self.files_tree.heading('status', text='Status')
+        self.files_tree.heading('size', text='Size')
+        self.files_tree.column('type', width=100)
+        self.files_tree.column('url', width=350)
+        self.files_tree.column('status', width=80)
+        self.files_tree.column('size', width=80)
+        
+        files_scrollbar = ttk.Scrollbar(files_frame, orient=tk.VERTICAL, command=self.files_tree.yview)
+        self.files_tree.configure(yscroll=files_scrollbar.set)
+        files_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        self.files_tree.pack(fill=tk.BOTH, expand=True)
+        
+        # Add context menu for files tree
+        self.files_menu = tk.Menu(self.root, tearoff=0)
+        self.files_menu.add_command(label="Open in Browser", command=self.open_selected_file)
+        self.files_menu.add_command(label="Copy URL", command=self.copy_file_url)
+        self.files_menu.add_command(label="Download File", command=self.download_selected_file)
+        self.files_tree.bind("<Button-3>", self.show_files_context_menu)
+        
+        notebook.add(files_frame, text='Exposed Files')
+        
+        # Network Info tab
+        network_frame = ttk.Frame(notebook)
+        self.network_tree = ttk.Treeview(network_frame, columns=('service', 'port', 'state', 'version'), show='headings')
+        self.network_tree.heading('service', text='Service')
+        self.network_tree.heading('port', text='Port')
+        self.network_tree.heading('state', text='State')
+        self.network_tree.heading('version', text='Version')
+        self.network_tree.column('service', width=150)
+        self.network_tree.column('port', width=80)
+        self.network_tree.column('state', width=80)
+        self.network_tree.column('version', width=200)
+        
+        network_scrollbar = ttk.Scrollbar(network_frame, orient=tk.VERTICAL, command=self.network_tree.yview)
+        self.network_tree.configure(yscroll=network_scrollbar.set)
+        network_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        self.network_tree.pack(fill=tk.BOTH, expand=True)
+        
+        notebook.add(network_frame, text='Network Info')
+        
+        # Configure tags for severity colors
+        self.results_tree.tag_configure('critical', background='#ff9999', foreground='#800000')
+        self.results_tree.tag_configure('high', background='#ffcccc')
+        self.results_tree.tag_configure('medium', background='#fff3cd')
+        self.results_tree.tag_configure('low', background='#d4edda')
+        self.results_tree.tag_configure('info', background='#d1ecf1')
+        
+        # Configure tags for network info
+        self.network_tree.tag_configure('open', background='#ffcccc')
+        self.network_tree.tag_configure('filtered', background='#fff3cd')
+        self.network_tree.tag_configure('closed', background='#d4edda')
+    
+    def show_vuln_context_menu(self, event):
+        item = self.results_tree.identify_row(event.y)
+        if item:
+            self.results_tree.selection_set(item)
+            self.vuln_menu.post(event.x_root, event.y_root)
+    
+    def show_vuln_details(self):
+        selected = self.results_tree.selection()
+        if selected:
+            details = self.results_tree.item(selected[0])['values'][2]
+            self.show_details_window("Vulnerability Details", details)
+    
+    def copy_vuln_details(self):
+        selected = self.results_tree.selection()
+        if selected:
+            details = self.results_tree.item(selected[0])['values'][2]
+            self.root.clipboard_clear()
+            self.root.clipboard_append(details)
+            messagebox.showinfo("Copied", "Vulnerability details copied to clipboard")
+    
+    def export_vuln_to_report(self):
+        selected = self.results_tree.selection()
+        if selected:
+            item = self.results_tree.item(selected[0])
+            severity, vuln_type, details = item['values']
+            
+            report = f"Vulnerability Report\n\n"
+            report += f"Severity: {severity}\n"
+            report += f"Type: {vuln_type}\n"
+            report += f"Details:\n{details}\n"
+            
+            filename = filedialog.asksaveasfilename(
+                defaultextension=".txt",
+                filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
+                title="Save Report As"
+            )
+            
+            if filename:
+                with open(filename, 'w') as f:
+                    f.write(report)
+                messagebox.showinfo("Saved", f"Report saved to {filename}")
+    
+    def show_details_window(self, title, content):
+        window = tk.Toplevel(self.root)
+        window.title(title)
+        window.geometry("600x400")
+        
+        text = scrolledtext.ScrolledText(window, wrap=tk.WORD, font=('Consolas', 9))
+        text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        text.insert(tk.END, content)
+        text.config(state=tk.DISABLED)
+        
+        btn_frame = ttk.Frame(window)
+        btn_frame.pack(pady=5)
+        
+        ttk.Button(btn_frame, text="Copy", command=lambda: self.copy_to_clipboard(content)).pack(side=tk.LEFT, padx=5)
+        ttk.Button(btn_frame, text="Close", command=window.destroy).pack(side=tk.LEFT, padx=5)
+    
+    def copy_to_clipboard(self, text):
+        self.root.clipboard_clear()
+        self.root.clipboard_append(text)
+        messagebox.showinfo("Copied", "Content copied to clipboard")
+    
+    def show_files_context_menu(self, event):
+        item = self.files_tree.identify_row(event.y)
+        if item:
+            self.files_tree.selection_set(item)
+            self.files_menu.post(event.x_root, event.y_root)
+    
+    def open_selected_file(self):
+        selected = self.files_tree.selection()
+        if selected:
+            url = self.files_tree.item(selected[0])['values'][1]
+            webbrowser.open(url)
+    
+    def download_selected_file(self):
+        selected = self.files_tree.selection()
+        if selected:
+            url = self.files_tree.item(selected[0])['values'][1]
+            try:
+                response = requests.get(url, stream=True, timeout=10)
+                if response.status_code == 200:
+                    filename = filedialog.asksaveasfilename(
+                        initialfile=os.path.basename(urlparse(url).path),
+                        title="Save File As"
+                    )
+                    if filename:
+                        with open(filename, 'wb') as f:
+                            for chunk in response.iter_content(1024):
+                                f.write(chunk)
+                        messagebox.showinfo("Download Complete", f"File saved to {filename}")
+            except Exception as e:
+                messagebox.showerror("Download Error", f"Failed to download file: {str(e)}")
+    
+    def copy_file_url(self):
+        selected = self.files_tree.selection()
+        if selected:
+            url = self.files_tree.item(selected[0])['values'][1]
+            self.root.clipboard_clear()
+            self.root.clipboard_append(url)
+            messagebox.showinfo("Copied", "URL copied to clipboard")
+    
+    def open_wsl_linux(self):
+        """Open WSL (Windows Subsystem for Linux) terminal"""
+        try:
+            subprocess.Popen("wsl", creationflags=subprocess.CREATE_NEW_CONSOLE)
+            messagebox.showinfo("WSL", "WSL terminal opened successfully!")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to open WSL: {str(e)}")
+    
+    def open_terminal(self):
+        """Open system terminal"""
+        try:
+            if sys.platform == "win32":
+                subprocess.Popen("cmd", creationflags=subprocess.CREATE_NEW_CONSOLE)
+            elif sys.platform == "linux":
+                subprocess.Popen("x-terminal-emulator")
+            elif sys.platform == "darwin":
+                subprocess.Popen("open -a Terminal .")
+            messagebox.showinfo("Terminal", "Terminal opened successfully!")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to open terminal: {str(e)}")
+    
+    def save_report(self):
+        """Save scan results to a file"""
+        try:
+            filename = filedialog.asksaveasfilename(
+                defaultextension=".txt",
+                filetypes=[("Text Files", "*.txt"), ("HTML Files", "*.html"), ("All Files", "*.*")],
+                title="Save Report As"
+            )
+            
+            if filename:
+                if filename.endswith('.html'):
+                    self.save_html_report(filename)
+                else:
+                    self.save_text_report(filename)
+                
+                messagebox.showinfo("Saved", f"Report saved to {filename}")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to save report: {str(e)}")
+    
+    def save_text_report(self, filename):
+        """Save report as plain text"""
+        with open(filename, 'w') as f:
+            # Write header
+            f.write("="*80 + "\n")
+            f.write("Advanced Vulnerability Scanner Report\n")
+            f.write(f"Generated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"Target: {self.url_entry.get()}\n")
+            f.write("="*80 + "\n\n")
+            
+            # Write vulnerabilities
+            f.write("Vulnerabilities:\n")
+            f.write("-"*80 + "\n")
+            for item in self.results_tree.get_children():
+                severity, vuln_type, details = self.results_tree.item(item)['values']
+                f.write(f"[{severity}] {vuln_type}:\n{details}\n\n")
+            
+            # Write exposed files
+            f.write("\nExposed Files:\n")
+            f.write("-"*80 + "\n")
+            for item in self.files_tree.get_children():
+                file_type, url, status, size = self.files_tree.item(item)['values']
+                f.write(f"{file_type}: {url} ({status}, {size})\n")
+            
+            # Write network info
+            if self.network_tree.get_children():
+                f.write("\nNetwork Information:\n")
+                f.write("-"*80 + "\n")
+                for item in self.network_tree.get_children():
+                    service, port, state, version = self.network_tree.item(item)['values']
+                    f.write(f"{service} on port {port} ({state}): {version}\n")
+            
+            # Write scan details
+            f.write("\nScan Details:\n")
+            f.write("-"*80 + "\n")
+            f.write(self.details_text.get("1.0", tk.END))
+    
+    def save_html_report(self, filename):
+        """Save report as HTML"""
+        with open(filename, 'w') as f:
+            f.write("<!DOCTYPE html>\n<html>\n<head>\n")
+            f.write("<title>Vulnerability Scan Report</title>\n")
+            f.write("<style>\n")
+            f.write("body { font-family: Arial, sans-serif; line-height: 1.6; }\n")
+            f.write("h1, h2 { color: #333; }\n")
+            f.write(".critical { background-color: #ff9999; color: #800000; padding: 2px 5px; }\n")
+            f.write(".high { background-color: #ffcccc; padding: 2px 5px; }\n")
+            f.write(".medium { background-color: #fff3cd; padding: 2px 5px; }\n")
+            f.write(".low { background-color: #d4edda; padding: 2px 5px; }\n")
+            f.write(".info { background-color: #d1ecf1; padding: 2px 5px; }\n")
+            f.write("pre { background-color: #f5f5f5; padding: 10px; border-radius: 3px; }\n")
+            f.write("table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }\n")
+            f.write("th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }\n")
+            f.write("th { background-color: #f2f2f2; }\n")
+            f.write("</style>\n</head>\n<body>\n")
+            
+            # Write header
+            f.write("<h1>Advanced Vulnerability Scanner Report</h1>\n")
+            f.write(f"<p><strong>Generated:</strong> {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>\n")
+            f.write(f"<p><strong>Target:</strong> {self.url_entry.get()}</p>\n")
+            f.write("<hr>\n")
+            
+            # Write vulnerabilities
+            f.write("<h2>Vulnerabilities</h2>\n")
+            f.write("<table>\n")
+            f.write("<tr><th>Severity</th><th>Type</th><th>Details</th></tr>\n")
+            for item in self.results_tree.get_children():
+                severity, vuln_type, details = self.results_tree.item(item)['values']
+                f.write(f"<tr><td><span class='{severity.lower()}'>{severity}</span></td>")
+                f.write(f"<td>{vuln_type}</td><td><pre>{details}</pre></td></tr>\n")
+            f.write("</table>\n")
+            
+            # Write exposed files
+            f.write("<h2>Exposed Files</h2>\n")
+            f.write("<table>\n")
+            f.write("<tr><th>Type</th><th>URL</th><th>Status</th><th>Size</th></tr>\n")
+            for item in self.files_tree.get_children():
+                file_type, url, status, size = self.files_tree.item(item)['values']
+                f.write(f"<tr><td>{file_type}</td><td><a href='{url}' target='_blank'>{url}</a></td>")
+                f.write(f"<td>{status}</td><td>{size}</td></tr>\n")
+            f.write("</table>\n")
+            
+            # Write network info
+            if self.network_tree.get_children():
+                f.write("<h2>Network Information</h2>\n")
+                f.write("<table>\n")
+                f.write("<tr><th>Service</th><th>Port</th><th>State</th><th>Version</th></tr>\n")
+                for item in self.network_tree.get_children():
+                    service, port, state, version = self.network_tree.item(item)['values']
+                    f.write(f"<tr><td>{service}</td><td>{port}</td><td>{state}</td><td>{version}</td></tr>\n")
+                f.write("</table>\n")
+            
+            # Write scan details
+            f.write("<h2>Scan Details</h2>\n")
+            f.write(f"<pre>{self.details_text.get('1.0', tk.END)}</pre>\n")
+            
+            f.write("</body>\n</html>")
+    
+    def load_config(self):
+        """Load scan configuration from file"""
+        try:
+            filename = filedialog.askopenfilename(
+                filetypes=[("JSON Files", "*.json"), ("All Files", "*.*")],
+                title="Load Configuration"
+            )
+            
+            if filename:
+                with open(filename, 'r') as f:
+                    config = json.load(f)
+                
+                # Update UI with loaded configuration
+                self.url_entry.delete(0, tk.END)
+                self.url_entry.insert(0, config.get('target_url', ''))
+                
+                # Update scan options
+                self.sql_var.set(config.get('sql_injection', True))
+                self.xss_var.set(config.get('xss', True))
+                self.headers_var.set(config.get('headers', True))
+                self.ssl_var.set(config.get('ssl', True))
+                self.crawl_var.set(config.get('crawl', True))
+                self.csrf_var.set(config.get('csrf', True))
+                self.dir_trav_var.set(config.get('dir_traversal', True))
+                self.cmdi_var.set(config.get('command_injection', True))
+                self.file_exp_var.set(config.get('exposed_files', True))
+                self.ssrf_var.set(config.get('ssrf', False))
+                self.xxe_var.set(config.get('xxe', False))
+                self.idor_var.set(config.get('idor', False))
+                self.port_scan_var.set(config.get('port_scan', False))
+                self.os_detect_var.set(config.get('os_detection', False))
+                self.service_scan_var.set(config.get('service_scan', False))
+                
+                # Update scan configuration
+                self.scan_config.update(config.get('scan_config', {}))
+                
+                messagebox.showinfo("Loaded", "Configuration loaded successfully!")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to load configuration: {str(e)}")
+    
+    def save_config(self):
+        """Save current configuration to file"""
+        try:
+            filename = filedialog.asksaveasfilename(
+                defaultextension=".json",
+                filetypes=[("JSON Files", "*.json"), ("All Files", "*.*")],
+                title="Save Configuration As"
+            )
+            
+            if filename:
+                config = {
+                    'target_url': self.url_entry.get(),
+                    'scan_config': self.scan_config,
+                    'sql_injection': self.sql_var.get(),
+                    'xss': self.xss_var.get(),
+                    'headers': self.headers_var.get(),
+                    'ssl': self.ssl_var.get(),
+                    'crawl': self.crawl_var.get(),
+                    'csrf': self.csrf_var.get(),
+                    'dir_traversal': self.dir_trav_var.get(),
+                    'command_injection': self.cmdi_var.get(),
+                    'exposed_files': self.file_exp_var.get(),
+                    'ssrf': self.ssrf_var.get(),
+                    'xxe': self.xxe_var.get(),
+                    'idor': self.idor_var.get(),
+                    'port_scan': self.port_scan_var.get(),
+                    'os_detection': self.os_detect_var.get(),
+                    'service_scan': self.service_scan_var.get()
+                }
+                
+                with open(filename, 'w') as f:
+                    json.dump(config, f, indent=4)
+                
+                messagebox.showinfo("Saved", f"Configuration saved to {filename}")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to save configuration: {str(e)}")
+    
+    def open_port_scanner(self):
+        """Open port scanner tool"""
+        port_window = tk.Toplevel(self.root)
+        port_window.title("Port Scanner")
+        port_window.geometry("500x400")
+        
+        ttk.Label(port_window, text="Target Host:").pack(pady=(10, 0))
+        host_entry = ttk.Entry(port_window, width=30)
+        host_entry.pack()
+        host_entry.insert(0, self.url_entry.get())
+        
+        ttk.Label(port_window, text="Port Range (e.g., 1-1024):").pack(pady=(10, 0))
+        port_entry = ttk.Entry(port_window, width=30)
+        port_entry.pack()
+        port_entry.insert(0, "1-1024")
+        
+        result_text = scrolledtext.ScrolledText(port_window, wrap=tk.WORD, height=15)
+        result_text.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)
+        
+        def scan_ports():
+            host = host_entry.get().strip()
+            port_range = port_entry.get().strip()
+            
+            if not host:
+                messagebox.showerror("Error", "Please enter a target host")
+                return
+            
+            try:
+                # Validate port range
+                if '-' in port_range:
+                    start, end = map(int, port_range.split('-'))
+                else:
+                    start = end = int(port_range)
+                
+                result_text.delete(1.0, tk.END)
+                result_text.insert(tk.END, f"Scanning {host} ports {start}-{end}...\n\n")
+                port_window.update()
+                
+                open_ports = []
+                
+                for port in range(start, end + 1):
+                    try:
+                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        sock.settimeout(1)
+                        result = sock.connect_ex((host, port))
+                        if result == 0:
+                            service = socket.getservbyport(port, 'tcp') if port <= 65535 else 'unknown'
+                            open_ports.append((port, service))
+                            result_text.insert(tk.END, f"Port {port} ({service}) is open\n")
+                        sock.close()
+                    except:
+                        result_text.insert(tk.END, f"Port {port}: Error scanning\n")
+                    
+                    port_window.update()
+                
+                result_text.insert(tk.END, f"\nScan complete. Found {len(open_ports)} open ports.\n")
+                
+                if open_ports:
+                    result_text.insert(tk.END, "\nOpen ports:\n")
+                    for port, service in open_ports:
+                        result_text.insert(tk.END, f"- {port}: {service}\n")
+                
+            except ValueError:
+                messagebox.showerror("Error", "Invalid port range format")
+            except Exception as e:
+                messagebox.showerror("Error", f"Port scan failed: {str(e)}")
+        
+        ttk.Button(port_window, text="Scan Ports", command=scan_ports).pack(pady=5)
+    
+    def open_whois_tool(self):
+        """Open WHOIS lookup tool"""
+        whois_window = tk.Toplevel(self.root)
+        whois_window.title("WHOIS Lookup")
+        whois_window.geometry("600x400")
+        
+        ttk.Label(whois_window, text="Domain or IP:").pack(pady=(10, 0))
+        domain_entry = ttk.Entry(whois_window, width=30)
+        domain_entry.pack()
+        domain_entry.insert(0, self.url_entry.get())
+        
+        result_text = scrolledtext.ScrolledText(whois_window, wrap=tk.WORD, height=20)
+        result_text.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)
+        
+        def perform_whois():
+            domain = domain_entry.get().strip()
+            if not domain:
+                messagebox.showerror("Error", "Please enter a domain or IP")
+                return
+            
+            try:
+                result_text.delete(1.0, tk.END)
+                result_text.insert(tk.END, f"Performing WHOIS lookup for {domain}...\n\n")
+                whois_window.update()
+                
+                # Extract domain from URL if needed
+                if domain.startswith(('http://', 'https://')):
+                    domain = urlparse(domain).netloc
+                
+                # Perform WHOIS lookup
+                w = whois.whois(domain)
+                
+                result_text.insert(tk.END, f"WHOIS Results for {domain}:\n\n")
+                
+                # Display basic info
+                result_text.insert(tk.END, f"Domain Name: {w.domain_name}\n")
+                result_text.insert(tk.END, f"Registrar: {w.registrar}\n")
+                result_text.insert(tk.END, f"Creation Date: {w.creation_date}\n")
+                result_text.insert(tk.END, f"Expiration Date: {w.expiration_date}\n")
+                result_text.insert(tk.END, f"Name Servers: {', '.join(w.name_servers) if w.name_servers else 'N/A'}\n\n")
+                
+                # Display raw WHOIS data
+                result_text.insert(tk.END, "Raw WHOIS Data:\n")
+                result_text.insert(tk.END, "-"*50 + "\n")
+                result_text.insert(tk.END, str(w.text) + "\n")
+                
+            except Exception as e:
+                messagebox.showerror("Error", f"WHOIS lookup failed: {str(e)}")
+        
+        ttk.Button(whois_window, text="Lookup", command=perform_whois).pack(pady=5)
+    
+    def open_dns_tool(self):
+        """Open DNS lookup tool"""
+        dns_window = tk.Toplevel(self.root)
+        dns_window.title("DNS Lookup")
+        dns_window.geometry("600x400")
+        
+        ttk.Label(dns_window, text="Domain:").pack(pady=(10, 0))
+        domain_entry = ttk.Entry(dns_window, width=30)
+        domain_entry.pack()
+        domain_entry.insert(0, self.url_entry.get())
+        
+        result_text = scrolledtext.ScrolledText(dns_window, wrap=tk.WORD, height=20)
+        result_text.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)
+        
+        def perform_dns_lookup():
+            domain = domain_entry.get().strip()
+            if not domain:
+                messagebox.showerror("Error", "Please enter a domain")
+                return
+            
+            try:
+                result_text.delete(1.0, tk.END)
+                result_text.insert(tk.END, f"Performing DNS lookup for {domain}...\n\n")
+                dns_window.update()
+                
+                # Extract domain from URL if needed
+                if domain.startswith(('http://', 'https://')):
+                    domain = urlparse(domain).netloc
+                
+                # Perform DNS lookups
+                record_types = ['A', 'AAAA', 'MX', 'NS', 'TXT', 'CNAME', 'SOA']
+                
+                for record_type in record_types:
+                    try:
+                        result_text.insert(tk.END, f"{record_type} Records:\n")
+                        answers = dns.resolver.resolve(domain, record_type)
+                        for rdata in answers:
+                            result_text.insert(tk.END, f"- {rdata}\n")
+                        result_text.insert(tk.END, "\n")
+                    except dns.resolver.NoAnswer:
+                        result_text.insert(tk.END, f"No {record_type} records found\n\n")
+                    except dns.resolver.NXDOMAIN:
+                        result_text.insert(tk.END, f"Domain {domain} does not exist\n\n")
+                        break
+                    except Exception as e:
+                        result_text.insert(tk.END, f"Error querying {record_type} records: {str(e)}\n\n")
+                    
+                    dns_window.update()
+                
+                result_text.insert(tk.END, "DNS lookup complete.\n")
+                
+            except Exception as e:
+                messagebox.showerror("Error", f"DNS lookup failed: {str(e)}")
+        
+        ttk.Button(dns_window, text="Lookup", command=perform_dns_lookup).pack(pady=5)
+    
+    def open_ping_tool(self):
+        """Open ping tool"""
+        ping_window = tk.Toplevel(self.root)
+        ping_window.title("Ping Tool")
+        ping_window.geometry("500x300")
+        
+        ttk.Label(ping_window, text="Host:").pack(pady=(10, 0))
+        host_entry = ttk.Entry(ping_window, width=30)
+        host_entry.pack()
+        host_entry.insert(0, self.url_entry.get())
+        
+        ttk.Label(ping_window, text="Count (1-10):").pack(pady=(10, 0))
+        count_entry = ttk.Entry(ping_window, width=10)
+        count_entry.pack()
+        count_entry.insert(0, "4")
+        
+        result_text = scrolledtext.ScrolledText(ping_window, wrap=tk.WORD, height=10)
+        result_text.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)
+        
+        def perform_ping():
+            host = host_entry.get().strip()
+            if not host:
+                messagebox.showerror("Error", "Please enter a host")
+                return
+            
+            try:
+                count = int(count_entry.get())
+                if count < 1 or count > 10:
+                    raise ValueError
+            except ValueError:
+                messagebox.showerror("Error", "Please enter a count between 1 and 10")
+                return
+            
+            try:
+                result_text.delete(1.0, tk.END)
+                result_text.insert(tk.END, f"Pinging {host} {count} times...\n\n")
+                ping_window.update()
+                
+                # Extract host from URL if needed
+                if host.startswith(('http://', 'https://')):
+                    host = urlparse(host).netloc
+                
+                # Platform-specific ping command
+                if sys.platform == "win32":
+                    cmd = ["ping", "-n", str(count), host]
+                else:
+                    cmd = ["ping", "-c", str(count), host]
+                
+                process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    universal_newlines=True
+                )
+                
+                for line in process.stdout:
+                    result_text.insert(tk.END, line)
+                    ping_window.update()
+                
+                result_text.insert(tk.END, "\nPing complete.\n")
+                
+            except Exception as e:
+                messagebox.showerror("Error", f"Ping failed: {str(e)}")
+        
+        ttk.Button(ping_window, text="Ping", command=perform_ping).pack(pady=5)
+    
+    def open_documentation(self):
+        """Open documentation in browser"""
+        try:
+            webbrowser.open("https://github.com/yourusername/vulnerability-scanner/docs")
+        except:
+            messagebox.showerror("Error", "Could not open documentation")
+    
+    def show_about(self):
+        """Show about dialog"""
+        about_window = tk.Toplevel(self.root)
+        about_window.title("About")
+        about_window.geometry("400x300")
+        
+        try:
+            icon_path = os.path.join(os.path.dirname(__file__), "icon.ico")
+            if os.path.exists(icon_path):
+                img = Image.open(icon_path)
+                img = img.resize((64, 64), Image.LANCZOS)
+                tk_icon = ImageTk.PhotoImage(img)
+                icon_label = ttk.Label(about_window, image=tk_icon)
+                icon_label.image = tk_icon  # Keep a reference
+                icon_label.pack(pady=10)
+        except Exception:
+            pass
+        
+        ttk.Label(about_window, text="Advanced Vulnerability Scanner Pro", 
+                 font=('Arial', 12, 'bold')).pack()
+        
+        ttk.Label(about_window, text="Version 2.0").pack()
+        ttk.Label(about_window, text="\nA comprehensive security scanning tool").pack()
+        ttk.Label(about_window, text="for identifying vulnerabilities in web applications.").pack()
+        
+        ttk.Label(about_window, text="\n© 2023 Security Tools Inc.").pack()
+        
+        btn_frame = ttk.Frame(about_window)
+        btn_frame.pack(pady=10)
+        
+        ttk.Button(btn_frame, text="Close", command=about_window.destroy).pack()
+    
+    def start_scan(self):
+        target = self.url_entry.get().strip()
+        if not target:
+            messagebox.showerror("Error", "Please enter a target URL or IP")
+            return
+        
+        # Clear previous results
+        for item in self.results_tree.get_children():
+            self.results_tree.delete(item)
+        for item in self.files_tree.get_children():
+            self.files_tree.delete(item)
+        for item in self.network_tree.get_children():
+            self.network_tree.delete(item)
+        self.details_text.delete(1.0, tk.END)
+        
+        self.scan_btn.config(state=tk.DISABLED)
+        
+        scan_thread = threading.Thread(target=self.run_scan, args=(target,), daemon=True)
+        scan_thread.start()
+    
+    def run_scan(self, target):
+        try:
+            # Check if target is an IP address
+            try:
+                ipaddress.ip_address(target)
+                is_ip = True
+            except ValueError:
+                is_ip = False
+            
+            if not is_ip and not target.startswith(('http://', 'https://')):
+                target = f"http://{target}"
+            
+            parsed_url = urlparse(target) if not is_ip else None
+            domain = parsed_url.netloc if not is_ip else target
+            base_url = f"{parsed_url.scheme}://{domain}" if not is_ip else None
+            
+            # Calculate total steps for progress
+            total_steps = sum([
+                self.sql_var.get(),
+                self.xss_var.get(),
+                self.headers_var.get(),
+                self.ssl_var.get(),
+                self.csrf_var.get(),
+                self.dir_trav_var.get(),
+                self.cmdi_var.get(),
+                self.crawl_var.get(),
+                self.file_exp_var.get(),
+                self.ssrf_var.get(),
+                self.xxe_var.get(),
+                self.idor_var.get(),
+                self.port_scan_var.get(),
+                self.os_detect_var.get(),
+                self.service_scan_var.get()
+            ])
+            current_step = 0
+            
+            # Network scans (work for both IP and URL)
+            if self.port_scan_var.get() and self.nm:
+                self.update_status("Performing port scan...")
+                self.port_scan(domain)
+                current_step += 1
+                self.update_progress(current_step, total_steps)
+            
+            if self.os_detect_var.get() and self.nm:
+                self.update_status("Detecting OS...")
+                self.os_detection(domain)
+                current_step += 1
+                self.update_progress(current_step, total_steps)
+            
+            if self.service_scan_var.get() and self.nm:
+                self.update_status("Scanning services...")
+                self.service_scan(domain)
+                current_step += 1
+                self.update_progress(current_step, total_steps)
+            
+            # Web application scans (only for URLs)
+            if not is_ip:
+                # SSL/TLS Check
+                if self.ssl_var.get():
+                    self.update_status("Checking SSL/TLS configuration...")
+                    self.check_ssl(domain)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # Headers Analysis
+                if self.headers_var.get():
+                    self.update_status("Analyzing HTTP headers...")
+                    self.analyze_headers(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # SQL Injection Test
+                if self.sql_var.get():
+                    self.update_status("Testing for SQL Injection...")
+                    self.test_sql_injection(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # XSS Test
+                if self.xss_var.get():
+                    self.update_status("Testing for XSS vulnerabilities...")
+                    self.test_xss(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # CSRF Test
+                if self.csrf_var.get():
+                    self.update_status("Checking for CSRF vulnerabilities...")
+                    self.test_csrf(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # Directory Traversal Test
+                if self.dir_trav_var.get():
+                    self.update_status("Testing for Directory Traversal...")
+                    self.test_directory_traversal(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # Command Injection Test
+                if self.cmdi_var.get():
+                    self.update_status("Testing for Command Injection...")
+                    self.test_command_injection(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # SSRF Test
+                if self.ssrf_var.get():
+                    self.update_status("Testing for SSRF vulnerabilities...")
+                    self.test_ssrf(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # XXE Test
+                if self.xxe_var.get():
+                    self.update_status("Testing for XXE vulnerabilities...")
+                    self.test_xxe(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # IDOR Test
+                if self.idor_var.get():
+                    self.update_status("Testing for IDOR vulnerabilities...")
+                    self.test_idor(target)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # Crawl Pages
+                if self.crawl_var.get():
+                    self.update_status("Crawling website for links...")
+                    self.crawl_pages(base_url)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+                
+                # Check for exposed files
+                if self.file_exp_var.get():
+                    self.update_status("Checking for exposed files...")
+                    self.check_exposed_files(base_url)
+                    current_step += 1
+                    self.update_progress(current_step, total_steps)
+            
+            self.update_status("Scan completed successfully!")
+            messagebox.showinfo("Scan Complete", "Vulnerability scan completed!")
+        
+        except Exception as e:
+            self.add_result("High", "Scan Error", f"Error during scan: {str(e)}")
+            self.update_status(f"Error: {str(e)}")
+        
+        finally:
+            self.scan_btn.config(state=tk.NORMAL)
+    
+    def port_scan(self, host):
+        """Perform port scan using nmap"""
+        try:
+            if not self.nm:
+                self.add_result("Medium", "Port Scan", "Nmap is not installed. Port scanning disabled.")
+                return
+            
+            self.nm.scan(hosts=host, arguments='-F')  # Fast scan (top 100 ports)
+            
+            if host not in self.nm.all_hosts():
+                self.add_result("Medium", "Port Scan", "Host not reachable for port scanning")
+                return
+            
+            open_ports = []
+            
+            for proto in self.nm[host].all_protocols():
+                ports = self.nm[host][proto].keys()
+                for port in ports:
+                    port_info = self.nm[host][proto][port]
+                    state = port_info['state']
+                    service = port_info['name']
+                    version = port_info.get('version', 'unknown')
+                    
+                    if state == 'open':
+                        open_ports.append((service, port, state, version))
+                        self.network_tree.insert('', tk.END, 
+                                               values=(service, port, state, version),
+                                               tags=(state,))
+            
+            if open_ports:
+                self.add_result("Medium", "Open Ports", 
+                              f"Found {len(open_ports)} open ports on {host}")
+            else:
+                self.add_result("Low", "Port Scan", "No open ports found")
+            
+            self.details_text.insert(tk.END, f"\nPort Scan Results for {host}:\n")
+            self.details_text.insert(tk.END, f"Scanned {len(self.nm[host].all_ports())} ports\n")
+            self.details_text.insert(tk.END, f"Found {len(open_ports)} open ports\n\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "Port Scan Error", f"Port scan failed: {str(e)}")
+    
+    def os_detection(self, host):
+        """Perform OS detection using nmap"""
+        try:
+            if not self.nm:
+                self.add_result("Medium", "OS Detection", "Nmap is not installed. OS detection disabled.")
+                return
+            
+            self.nm.scan(hosts=host, arguments='-O')  # OS detection scan
+            
+            if host not in self.nm.all_hosts():
+                self.add_result("Medium", "OS Detection", "Host not reachable for OS detection")
+                return
+            
+            os_info = self.nm[host].get('osmatch', [])
+            
+            if os_info:
+                best_guess = os_info[0]
+                os_name = best_guess['name']
+                accuracy = best_guess['accuracy']
+                
+                self.add_result("Low", "OS Detection", 
+                              f"Likely OS: {os_name} (Accuracy: {accuracy}%)")
+                
+                self.details_text.insert(tk.END, f"\nOS Detection Results for {host}:\n")
+                self.details_text.insert(tk.END, f"Best guess: {os_name} ({accuracy}% accuracy)\n")
+                
+                if len(os_info) > 1:
+                    self.details_text.insert(tk.END, "\nOther possible matches:\n")
+                    for match in os_info[1:]:
+                        self.details_text.insert(tk.END, f"- {match['name']} ({match['accuracy']}%)\n")
+            else:
+                self.add_result("Low", "OS Detection", "Could not determine operating system")
+                self.details_text.insert(tk.END, f"\nOS Detection Results for {host}:\n")
+                self.details_text.insert(tk.END, "Could not determine operating system\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "OS Detection Error", f"OS detection failed: {str(e)}")
+    
+    def service_scan(self, host):
+        """Perform service version detection using nmap"""
+        try:
+            if not self.nm:
+                self.add_result("Medium", "Service Scan", "Nmap is not installed. Service scan disabled.")
+                return
+            
+            self.nm.scan(hosts=host, arguments='-sV')  # Service version scan
+            
+            if host not in self.nm.all_hosts():
+                self.add_result("Medium", "Service Scan", "Host not reachable for service scan")
+                return
+            
+            service_info = []
+            
+            for proto in self.nm[host].all_protocols():
+                ports = self.nm[host][proto].keys()
+                for port in ports:
+                    port_data = self.nm[host][proto][port]
+                    if port_data['state'] == 'open':
+                        service_info.append((
+                            port_data['name'],
+                            port,
+                            port_data['state'],
+                            port_data.get('product', '') + ' ' + port_data.get('version', '')
+                        ))
+            
+            if service_info:
+                self.add_result("Low", "Service Scan", 
+                              f"Found {len(service_info)} services on {host}")
+                
+                self.details_text.insert(tk.END, f"\nService Scan Results for {host}:\n")
+                for service in service_info:
+                    self.details_text.insert(tk.END, 
+                                           f"Port {service[1]}: {service[0]} - {service[3]}\n")
+            else:
+                self.add_result("Low", "Service Scan", "No services detected")
+                self.details_text.insert(tk.END, f"\nService Scan Results for {host}:\n")
+                self.details_text.insert(tk.END, "No services detected\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "Service Scan Error", f"Service scan failed: {str(e)}")
+    
+    def check_exposed_files(self, base_url):
+        """Check for exposed files on hosting platforms like Vercel, Netlify, etc."""
+        try:
+            parsed = urlparse(base_url)
+            domain = parsed.netloc
+            scheme = parsed.scheme
+            
+            # Common exposed files and directories
+            common_files = [
+                # Configuration files
+                "_config.yml", "config.yml", "config.json", "package.json", 
+                "composer.json", "package-lock.json", "yarn.lock",
+                "dockerfile", "docker-compose.yml", ".env", ".env.example",
+                ".gitignore", ".htaccess", "robots.txt", "sitemap.xml",
+                
+                # Platform specific files
+                "vercel.json", "netlify.toml", "now.json", "firebase.json",
+                "_redirects", "_headers",
+                
+                # Source code files
+                "index.php", "index.html", "main.js", "app.js", "server.js",
+                "style.css", "main.css", "app.css", "README.md", "LICENSE",
+                
+                # Backup files
+                "backup.zip", "backup.tar.gz", "backup.sql", "dump.sql",
+                "database.sql", "backup.rar", "backup.db",
+                
+                # Admin interfaces
+                "admin.php", "admin.html", "wp-admin", "administrator",
+                "login.php", "login.html", "wp-login.php",
+                
+                # API endpoints
+                "api/v1", "graphql", "graphiql", "api.json", "swagger.json",
+                "openapi.json", "api.php", "api.js",
+                
+                # Log files
+                "logs", "error.log", "access.log", "debug.log"
+            ]
+            
+            # Platform-specific file patterns
+            platform_patterns = {
+                "vercel": [
+                    "/_next/static/chunks/pages/", 
+                    "/_next/static/development/",
+                    "/_next/static/css/",
+                    "/api/",
+                    "/public/"
+                ],
+                "netlify": [
+                    "/.netlify/functions/",
+                    "/public/",
+                    "/static/",
+                    "/dist/"
+                ],
+                "github": [
+                    "/.github/workflows/",
+                    "/.github/",
+                    "/actions/"
+                ],
+                "firebase": [
+                    "/__/firebase/",
+                    "/__/auth/",
+                    "/__/database/"
+                ]
+            }
+            
+            # Check if the domain matches known hosting platforms
+            platform = None
+            if "vercel.app" in domain:
+                platform = "vercel"
+            elif "netlify.app" in domain:
+                platform = "netlify"
+            elif "github.io" in domain:
+                platform = "github"
+            elif "firebaseapp.com" in domain or "web.app" in domain:
+                platform = "firebase"
+            
+            found_files = []
+            
+            # Check common files
+            for file in common_files:
+                test_url = f"{scheme}://{domain}/{file}"
+                try:
+                    response = requests.head(test_url, timeout=5, allow_redirects=False)
+                    if response.status_code == 200:
+                        size = response.headers.get('content-length', 'unknown')
+                        found_files.append(("file", test_url, "200 OK", size))
+                        self.files_tree.insert('', tk.END, 
+                                             values=("File", test_url, "200 OK", size))
+                except:
+                    continue
+            
+            # Check platform-specific patterns if platform is detected
+            if platform:
+                for pattern in platform_patterns.get(platform, []):
+                    test_url = f"{scheme}://{domain}{pattern}"
+                    try:
+                        response = requests.head(test_url, timeout=5, allow_redirects=False)
+                        if response.status_code == 200:
+                            size = response.headers.get('content-length', 'unknown')
+                            found_files.append(("directory", test_url, "200 OK", size))
+                            self.files_tree.insert('', tk.END, 
+                                                 values=("Directory", test_url, "200 OK", size))
+                    except:
+                        continue
+            
+            # Special check for .git directory
+            test_url = f"{scheme}://{domain}/.git/"
+            try:
+                response = requests.head(test_url, timeout=5, allow_redirects=False)
+                if response.status_code in (200, 403):
+                    size = response.headers.get('content-length', 'unknown')
+                    found_files.append(("directory", test_url, f"{response.status_code}", size))
+                    self.files_tree.insert('', tk.END, 
+                                         values=("Git", test_url, f"{response.status_code}", size))
+            except:
+                pass
+            
+            # Check for exposed source code
+            self.check_exposed_source_code(base_url)
+            
+            if found_files:
+                self.add_result("Medium", "Exposed Files", f"Found {len(found_files)} exposed files/directories")
+            else:
+                self.add_result("Low", "Exposed Files", "No obvious exposed files found")
+            
+            self.details_text.insert(tk.END, f"\nExposed Files Check:\nFound {len(found_files)} files/directories\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "Exposed Files Error", f"Exposed files check failed: {str(e)}")
+    
+    def check_exposed_source_code(self, base_url):
+        """Check for exposed source code files on platforms like Vercel, Netlify"""
+        try:
+            parsed = urlparse(base_url)
+            domain = parsed.netloc
+            scheme = parsed.scheme
+            
+            # Common source code patterns for Vercel/Next.js
+            vercel_patterns = [
+                "/_next/static/chunks/pages/_app.js",
+                "/_next/static/chunks/main.js",
+                "/_next/static/chunks/webpack.js",
+                "/_next/static/css/styles.chunk.css"
+            ]
+            
+            # Common source code patterns for Netlify
+            netlify_patterns = [
+                "/static/js/main.chunk.js",
+                "/static/js/runtime-main.js",
+                "/static/css/main.chunk.css"
+            ]
+            
+            # Check if the domain matches known hosting platforms
+            if "vercel.app" in domain:
+                for pattern in vercel_patterns:
+                    test_url = f"{scheme}://{domain}{pattern}"
+                    try:
+                        response = requests.head(test_url, timeout=5, allow_redirects=False)
+                        if response.status_code == 200:
+                            size = response.headers.get('content-length', 'unknown')
+                            self.files_tree.insert('', tk.END, 
+                                                 values=("Source", test_url, "200 OK", size))
+                    except:
+                        continue
+            
+            elif "netlify.app" in domain:
+                for pattern in netlify_patterns:
+                    test_url = f"{scheme}://{domain}{pattern}"
+                    try:
+                        response = requests.head(test_url, timeout=5, allow_redirects=False)
+                        if response.status_code == 200:
+                            size = response.headers.get('content-length', 'unknown')
+                            self.files_tree.insert('', tk.END, 
+                                                 values=("Source", test_url, "200 OK", size))
+                    except:
+                        continue
+            
+            # Special check for source map files
+            source_map_patterns = [
+                "/static/js/main.js.map",
+                "/static/js/bundle.js.map",
+                "/static/js/vendor.js.map",
+                "/app.js.map",
+                "/main.js.map"
+            ]
+            
+            for pattern in source_map_patterns:
+                test_url = f"{scheme}://{domain}{pattern}"
+                try:
+                    response = requests.head(test_url, timeout=5, allow_redirects=False)
+                    if response.status_code == 200:
+                        size = response.headers.get('content-length', 'unknown')
+                        self.files_tree.insert('', tk.END, 
+                                             values=("Source Map", test_url, "200 OK", size))
+                except:
+                    continue
+            
+        except Exception as e:
+            self.add_result("Medium", "Source Code Check Error", f"Source code check failed: {str(e)}")
+    
+    def update_status(self, message):
+        self.status.config(text=message)
+        self.root.update()
+    
+    def update_progress(self, current, total):
+        progress = (current / total) * 100
+        self.progress['value'] = progress
+        self.root.update()
+    
+    def add_result(self, severity, vuln_type, details):
+        tag = severity.lower()
+        self.results_tree.insert('', tk.END, values=(severity, vuln_type, details), tags=(tag,))
+        self.details_text.insert(tk.END, f"[{severity}] {vuln_type}: {details}\n\n")
+        self.details_text.see(tk.END)
+        self.root.update()
+    
+    def check_ssl(self, domain):
+        try:
+            context = ssl.create_default_context()
+            with socket.create_connection((domain, 443)) as sock:
+                with context.wrap_socket(sock, server_hostname=domain) as ssock:
+                    cert = ssock.getpeercert()
+            
+            # Check certificate expiration
+            expiry_date = datetime.datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
+            days_remaining = (expiry_date - datetime.datetime.now()).days
+            
+            details = "SSL Certificate:\nIssuer: {}\n".format(cert['issuer'][1][0][1])
+            details += "Subject: {}\n".format(cert['subject'][1][0][1])
+            details += "Serial Number: {}\n".format(cert['serialNumber'])
+            details += "Valid From: {}\n".format(cert['notBefore'])
+            details += "Valid Until: {} ({} days remaining)\n".format(cert['notAfter'], days_remaining)
+            
+            # Check certificate algorithms
+            details += "\nCertificate Algorithms:\n"
+            details += "Signature Algorithm: {}\n".format(cert['signatureAlgorithm'])
+            
+            # Check for weak protocols
+            weak_protocols = self.detect_weak_ssl_protocols(domain)
+            if weak_protocols:
+                details += "\nWeak Protocols: {}\n".format(', '.join(weak_protocols))
+                self.add_result("High", "Weak SSL Protocols", f"Server supports: {', '.join(weak_protocols)}")
+            
+            # Check for weak ciphers
+            weak_ciphers = self.detect_weak_ciphers(domain)
+            if weak_ciphers:
+                details += "\nWeak Ciphers:\n"
+                for cipher in weak_ciphers:
+                    details += f"- {cipher}\n"
+                self.add_result("High", "Weak SSL Ciphers", f"Server supports weak ciphers: {', '.join(weak_ciphers[:3])}...")
+            
+            if days_remaining < 30:
+                self.add_result("High", "SSL Expiry", f"Certificate expires in {days_remaining} days")
+            elif days_remaining < 90:
+                self.add_result("Medium", "SSL Expiry", f"Certificate expires in {days_remaining} days")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("High", "SSL Error", f"SSL verification failed: {str(e)}")
+    
+    def detect_weak_ssl_protocols(self, domain):
+        weak_protocols = []
+        protocols = {
+            'SSLv2': ssl.PROTOCOL_SSLv2,
+            'SSLv3': ssl.PROTOCOL_SSLv3,
+            'TLSv1': ssl.PROTOCOL_TLSv1,
+            'TLSv1.1': ssl.PROTOCOL_TLSv1_1
+        }
+        
+        for name, proto in protocols.items():
+            try:
+                context = ssl.SSLContext(proto)
+                with socket.create_connection((domain, 443)) as sock:
+                    with context.wrap_socket(sock, server_hostname=domain):
+                        weak_protocols.append(name)
+            except:
+                continue
+        
+        return weak_protocols
+    
+    def detect_weak_ciphers(self, domain):
+        weak_ciphers = [
+            'DES', '3DES', 'RC4', 'RC2', 'IDEA', 'SEED',
+            'MD5', 'SHA1', 'NULL', 'ANON', 'ADH', 'EXP',
+            'CBC', 'CAMELLIA', 'PSK', 'SRP'
+        ]
+        
+        detected = []
+        
+        try:
+            context = ssl.create_default_context()
+            with socket.create_connection((domain, 443)) as sock:
+                with context.wrap_socket(sock, server_hostname=domain) as ssock:
+                    cipher = ssock.cipher()
+                    if cipher:
+                        for weak in weak_ciphers:
+                            if weak in cipher[0]:
+                                detected.append(cipher[0])
+                                break
+        except:
+            pass
+        
+        return detected
+    
+    def analyze_headers(self, url):
+        try:
+            response = requests.get(url, timeout=10, allow_redirects=True)
+            headers = response.headers
+            
+            details = "Security Headers Analysis:\n"
+            missing_headers = []
+            security_headers = {
+                'X-XSS-Protection': '1; mode=block',
+                'X-Content-Type-Options': 'nosniff',
+                'X-Frame-Options': ['DENY', 'SAMEORIGIN'],
+                'Content-Security-Policy': '',
+                'Strict-Transport-Security': '',
+                'Referrer-Policy': 'no-referrer',
+                'Feature-Policy': '',
+                'Permissions-Policy': ''
+            }
+            
+            for header, expected in security_headers.items():
+                if header not in headers:
+                    missing_headers.append(header)
+                elif expected and isinstance(expected, list) and headers[header] not in expected:
+                    self.add_result("Medium", f"Misconfigured {header}", 
+                                  f"Expected one of {expected}, got {headers[header]}")
+                elif expected and isinstance(expected, str) and headers[header] != expected:
+                    self.add_result("Medium", f"Misconfigured {header}", 
+                                  f"Expected {expected}, got {headers[header]}")
+            
+            if missing_headers:
+                self.add_result("Medium", "Missing Security Headers", 
+                              f"Missing: {', '.join(missing_headers)}")
+            
+            # Check for server information disclosure
+            if 'server' in headers:
+                self.add_result("Low", "Server Disclosure", f"Server header: {headers['server']}")
+            
+            # Check for CORS misconfiguration
+            if 'access-control-allow-origin' in headers and headers['access-control-allow-origin'] == '*':
+                self.add_result("Medium", "Permissive CORS", "Access-Control-Allow-Origin is set to '*'")
+            
+            # Check for clickjacking protection
+            if 'x-frame-options' not in headers:
+                self.add_result("Medium", "Clickjacking", "Missing X-Frame-Options header")
+            
+            # Check for content type sniffing protection
+            if 'x-content-type-options' not in headers:
+                self.add_result("Low", "Content Type Sniffing", "Missing X-Content-Type-Options header")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "Headers Error", f"Header analysis failed: {str(e)}")
+    
+    def test_sql_injection(self, url):
+        payloads = [
+            "'", "\"", "' OR '1'='1", "' OR 1=1--", 
+            "' OR 1=1#", "' OR 1=1/*", "' UNION SELECT null,version()--",
+            "' UNION SELECT username,password FROM users--",
+            "1 AND 1=1", "1 AND 1=2", "1' AND SLEEP(5)--",
+            "1' OR IF(1=1,SLEEP(5),0)--"
+        ]
+        
+        try:
+            parsed = urlparse(url)
+            params = parse_qs(parsed.query)
+            
+            if not params:
+                self.add_result("Info", "SQLi Test", "No parameters to test")
+                return
+            
+            vulnerable = False
+            details = "SQL Injection Tests:\n"
+            
+            for param in params:
+                for payload in payloads:
+                    test_url = url.replace(f"{param}={params[param][0]}", f"{param}={payload}")
+                    try:
+                        start_time = time.time()
+                        response = requests.get(test_url, timeout=5)
+                        elapsed = time.time() - start_time
+                        
+                        if self.detect_sql_errors(response.text):
+                            vulnerable = True
+                            details += f"Potential SQLi in {param} with payload: {payload} (Error-based)\n"
+                            break
+                        elif elapsed > 4:  # Time-based detection
+                            vulnerable = True
+                            details += f"Potential SQLi in {param} with payload: {payload} (Time-based, {elapsed:.2f}s)\n"
+                            break
+                        elif payload in response.text:  # Boolean-based detection
+                            vulnerable = True
+                            details += f"Potential SQLi in {param} with payload: {payload} (Boolean-based)\n"
+                            break
+                    except:
+                        continue
+            
+            if vulnerable:
+                self.add_result("High", "SQL Injection", "Potential SQLi vulnerabilities detected")
+            else:
+                self.add_result("Low", "SQL Injection", "No obvious SQLi vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "SQLi Error", f"SQLi test failed: {str(e)}")
+    
+    def detect_sql_errors(self, content):
+        errors = [
+            "SQL syntax", "MySQL server", "ORA-", "syntax error",
+            "unclosed quotation mark", "Microsoft OLE DB Provider",
+            "ODBC Driver", "PostgreSQL", "SQLite", "MariaDB",
+            "SQL error", "database error", "query failed",
+            "syntax error", "unknown column", "table not found"
+        ]
+        return any(error.lower() in content.lower() for error in errors)
+    
+    def test_xss(self, url):
+        payloads = [
+            "<script>alert(1)</script>", 
+            "<img src=x onerror=alert(1)>",
+            "\"><script>alert(1)</script>",
+            "javascript:alert(1)",
+            "onmouseover=alert(1)",
+            "onload=alert(1)",
+            "onfocus=alert(1)",
+            "svg/onload=alert(1)",
+            "alert`1`",
+            "eval('alert(1)')"
+        ]
+        
+        try:
+            parsed = urlparse(url)
+            params = parse_qs(parsed.query)
+            
+            if not params:
+                self.add_result("Info", "XSS Test", "No parameters to test")
+                return
+            
+            vulnerable = False
+            details = "XSS Tests:\n"
+            
+            for param in params:
+                for payload in payloads:
+                    test_url = url.replace(f"{param}={params[param][0]}", f"{param}={payload}")
+                    try:
+                        response = requests.get(test_url, timeout=5)
+                        if payload in response.text:
+                            vulnerable = True
+                            details += f"Potential XSS in {param} with payload: {payload}\n"
+                            break
+                    except:
+                        continue
+            
+            if vulnerable:
+                self.add_result("High", "XSS", "Potential XSS vulnerabilities detected")
+            else:
+                self.add_result("Low", "XSS", "No obvious XSS vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "XSS Error", f"XSS test failed: {str(e)}")
+    
+    def test_csrf(self, url):
+        try:
+            response = requests.get(url, timeout=10)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            forms = soup.find_all('form')
+            
+            vulnerable = False
+            details = "CSRF Tests:\n"
+            
+            for form in forms:
+                if not form.find('input', {'name': 'csrf_token'}) and \
+                   not form.find('input', {'name': 'csrfmiddlewaretoken'}) and \
+                   not form.find('input', {'name': '_token'}):
+                    vulnerable = True
+                    action = form.get('action', 'current URL')
+                    method = form.get('method', 'GET').upper()
+                    details += f"Form without CSRF protection found (Action: {action}, Method: {method})\n"
+                    break
+            
+            if vulnerable:
+                self.add_result("Medium", "CSRF", "Forms without CSRF protection detected")
+            else:
+                self.add_result("Low", "CSRF", "No obvious CSRF vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "CSRF Error", f"CSRF test failed: {str(e)}")
+    
+    def test_directory_traversal(self, url):
+        payloads = [
+            "../../../../etc/passwd",
+            "..%2F..%2F..%2Fetc%2Fpasswd",
+            "....//....//etc/passwd",
+            "%2e%2e%2fetc%2fpasswd",
+            "..\\..\\..\\windows\\win.ini",
+            "%2e%2e%5cwindows%5cwin.ini"
+        ]
+        
+        try:
+            parsed = urlparse(url)
+            base_url = f"{parsed.scheme}://{parsed.netloc}"
+            paths = [p for p in parsed.path.split('/') if p]
+            
+            vulnerable = False
+            details = "Directory Traversal Tests:\n"
+            
+            for payload in payloads:
+                test_url = f"{base_url}/{payload}"
+                try:
+                    response = requests.get(test_url, timeout=5)
+                    if "root:" in response.text or "bin:" in response.text or "[fonts]" in response.text:
+                        vulnerable = True
+                        details += f"Potential directory traversal with payload: {payload}\n"
+                        break
+                except:
+                    continue
+            
+            if vulnerable:
+                self.add_result("High", "Directory Traversal", "Potential directory traversal vulnerabilities detected")
+            else:
+                self.add_result("Low", "Directory Traversal", "No obvious directory traversal vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "Dir Traversal Error", f"Directory traversal test failed: {str(e)}")
+    
+    def test_command_injection(self, url):
+        payloads = [
+            ";id", "|id", "`id`", "$(id)", 
+            "|| ping -c 1 localhost", "&& ping -c 1 localhost",
+            "| dir", "&& dir", "; dir",
+            "| ls", "&& ls", "; ls"
+        ]
+        
+        try:
+            parsed = urlparse(url)
+            params = parse_qs(parsed.query)
+            
+            if not params:
+                self.add_result("Info", "Command Injection", "No parameters to test")
+                return
+            
+            vulnerable = False
+            details = "Command Injection Tests:\n"
+            
+            for param in params:
+                for payload in payloads:
+                    test_url = url.replace(f"{param}={params[param][0]}", f"{param}={params[param][0]}{payload}")
+                    try:
+                        response = requests.get(test_url, timeout=5)
+                        if "uid=" in response.text or "bytes from" in response.text or "Volume Serial" in response.text:
+                            vulnerable = True
+                            details += f"Potential command injection in {param} with payload: {payload}\n"
+                            break
+                    except:
+                        continue
+            
+            if vulnerable:
+                self.add_result("High", "Command Injection", "Potential command injection vulnerabilities detected")
+            else:
+                self.add_result("Low", "Command Injection", "No obvious command injection vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "CMD Injection Error", f"Command injection test failed: {str(e)}")
+    
+    def test_ssrf(self, url):
+        """Test for Server-Side Request Forgery vulnerabilities"""
+        test_servers = [
+            "http://169.254.169.254/latest/meta-data/",  # AWS metadata
+            "http://metadata.google.internal/computeMetadata/v1/",  # GCP metadata
+            "http://169.254.169.253/latest/meta-data/",  # Azure metadata
+            "http://localhost:80",
+            "http://127.0.0.1:80"
+        ]
+        
+        try:
+            parsed = urlparse(url)
+            params = parse_qs(parsed.query)
+            
+            if not params:
+                self.add_result("Info", "SSRF Test", "No parameters to test")
+                return
+            
+            vulnerable = False
+            details = "SSRF Tests:\n"
+            
+            for param in params:
+                for server in test_servers:
+                    test_url = url.replace(f"{param}={params[param][0]}", f"{param}={server}")
+                    try:
+                        response = requests.get(test_url, timeout=5)
+                        if response.status_code == 200 and any(
+                            keyword in response.text.lower() 
+                            for keyword in ["instance-id", "ami-id", "compute", "metadata"]
+                        ):
+                            vulnerable = True
+                            details += f"Potential SSRF in {param} with payload: {server}\n"
+                            break
+                    except:
+                        continue
+            
+            if vulnerable:
+                self.add_result("High", "SSRF", "Potential SSRF vulnerabilities detected")
+            else:
+                self.add_result("Low", "SSRF", "No obvious SSRF vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "SSRF Error", f"SSRF test failed: {str(e)}")
+    
+    def test_xxe(self, url):
+        """Test for XML External Entity vulnerabilities"""
+        xxe_payload = """<?xml version="1.0" encoding="ISO-8859-1"?>
+<!DOCTYPE foo [ <!ELEMENT foo ANY >
+<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
+<foo>&xxe;</foo>"""
+        
+        try:
+            # First check if the endpoint accepts XML
+            response = requests.get(url, timeout=5)
+            if "xml" not in response.headers.get('content-type', '').lower():
+                self.add_result("Info", "XXE Test", "Endpoint doesn't appear to accept XML")
+                return
+            
+            # Try XXE injection
+            headers = {'Content-Type': 'application/xml'}
+            response = requests.post(url, data=xxe_payload, headers=headers, timeout=5)
+            
+            if "root:" in response.text:
+                self.add_result("Critical", "XXE", "XML External Entity injection vulnerability detected")
+                self.details_text.insert(tk.END, "XXE Test:\nVulnerable to XXE injection\n")
+            else:
+                self.add_result("Low", "XXE", "No obvious XXE vulnerabilities found")
+                self.details_text.insert(tk.END, "XXE Test:\nNo XXE vulnerability detected\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "XXE Error", f"XXE test failed: {str(e)}")
+    
+    def test_idor(self, url):
+        """Test for Insecure Direct Object References"""
+        try:
+            # This is a simple test that checks for sequential IDs
+            # In a real scanner, you'd need more sophisticated tests
+            parsed = urlparse(url)
+            params = parse_qs(parsed.query)
+            
+            id_params = [p for p in params if 'id' in p.lower()]
+            
+            if not id_params:
+                self.add_result("Info", "IDOR Test", "No ID parameters to test")
+                return
+            
+            vulnerable = False
+            details = "IDOR Tests:\n"
+            
+            for param in id_params:
+                original_id = params[param][0]
+                if original_id.isdigit():
+                    test_id = str(int(original_id) + 1)
+                    test_url = url.replace(f"{param}={original_id}", f"{param}={test_id}")
+                    
+                    try:
+                        original_response = requests.get(url, timeout=5)
+                        test_response = requests.get(test_url, timeout=5)
+                        
+                        if test_response.status_code == 200 and \
+                           test_response.text != original_response.text and \
+                           len(test_response.text) > 100:  # Basic check to avoid 404 pages
+                            vulnerable = True
+                            details += f"Potential IDOR in {param} by changing {original_id} to {test_id}\n"
+                    except:
+                        continue
+            
+            if vulnerable:
+                self.add_result("Medium", "IDOR", "Potential IDOR vulnerabilities detected")
+            else:
+                self.add_result("Low", "IDOR", "No obvious IDOR vulnerabilities found")
+            
+            self.details_text.insert(tk.END, details + "\n")
+        
+        except Exception as e:
+            self.add_result("Medium", "IDOR Error", f"IDOR test failed: {str(e)}")
+    
+    def crawl_pages(self, base_url):
+        try:
+            visited = set()
+            to_visit = {base_url}
+            max_pages = self.scan_config['max_pages']
+            
+            details = "Crawling Results:\n"
+            
+            while to_visit and len(visited) < max_pages:
+                url = to_visit.pop()
+                if url in visited:
+                    continue
+                
+                try:
+                    response = requests.get(url, timeout=5)
+                    visited.add(url)
+                    details += f"Found: {url} ({response.status_code})\n"
+                    
+                    soup = BeautifulSoup(response.text, 'html.parser')
+                    
+                    # Find links
+                    for link in soup.find_all('a', href=True):
+                        href = link['href']
+                        if href.startswith('http') and base_url in href and href not in visited:
+                            to_visit.add(href)
+                        elif href.startswith('/'):
+                            absolute = urljoin(base_url, href)
+                            if absolute not in visited:
+                                to_visit.add(absolute)
+                    
+                    # Check for forms
+                    forms = soup.find_all('form')
+                    if forms:
+                        details += f"Found {len(forms)} forms on {url}\n"
+                    
+                    # Check for sensitive content
+                    sensitive_keywords = [
+                        'password', 'secret', 'key', 'token', 
+                        'admin', 'login', 'credentials', 'backup'
+                    ]
+                    page_text = soup.get_text().lower()
+                    found_keywords = [kw for kw in sensitive_keywords if kw in page_text]
+                    if found_keywords:
+                        details += f"Found sensitive keywords: {', '.join(found_keywords)}\n"
+                    
+                    self.root.update()
+                except:
+                    continue
+            
+            details += f"\nCrawled {len(visited)} pages\n"
+            self.details_text.insert(tk.END, details + "\n")
+            
+            if len(visited) >= max_pages:
+                self.add_result("Info", "Crawl Limit", f"Limited to {max_pages} pages for demo")
+        
+        except Exception as e:
+            self.add_result("Medium", "Crawl Error", f"Crawling failed: {str(e)}")
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    
+    # Set Windows style if available
+    if sys.platform == "win32":
+        from ctypes import windll
+        windll.shcore.SetProcessDpiAwareness(1)
+        
+    app = AdvancedVulnerabilityScanner(root)
+    root.mainloop()