martes, 23 de diciembre de 2008

Desarrollo de Exploits para Metasploit - Parte 3

Hola!,

Bueno, lo prometido es deuda, como le dije a mi amigo Boken, aqui esta el tutorial sobre el ataque de SMB:

SMB Credential Reflection Attack (Desarrollo de Exploits para Metasploit Parte 3)

Espero que les guste!.

Saludos.

domingo, 23 de noviembre de 2008

Protecciones de Software Basicas

Hola!,

Solo queria hacer un cross post del blog de S21sec que esta haciendo una recopilacion de las tecnicas que se utilizan para proteger el software, si bien son cosas muy basicas, me parece genial la recopilacion, que ya va por la parte 7:

Proteccion de Software Parte 1
Proteccion de Software Parte 2
Proteccion de Software Parte 3
Proteccion de Software Parte 4
Proteccion de Software Parte 5
Proteccion de Software Parte 6
Proteccion de Software Parte 7

Chau!

Un simple tutorial...

Hola!,

En la lista de Crackslatinos iniciaron un hilo de como crackear aplicaciones flash, en particular, de como descomprimir / comprimir un flash. Asi que hice este pequeño apunte.

Tal vez a alguien le sirve :P

Descomprimiendo un SWF con ZLIB

Mirror

Hasta pronto!.

sábado, 22 de noviembre de 2008

Desarrollo de exploits para Metasploit

Hola!,

Hoy quisiera hablar de la iniciativa de Boken. Este muchacho se ha planteado desarrollar una serie de tutoriales que hablen acerca de como escribir exploits para el framework Metasploit.

Ya ha escrito dos partes las cuales estan muy bien redactadas y explicadas en detalle, los invito a que hagan una lectura y se introduzcan en el tema.

Desarrollo de Exploits para Metasploit por Boken Parte 1
Desarrollo de Exploits para Metasploit por Boken Parte 2

Proximamente nos estara brindando una nueva entrega!.

Hasta pronto!.

domingo, 16 de noviembre de 2008

SMB Relay Attack - MS08-068 (CVE-2008-4037)

Hola Manola!,

El martes pasado, Microsoft publico nuevamente sus parches:

http://blogs.technet.com/msrc/archive/2008/11/11/november-2008-bulletin-release.aspx

De los dos parches, el que mas me llamo la atencion fue el ms08-068 que viene arrastrandose desde el año 2001 y que tiene que ver con el proceso de autenticacion de NTLM sobre SMB.

NTLM es un protocolo de autenticacion utilizado por Microsoft sobre varios protocolos, uno de ellos, SMB.

El ataque que se viene discutiendo desde hace mucho y ya hay varias tools que lo implementan.

Lo que nos permite, basicamente, es loguearnos es una maquina usando sus propias credenciales.

El protocolo NTLM funciona mas o menos de la siguiente manera:

1- El cliente se conecta al server.
2- El server genera un CHALLENGE (8 bytes) y lo envia al cliente.
3- El cliente toma ese CHALLENGE y con el HASH de su password, encrypta el CHALLENGE.
4- El cliente envia el CHALLENGE-ENCRIPTADO al server.
5- El server agarra el hash que tiene guardado y encripta el mismo CHALLENGE que envio al cliente y lo compara con el CHALLENGE-ENCRIPTADO, si ambos son iguales, ACCESO CONCEDIDO, sino, ACCESO DENEGADO.

Entonces el ataque consiste mas o menos en lo siguiente:

1- El cliente se conecta al server.
2- El server se conecta al cliente (ahora el cliente se convierte en server).
3- El cliente genera un challenge y lo envia al server.
4- El server agarra el challenge y se lo envia al cliente que esta esperando en la otra sesion.
5- El cliente toma el challenge y lo encripta con su hash y se lo envia al server.
6- El server agarra el challenge encriptado y se lo envia a la otra conexion que tiene con el cliente.
7- El server corta la conexion con el cliente.
8- El server tiene conexion con el cliente utilizando sus mismas credenciales. Por que? pues porque envio EL MISMO challenge al cliente que el cliente le envio.

Una vez que ya tenemos una sesion autenticada con el cliente, podemos por ejemplo, dropear un file en ADMIN$ y levantarlo como servicio mediante llamadas RPC.

Todo este ataque es sobre SMB, pero tambien puede realizarse sobre otros protocolos que soporten NTLM como HTTP, IMAP, POP3, etc.

Para el que quiera mayor informacion puede visitar esta paginas:

