[NCR2009] - Un crackme sencillo en .NET

Hola!,

Solo postear algo muy sencillo en .NET:

[NCR2009]Un.crackme.sencillo.en.NET

Saludos.

El anexo que debia...

Hola!,

Hace ya un tiempo, publique un tutorial sobre un sencillo Keygenme y me habia quedado pendiente el keygen asi que aca esta. Es un simple script en python muy mal hecho pero que cumple con su cometido!. Proximamente voy a estar subiendo un pequeño .doc o .pdf en el cual vamos a dejarlo un poco mas bonito programando una GUI en VisualWx!.


# little keygen to White Crackme (HMX0101) by NCR/CRC! [ReVeRsEr]
# 17/03/2009

import sys
import random

username = sys.stdin.readline().strip("\n")
namevalue = 0

# generate a name based value
for i in range(len(username)):
if ord(username[i]) >= 0x30 and ord(username[i]) <= 0x39:
namevalue += 2 * ord(username[i])
if ord(username[i]) >= 0x41 and ord(username[i]) <= 0x5a:
namevalue += ord(username[i]) + ord(username[i]) * 2
if ord(username[i]) >= 0x61 and ord(username[i]) <= 0x7a:
namevalue += ord(username[i]) << 2

namevalue = namevalue & 0xFFF

# generate a random number
randvalue = random.randint(1,9999)
if randvalue < 1000:
randvalue = str(0) + str(randvalue)
else:
randvalue = str(randvalue)

sp = str(((((int(randvalue[2]) << 4)) + namevalue) + (int(randvalue[3]) << 4)))

num1 = random.randint(0,9)
num11 = random.randint(0,9)
num13 = random.randint(0,9)

while 1:
if((num1 + int(randvalue[2]) + num11 + num13) != 0x18):
num1 = random.randint(0,9)
num11 = random.randint(0,9)
num13 = random.randint(0,9)
else:
break

num12 = random.randint(0,9)
num14 = random.randint(0,9)
num2 = random.randint(0,9)

while 1:
if(2 * (int(randvalue[3]) + num2 + num12 + num14) != 0x20):
num12 = random.randint(0,9)
num14 = random.randint(0,9)
num2 = random.randint(0,9)
else:
break

num16and17 = str(((ord(username[0]) >> 1) + num1) + 0x0a)
num18and19 = str(((ord(username[len(username) - 1]) >> 1) + num2) + 0x08)

print 'serial is: %s-%s-%s-%s' % (str(num1) + str(num2) + str(int(randvalue[2])) + str(int(randvalue[3])), sp, str(num11) + str(num12) + str(num13) + str(num14), str(num16and17) + str(num18and19))

Pueden bajar el script desde aca.

Hasta la proxima!.

pd. no se rian del codigo, son las 2:41 a.m!!!, tengan piedad! :P

Web

Hola!,

Solo queria dejarles saber que un amigo me ha ayudado a colgar todos los tutoriales que he escrito aqui:

http://www.reversinglabs.com.ar/ncr/

Saludos.

Windows 7 beta 2

Hola!,

Solo quiero hacer este post para darles mi opinion sobre la beta 2 de Windows 7.

Estuve usandola un poco en una VM y y la verdad es que quede asombrado. Yo en general busco un OS que me de estabilidad, seguridad y que ademas sea agradable a la vista, no me importa si es Windows, algun derivado Unix, *BSD o lo que sea, de hecho he sido usuario de Windows por mucho tiempo y el que mas a durado en mi maquina es Windows XP desde su version inicial hasta el SP3, pero ademas he pasado por Ubuntu, Kubuntu, Debian, en incluso he llegado a usar algun *BSD como Desktop BSD. Tambien, he probado las versiones de Windows Vista y debo decir que Windows 7 en mi particular opinion es mucho mas rapido, estable y agradable que Windows Vista (hablo como usuario final). Para mi, Windows Vista fue el fracaso mas grande de la historia de los OS, tal vez con el SP 1 lo arreglaron un poco pero sigue siendo un horror. Luego probe Windows Server 2008 y andaba mucho mejor que Windows Vista con lo cual pense: "apreiendieron de los errores", y ahora con Windows 7 creo que se estan reibindicando.

Como dije, la estabilidad de la beta es increible y ademas la rapidez con la que corre en una VM (teniendo en cuenta que cuando hice la prueba con Windows Vista, este se arrastraba por decirlo de alguna manera), ademas de que la interfaz es muy fluida y vistosa, asi que extrapolando los resultados obtenidos en la VM a una maquina fisica, imagino que andara mucho mejor, incluso escuche que este Windows 7 lo estan preparando especialmente para que corra en computadoras como las EEPC y similares, asi que esperemos que cuando salga la version final ahora cerca de octubre se mantengan o mejoren los resultados. Lastima que segun lei, va a ser el ultimo OS de Microsoft con soporte para 32 bist, los proximos solo contaran con versiones de 64 bits, pero bueno, es la evolucion :P ya no nos podemos conformar con que nuestra maquina nos reconozca solo 3 GB de Ram :P

Ah, me falta agregar que las pruebas las realice en una Intel Pentium Core 2 Duo 2 Ghz, con 2 GB de Ram.

Hasta la proxima!.

Estamos sick! :P

Bueno, con un amigo que no quiero decir quien es pero esta medio Sick!, estamos armando un nuevo proyecto aqui:

reversinglabs.com.ar

Vamos a intentar postear perdiodicamente algunas cosas referentes a ingenieria inversa asi que si quieren ver de que se trata los invito a que se den una vuelta por alli.

Todavia no hay mucho movimiento puesto que estamos ultimando detalles, viendo que posteamos que no, elijiendo temas y demas cosas que un proyecto asi implica.

Si alguno quiere formar parte de ello, pues que escriba a sick@reversing.com.ar o a ncr@reversing.com.ar

En fin...agendenlo!.

Hasta pronto!.

Asuntos pendientes (White Crackme)

Hola!,

Volvi de la muerte y junto conmigo traje algunos proyectos que me habian quedado en un volumen encriptado con TrueCrypt :P, uno de ellos era la solucion al White Crackme de HMX!. Para el que quiera leerla, aca la tiene:

White Crackme PARTE II by +NCR

Hasta la proxima!,
NCR

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.

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!.

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!.

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!.

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.

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!.

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.

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