1- Metasploit and SMB Relay Attack
2- Multiprotocol NTLM Replay Attack
3- Multiprotocol NTLM Replay Attack (PDF)
4- Metasploit SMB Relay Attack Exploit
5- MS08-68 - SMB Relay (MSRC)
6- SMB Relay and SMB Relay2
7- SMB Reflection Made Way Too Easy
8- BackTrack 3: Demos of selected tools
9- Windows Smb Relay Exploit (Demo Video)

Hasta pronto!.

lunes, 10 de noviembre de 2008

Panda Internet Security/Antivirus+Firewall 2008 CPoint.sys Memory Corruption Vulnerability

Hola!,

Nuevamente vamos a hablar de una vuln que salio hace tiempo:

http://www.securityfocus.com/bid/28150

Es otra vez una falla trivial por falta de chequeos en los datos
que se pasan desde user-mode a kernel-mode.

En este caso se trata de una vulnerabilidad en cpoit.sys que es
usado por Panda Firewall + AntiVirus 2008.

En este caso la falla permite dejarnos inutilizada la maquina mediante un BSoD o bien,
si la explotacion es exitosa, conseguir privilegios de SYSTEM.

Como ya contamos con algo de informacion publica, desensamblaremos
el driver (cpoint.sys) con IDA. Lo primero que haremos sera buscar el
IOCTL Manager:

mov eax, offset sub_10B24
mov [ebx+70h], eax
mov [ebx+74h], eax

No tardamos mucho tiempo en encontrarlo :P

Sabemos de antemano que el IOCTL vulnerable es 0xba002848, entonces
busquemos donde es que se despacha ese IOCTL.

Lo primero que vemos es como comienza comparando el valor de ECX
(nuestro IOCTL) con diferentes valores (el resto de los IOCTL's):

mov edi, [ebx+60h]
mov ecx, [edi+0Ch]
cmp ecx, 0BA00283Ch
jz loc_10D1B

Se fija si nuestro IOCTL es igual a 0BA00283Ch, como no es igual, seguiremos
por esta parte:

cmp ecx, 0BA002840h
jz loc_10C7D

Como nuestro IOCTL tampoco es igual a 0BA002840h, llegaremos a esta otra parte:

cmp ecx, 0BA002844h
jz short loc_10B93

Nuevamente, la comparacion resultara falsa y terminaremos llegando a este basic block:

mov eax, [ebx+0Ch]
lea edx, [ebp+var_4]
push edx
push dword ptr [edi+4]
push eax
push dword ptr [edi+8]
push eax
push ecx
call sub_12254
mov edi, eax
jmp loc_10CFF

Como vemos, hay un call a sub_12254, vemamos que hay dentro de esa funcion:

mov edi, edi
push ebp
mov ebp, esp
mov ecx, [ebp+IOCTL]
push ebx
mov edx, 0BA002828h
cmp ecx, edx
push esi
push edi
mov eax, 0C000000Dh
ja loc_12633

Nuevamente, sigue comparando IOCTL's, ECX contiene nuestro IOCTL.
Como nuestro IOCTL es mayor que 0BA002828h, continuaremos por esta parte:

loc_12633:
mov edx, 0BA002848h
cmp ecx, edx
ja loc_12946

Aqui si estamos en el lugar correcto, primero compara nuestro IOCTL con 0BA002848h, y como
ECX no es mayor sino igual a 0BA002848h, entonces continuaremos por aqui:

jz loc_128BE

Aqui compara si es igual, lo cual es verdadero y entonces llegamos aqui:

loc_128BE:
cmp [ebp+IN_BUFFER_SIZE], 1008h
jb loc_12A7D

Aqui comprueba si el tamaño del buffer de entrada es menor a 0x1008; en caso de
que sea mayor, llegamos a esta parte:

mov esi, [ebp+IN_BUFFER_DATA]
cmp dword ptr [esi], 3F256B9Ah
jnz loc_12A7D

Aqui, saca datos de nuestro buffer y compara con una constante (3F256B9Ah), o sea que
en nuestro buffer tenemos que pasarle esa constante para poder llegar a la zona vulnerable:

mov ebx, offset dword_1335C
mov ecx, ebx ; SpinLock
call ds:KfAcquireSpinLock
mov byte_13360, al
mov eax, [esi+10Ch]
mov dword_134A4, eax
mov eax, [esi+8]
mov dword_133A0, eax
xor eax, eax
cmp [esi+8], eax
jbe short loc_1291B

En la ultima parte de este basic block, tenemos un check mas, en el cual pone EAX a 0 y comprueba
que nuestro in_buffer+8 tenga 0.

Luego de pasar ese check, llegamos aqui:

lea ecx, [esi+0Ch]

Aqui saca data de nuestro IN_BUFFER+0Ch y lo pone en ECX.

Esta es la parte del codigo vulnerable:

loc_12909:
mov edx, [ecx]
mov dword_133A4[eax*4], edx
inc eax
add ecx, 4
cmp eax, [esi+8]
jb short loc_12909

Mueve a EDX el contenido de nuestra data y lo escribe en una zona de la memoria del driver dword_133A4.
Luego, incrementa EAX, le suma 4 a nuestro IN_BUFFER y compara EAX (contador del loop) con ESI+8 que controlamos
nosotros, o sea que controlamos el loop y podemos hacer que escriba tantas veces como queramos en esa zona
de memoria del driver.

Vale aclarar que un poco mas abajo, pasando este primer loop, tenemos una una zona muy similar a esta en la cual
hay otro loop que tambien escribe en otra zona del driver.

Si nos fijamos, la zona de memoria en la cual podemos escribir se trata de la seccion .data del driver
y mirando un poco esa seccion, nos encontramos con que hay cosas interesantes para pisar con nuestra
data:

.data:00013630 ; struct _KEVENT Event
.data:00013630 Event _KEVENT <0> ; DATA XREF: sub_107D2+1E9o
.data:00013630 ; sub_10A46+97o
.data:00013640 ; struct _KEVENT stru_13640
.data:00013640 stru_13640 _KEVENT <0> ; DATA XREF: sub_107D2+1F4o
.data:00013640 ; IOCTL_Manager+F8o ...
.data:00013650 unk_13650 db 0 ; DATA XREF: sub_107D2+203o
.data:00013650 ; IOCTL_Manager+1AEo

Un poco mas abajo de donde comienza a copiar, tenemos una structura KEVENT que podriamos pisar
cuidadosamente para lograr ejecutar codigo. No es facil pero es una posibilidad interesante.

Yo he programado un plugin para Kartoffel que trigerea esta vulnerabilidad. Si alguien tiene ganas
y programa un exploit funcional y quiere compartirlo pues lo invito a que lo haga.

Panda cpoint.sys PoC:

http://www.4shared.com/file/70535874/3db3935b/panda_plugin.html

Tambie pueden descargar el plugin desde la misma web de kartoffel:

http://kartoffel.reversemode.com/downloads/panda_plugin.zip

Aqui les dejo la estructuta KEVENT:

kd> dt_KEVENT
ntdll!_KEVENT
+0x000 Header : _DISPATCHER_HEADER
kd> dt_DISPATCHER_HEADER
ntdll!_DISPATCHER_HEADER
+0x000 Type : UChar
+0x001 Absolute : UChar
+0x002 Size : UChar
+0x003 Inserted : UChar
+0x004 SignalState : Int4B
+0x008 WaitListHead : _LIST_ENTRY
kd> dt_LIST_ENTRY
ntdll!_LIST_ENTRY
+0x000 Flink : Ptr32 _LIST_ENTRY
+0x004 Blink : Ptr32 _LIST_ENTRY

Para el que quiero informacion adicional:

http://www.trapkit.de/advisories/TKADV2008-001.txt

Bueno por ahora es todo.

Saludos.

domingo, 2 de noviembre de 2008

Recopilacion MS08-67 (CVE-2008-4250)

Hola!,

Por el momento solo quiero hacer una recopilacion de informacion y PoC's sobre esta vulnerabilidad que salio al semana pasada en un parche "out of bound" de Microsoft.

Hasta el momento, creo que, de los exploits publicos que salieron, el mas eficiente es el de Metasploit:

Microsoft Server Service Relative Path Stack Corruption
Actualmente soporta varias plataformas como XP/2000/2003 y ademas, en 2003 puede bypassear DEP.

Luego tenemos algo menos eficiente pero que puede trigerear la vuln, como este PoC:

http://www.securityfocus.com/data/vulnerabilities/exploits/31874.zip

Y finalmente, tenemos los exploits de Core IMPACT y de Immunity CANVAS pero esos no son publicos :P

Si quieren mayor informacion acerca del bug pueden visitar:

http://blogs.technet.com/swi/archive/2008/10/23/More-detail-about-MS08-067.aspx

Aunque ya se ha discutido mucho acerca de este bug y hay mucha info dando vuelta en la web, en alguna entrada posterior me gustaria explicar en que consiste y como llegar hasta ahi.

Hoy 12/11/2008 salio un nuevo Proof of Concept:

http://www.milw0rm.com/exploits/7104

Hasta pronto!.

jueves, 30 de octubre de 2008

Novell NetWare Client nicm.sys Local Privilege Escalation Vulnerability

Hola!,

Hoy queria hablar un poco acerca de esta vulnerabilidad que aunque es vieja, resulta muy trivial:

http://labs.idefense.com/intelligence/vulnerabilities/display.php?id=637

Todo el problema esta en el driver ncim.sys que no valida los datos que le pasamos en el input buffer desde user mode.

Desensamblando un poco el codigo en IDA, ubicamos primero el IOCTL Manager:

[...]
push edi
mov dword ptr [esi+38h], offset sub_16E16
mov dword ptr [esi+80h], offset sub_16E16
mov dword ptr [esi+40h], offset sub_16E16
mov dword ptr [esi+70h], offset ioctl_manager
mov dword ptr [esi+78h], offset sub_16E16
push DeviceObject ; DeviceObject
[...]

Lo primero que hace es verificar que el IOCTL es del tipo METHOD_NEITHER:

[...]
mov edi, [ebp+Irp]
push edi
call sub_16BE2
mov [ebp+var_28], al
mov esi, [edi+60h]
mov [ebp+var_2C], esi
mov eax, [esi+0Ch] ; IOCTL
sub eax, 143B63h ; METHOD_NEITHER
jz loc_16D74 ; input_buffer
[...]

En caso de que lo sea, comprueba que el INPUT_BUFFER no sea 0:

[...]
loc_16D74: ; input_buffer
mov eax, [esi+10h]
test eax, eax
jz short loc_16DD5
[...]
y luego, guarda el addrs del INPUT_BUFFER en el stack:

[...]
lea ecx, [eax+10h]
mov [ebp+var_40], ecx
[...]

Como vemos, es INPUT_BUFFER+10h.

Luego, continua haciendo un par de cosas pero nunca mas toca esa variable del stack hasta aqui:

[...]
mov eax, [ebp+var_40]
mov eax, [eax]
mov ecx, [eax]
push eax
call dword ptr [ecx+8]
jmp short loc_16DCC
[...]

Como vemos, primero saca INPUT_BUFFER+10h del stack, luego saca el primer DWORD de lo apuntando por INPUT_BUFFER+10h y posteriormente, vuelve a sacar el contenido de lo apuntado por el contenido de INPUT_BUFFER+10h y termina llamando al contenido de ese pujntero + 8; en ese momento logramos ejecutar nuestro codigo en ring0 desde user. El INPUT_BUFFER lo manejamos nosotros y por ende tambien su contenido.

Pero para llegar hasta aqui, debemos de bypassear dos comprobaciones.

La primero de ellas es esta:

[...]
call NicmCreateInstance
mov ebx, eax
mov ecx, ebx
mov eax, 0C0000000h
and ecx, eax
cmp ecx, eax
jz short loc_16DC7
[...]

En donde si EAX y ECX son ambos iguales nos iremos fuera del IOCTL manager pero en caso de que sean diferentes, pues estaremos un poco mas cerca de la parte vulnerable. Hay que decir que el valor de EAX depende de la llamada a NicmCreateInstance() a la cual se le pasan varios parametros controlados por nosotros:

[...]
mov [ebp+var_40], ecx
push ecx ; inbuffer_addr+10h
push offset dword_10568 ; constants_array
push 0 ; NULL
push eax ; input_buffer_addrs
call NicmCreateInstance
[...]

El siguiente trozo de codigo es la ultima comprobacion que debemos de pasar para poder estar en la parte vulnerable:

[...]
call sub_1716A
mov eax, [ebp+var_40]
push dword ptr [eax]
call sub_16FD2
mov ecx, eax
mov eax, 0C0000000h
and ecx, eax
cmp ecx, eax
jnz short loc_16DCC
[...]

Aqui, ECX y EAX deben de ser diferentes para que el JNZ nos lleve a la parte vulnerable. Notese que el parametro pasado al segundo call (call sub_16FD2) es un valor que nosotros controlamos y es el contenido de INPUT_BUFFER+10h.

Si logramos hacer todo eso, entonces estaremos ejecutando codigo en ring0 desde una cuenta con pocos privilegios ya que el symlink: \\..\nicm esta abierto para todo el mundo :)

Si alguien quiere el .idb de IDA ya sabe donde encontrarme.

Saludos.

sábado, 26 de julio de 2008

SDT Cleaner v1.0

What is the SDT Cleaner?

SDT Cleaner is a tool that intends to clean the SSDT (system service descriptor table) from hooks.

  • The SDT Cleaner allows you to clean hooks installed by Anti-Virus and Firewalls.
  • This little tool (in this first release) tries to collect info from your current kernel and then switches to kernel land and if there are any hooks in SSDT, this tool will replace them with the original entries.
http://oss.coresecurity.com/projects/sdtcleaner.html

lunes, 26 de mayo de 2008

Ubuntu y ...

Esta vez solo pretendo dejar dos cosas que me sirvieron con la ultima version de Ubuntu (Hardy). Si buscan en la red seguro encontraran varias soluciones posibles, pero a mi son estas dos las que me han servido. De que estoy hablando?...pues de VMWare Server (que todavia no tiene un instalador oficial para Hardy) y de kyba-dock que tiene el mismo problema que VMWarer.

Calculo que VMWare no necesita presentacion, pero para los que no la conocen, les dejo el link VMware Server y para los que no sepan que es kiba-dock pues aqui les dejo otro link KIBA-DOCK.

Para instalar estas dos aplicaciones me encontre con varios problemas, pero gracias a estos dos post logre solucionarlos:

1- Instalando VMWare Server
2- Instalando Kiba-Dock

Espero que les sirvan.

Saludos.

martes, 6 de mayo de 2008

wubi - Ubuntu desde Windows!

El otro dia un amigo de trabajo y compañero de una lista de cracking en la que me encuentro (de paso decir que se trata de la mejor lista de cracking hispano, CracksLatinoS!) me paso un link interesante y me comento de que se tartaba y la verdad es que al probarlo no me arrepieto de haberlo escuchado.

Muchos usuarios (entre los cuales me incluyo) hemos utilizado VMWare en Windows para correr y probar algun que otro sistema Unix, como por ejemplo Ubuntu, Kubuntu, etc; tambien hemos utilizado alguna particion o disco aparte para instalarlo y volver a formatearlo a los 5 minutos y algunos otros utilizan cosas como cygwin para intentar correr aplicaciones *nix en Windows, pues esto es algo que les traera felicidad a aquellos que no se animan todavia a pasarse al lado del pinguinito =).

Se trata de un instalador que simplemente nos baja la ultima ISO de Ubuntu (actualmente la 8.04, Hardy) y la instala como si fuera una aplicacion mas de Windows. Podemos optar por elegir Ubuntu, Kubuntu, Xubuntu y alguna que otra distro mas. Luego, lo que hace es crear una carpeta con un file gigantesco (que depende del tamaño que le asignemos al nuevo OS durante la instalacion) donde se almacena todo el filesystem de Ubuntu, luego, toca el boot loader para darnos en la proxima reiniciada, la opcion de iniciar con Ubuntu o Windows.

La verdad a mi me resulto muy util y lo estoy probando con excelentes resultados, es un Ubuntu completo sobre NTFS. Muy recomendable. Yo venia probando Ubuntu desde su version 5.10 y la verdad es que nunca me decidia por completo a instalarlo en mi maquina host, siempre en VMs, pero Wubi fue el paso definitivo que me llevo al mundo de Linux :)

Pueden bajarse el instalador de Wubi desde aqui: Wubi

La instalacion en mi maquina llevo alrededor de 1 hora + o -.

Espero que muchos lo prueben y den sus opiniones.

Hasta la proxima.

jueves, 6 de marzo de 2008

Volviendo a casa!!!

Hola manola!.

Volvi a escribir algo despues de mucho tiempo, nada rebuscado, sino dos cosas muy simples, la primera de ellas:

[*] pyPeviewer

Un simple visualizador de los datos del PE Header hecho en python con pefile (Ero Carrera) y wxPython. Nada del otro mundo, solo para practica!.

[*] White Crackme by HMX0101 PARTE I

Un simple crackme con Name/Serial como para desempolvar viejas tools (y nuevas tambien) y volver a la programacion de keygens. Solo la primera parte, la segunda en poco tiempo :)

EL resto de los tutoriales escritos los pueden encontrar en ncr.4shared.com, ncr.rvlcnsecurity.com. Tambien pueden hacer alguna busqueda en google :P