VBox
4.0.3 (+Xoanon)
Como
Marigold dice, y como nosotros f�cilmente
podemos ver, las protecci�nes VBox consta de 3
DLLs que se copian en tu directorio
\\WINDOWS\\SYSTEM. Estos DLLs son: VBOXP403.DLL -
VBOXB403.DLL - VBOXT403.DLL. Todos estos DLLs
excepto el primero est�n empaquetados , as� que
nosotros enfocaremos nuestra atenci�n en
VBOXP403.DLL. Este DLL act�a como un
loader/unpacker (n. del t.:
cargador/desempaquetador) para los otros
(entre las otras cosas, de nuevo simplemente mira
el ensayo de marigold para una explicaci�n
completa), as� que yo pens� esto: si encuentro
el c�digo que desempaqueta el DLL, justo
despu�s del desempaquetando, puedo parchear
*desde dentro de VBOXP403.DLL* el c�digo de la
protecci�n que reside en el espacio de memoria
de VBOXT403.DLL.... y lo hice:) �No es un
aproximamiento inteligente? :)
Nota: Esta manera de parchear puede hacerse muy
f�cilmente con un parche en memoria (mira el ensayo
de Stone), pero los
parches en memoria siempre necesitan un loader, o
un programa TSR-like que simplemente se cargue
antes del objetivo. De esta manera, podemos
obtener (como ya dije) un crack limpio y
universal que s�lo necesita ser copiado en lugar
del DLL original ...
As� que, deja de hablar y adelante con el
cracking ahora ...
En primer lugar, adelanta el reloj del sistema
para que el objetivo caduque.
Ahora, t� EXE ha sido "VBoxeado" con
protecci�n de d�as de prueba, �correcto? As�
que ser� vulnerable a BPX GETLOCALTIME de
nuestro querido SoftICE. Aterrizar�s en este
c�digo (despu�s de PRET desde la rutina de
API) dentro de VBOXP403.DLL. Despu�s
utilizaremos el espacio de este c�digo para
agregar nuestro c�digo del parche de memoria.
:0500E720 81ECCC000000 sub esp, 000000CC
:0500E726 8D442410 lea eax, dword ptr [esp+10]
* aqu� agregaremos el parche de memoria despu�s*
:0500E72A 56 push esi
:0500E72B 50 push eax
* Reference To: KERNEL32.GetLocalTime, Ord:00F5h
|
:0500E72C FF1544C50105 Call dword ptr [0501C544]
:0500E732 8D4C2404 lea ecx, dword ptr [esp+04]
:0500E736 51 push ecx
* Reference To: KERNEL32.GetSystemTime, Ord:0135h
|
:0500E737 FF1540C50105 Call dword ptr [0501C540]
:0500E73D 668B4C240E mov cx, word ptr [esp+0E]
:0500E742 66390D32AC0105 cmp word ptr [0501AC32], cx
:0500E749 7540 jne 0500E78B
:0500E74B 668B44240C mov ax, word ptr [esp+0C]
:0500E750 66390530AC0105 cmp word ptr [0501AC30], ax
:0500E757 7532 jne 0500E78B
Prosiguiendo
con el traceado, encontrar�s este c�digo en
VBOXT403.DLL qu� chequea si el objetivo est�
caducado o no:
:07005EFB F6451408 cmp eax, [ebp+10]
:07005EFE 7402 jz 7005F02
* NOPealo *
y
:7005FAA 3B45F0 cmp eax, [ebp+10]
:7005FAD 751A jnz 7005FC9
* c�mbialo a JMP 7005FC9 *
Ok,
ahora te�ricamente nuestro parche est�
hecho.... La pantalla de VBox ya no aparecer�
PERO: �lo hicimos simplemente en memoria, c�mo
aplicarlo en el archivo si VBOXT403.DLL est�n
empaquetado?
Aqu� viene un poco Zen, como nuestro +teacher
dice... Sabemos que esa DLL debe desempaquetarse
en alguna parte, as� que empezamos a buscar la
rutina de desempaquetado poniendo un BPM 7005EFE
W (breakpoint en rango d en rango de
memoria en escritura). Esto significa que
SoftICE romper� s�lo cuando este espacio de
memoria sea accedido para escritura (qu� es,
en nuestro caso, el desempaquetando de
VBOXT403.DLL).
Ok, as� que pon este breakpoint y rel�nzalo.
Aterrizar�s en nuestro querido VBOXP403.DLL
aqu�:
:0500E856 8BD1 mov edx, ecx
:0500E858 83E203 and edx, 00000003
:0500E85B C1E902 shr ecx, 02
:0500E85E F3 repz
:0500E85F A5 movsd
* esto escribe el c�digo desempaquetado a DS:EDI *
:0500E860 FF249568E80005 jmp dword ptr [4*edx+0500E868]
:0500E867 90 nop
Como
notar�s, esta rutina es ejecutada muchas veces,
ya que el desempaquetando es hecho a peque�os
pasos. Sin embargo, nosotros enfocaremos nuestra
atenci�n s�lo cuando EDI alcance 07007000.
�Por qu�? bien, simple: puesto que nosotros
queremos parchear en DS:7005xxx, si EDI alcanza
07007000 esto significa que el c�digo que
nosotros necesitamos ya est� desempaquetado y
preparado para nuestro ' saqueo' :).
Ahora, problema #2: necesitamos espacio para
hacer nuestro parche de memoria. F�cil, mira
aqu�... este c�digo no tiene ning�n uso m�s,
desde que la protecci�n est� eliminada. As�
que podemos utilizar el espacio de memoria de
este c�digo de control de fecha para llevar a
cabo nuestro parche de memoria.
En primer lugar, tenemos que localizar la llamada
a esta rutina y NOPearlo, ya que nosotros
queremos usarlo para nuestro prop�sito. Aqu�
est�:
:05002880 6A00 push 00000000
:05002882 E899BE0000 call 0500E720
* simplemente NOPea esto y la DLL no llamar�
la comprobaci�n de fecha nunca m�s *
:05002887 83C404 add esp, 00000004
:0500288A 50 push eax
Ahora
para el parche de memoria. Tenemos que saltar a
nuestra rutina �correcto? as� que nosotros
necesitamos modificar este c�digo correcto
despu�s de que VBOXT403.DLL es desempaquetado en
memoria:
cambia
:0500E860 FF249568E80005 jmp dword ptr [4*edx+0500E868]
a
:0500E860 E9C1FEFFFF909090 jmp 500E726
* ok, ahora esto salta al punto de entrada de
nuestra rutina *
Aqu�
est� la rutina del parche de memoria:
:0500E726 81FF00700007 cmp edi, 07007000
* comprueba si el c�digo que nosotros necesitamos remendar est�
desempaquetado ya *
:0500E72C 7519 jne 0500E747
* act�a normalmente si no *
:0500E72E 66C787FEEEFFFF9090mov word ptr [edi+FFFFEEFE], 9090
* parchea en EDI-1102 = 7005EFE *
:0500E737 C687ADEFFFFFEB mov byte ptr [edi+FFFFEFAD], EB
* parchea en EDI-1053 = 7005FA0 *
:0500E73E 66C787A5EEFFFF9090 mov word ptr [edi+FFFFEEA5], 9090
* parchea en EDI-115B = 7005EA5 *
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0500E72C(C)
|
:0500E747 FF249568E80005 jmp dword ptr [4*edx+0500E868]
* esto es el salto normalmente ejecutado
despu�s de desempaquetar *
:0500E74E 90 nop
:0500E74F 90 nop
Notas
que yo he hecho otro parche en 0500E73E. �Para
qu� es? bien, el remienda este c�digo
:7005E9C F6451408 test byte ptr [ebp+14],08
:7005EA0 BE01000000 mov esi, 00000001
:7005EA5 745B jz 7005F02
* NOPealo *
El
cu�l desv�a el control del 'n�mero de
ejecuciones' (otra opci�n de VBox, pru�balo
con el constructor).
Bien... eso es todo. VBox est� totalmente muerto
ahora, gracias a Marigold y tu peque�o xOANINO
:) Parchea el VBOXP403.DLL seg�n este ensayo,
c�pialo a tu \\WINDOWS\\SYSTEM borra el original
y di ' CIAO CIAO' a WeiJuhn Li:)
|
VBox 4.10 (Marigold)
Esta
versi�n tiene un manojo entero de nuevos rasgos:
Son autentificados los checksums para todos los
archivos involucrados (para VBOXT410 dos veces)
<----+
Son calculados los checksums para las im�genes
de DLL en memoria (para VBOXT410 � dos veces)
<- el crack R.I.P de Xoanon
La presencia de Debugger en memoria es
descubierta <- Adi�s, adi�s espera para el
restablecimiento de virginidad
Desensamblando VBOXP410.DLL cae W32DASM; IDA
trabaja pero da un desensamblado err�neo
Al principio, yo fui impresionado profundamente (Tu
sabes... un cuerpo muerto en un cuarto cerrado
desde dentro... crimen perfecto). Yo me
prepar� para una pelea larga y dura: Yo
desempaquet� VBOXT410.DLL, redirig� el c�lculo
de checksum del archivo al archivo original
empaquetado, agregu� una secci�n con una copia
de c�digo original inalterado y remit� el
c�lculo de checksum de la imagen a �l (esto
s�lo parece simple ...). Ves, yo imagin�,
conociendo las maneras de Weijun Li, este chequeo
para la presencia de debugger implicaba alguna
modificaci�n sutil dentro de la funci�n
unilateral, por ejemplo, y que no habr�a sido
f�cil, si alguna vez fue posible, encontrar y
quitarlo. As� que, yo plane� usar esta
modificada DLL para recolectar informaci�n,
necesaria para desenvolver, sin usar SoftICE.
Entender�s mi desilusi�n cuando, despu�s de
ordenar las cosas fuera, yo encontr� una
funci�n que simplemente pone un flag; entonces
este flag es examinado,... salta... todo ese
material primitivo... ' Un farol', en una
palabra. La �nica esperanza, esta versi�n se
debe de haberse hecho con prisas, y la pr�xima
mostrar�, por fin, a esos crackers una cosa o
dos. �Bien, esper�moslo!
Aqu� est� esa llamada infame:
:07006F4B 6A00 push 00000000
:07006F4D 6AFF push FFFFFFFF
:07006F4F 683B9D0000 push 00009D3B
:07006F54 8D8D34FEFFFF lea ecx, dword ptr [ebp+FFFFFE34]
:07006F5A E8E1220100 call 07019240
:07006F5F 8945BC mov dword ptr [ebp-44], eax
En
presencia de debugger esta funci�n devuelve 26h,
cambia eax a 0 y nunca ver�s de nuevo ese
mensaje horrible: ' Si est�s usando un debugger
...'
Otras cosas para mencionar:
El checksum de la Imagen es calculado aqu�:
:070066EA 8BC3 mov eax, ebx
:070066EC 33FB xor edi, ebx
:070066EE F7D0 not eax
:070066F0 3145B0 xor dword ptr [ebp-50], eax
:070066F3 8D85F0FDFFFF lea eax, dword ptr [ebp-210] <- Buffer para el checksum
:070066F9 50 push eax
:070066FA 8D8520FFFFFF lea eax, dword ptr [ebp-E0] <- tabla de Relocalizacion
:07006700 81F7494C0000 xor edi, 00004C49
:07006706 50 push eax
:07006707 57 push edi <- longitud del c�digo
:07006708 33F3 xor esi, ebx
:0700670A FF75B0 push [ebp-50]
:0700670D 81F64A570000 xor esi, 0000574A
:07006713 8975C4 mov dword ptr [ebp-3C], esi
:07006716 89BD0CFFFFFF mov dword ptr [ebp+FFFFFF0C], edi
:0700671C 56 push esi <- C�digo RVA
:0700671D FF7584 push [ebp-7C]
:07006720 E843120000 call 07007968
y
aqu� (los par�metros son los mismos):
:070071B2 8D8514FEFFFF lea eax, dword ptr [ebp+FFFFFE14]
:070071B8 C645FC23 mov [ebp-04], 23
:070071BC 50 push eax
:070071BD 8D8520FFFFFF lea eax, dword ptr [ebp+FFFFFF20]
:070071C3 50 push eax
:070071C4 FFB50CFFFFFF push dword ptr [ebp+FFFFFF0C]
:070071CA FF75B0 push [ebp-50]
:070071CD FF75C4 push [ebp-3C]
:070071D0 FF7584 push [ebp-7C]
:070071D3 E890070000 call 07007968
Recuerda,
que cualquier BPX de SoftICE activo cambia el
c�digo realmente, as� que elim�nalos antes de
estas llamadas.
El checksum del archivo (VBOXT410.DLL) es
calculado aqu�:
:07006F62 8D458C lea eax, dword ptr [ebp-74]
:07006F65 50 push eax
:07006F66 8D8504FFFFFF lea eax, dword ptr [ebp+FFFFFF04]
:07006F6C 50 push eax
:07006F6D A138FE0407 mov eax, dword ptr [0704FE38]
:07006F72 FF7028 push [eax+28]
:07006F75 E836DF0000 call 07014EB0
Otro
control es hecho dentro de VBOXB410.DLL, cu�l le
pasa el resultado a PreviewParadise como
combinaci�n de dos par�metros:
:070072D8 8B450C mov eax, dword ptr [ebp+0C]
:070072DB 8B4D2C mov ecx, dword ptr [ebp+2C]
:070072DE F7D0 not eax
:070072E0 33C8 xor ecx, eax; 1=OK
:070072E2 7510 jne 070072F4
Cuando
sabes todo esto, puedes restaurar la virginidad
del objetivo de la misma manera que con la
versi�n anterior. Hay algunos cambios menores en
cabeceras de secciones empaquetadas y otras
cosas... Si realmente vas a hacer esto, lo
ordenar�s f�cilmente fuera.
�Pero qu� hay sobre un crack universal del
estilo de Xoanon para todos los programas
VBoxedados? Yo lo he conseguido como un derivado
de soluci�n a mi objetivo principal (total
desenvolvimiento, recuerdas). El VBOXT410.DLL
modificado que yo hice permite cualquier
parcheado en su c�digo ... �Alguna pregunta?
|
VBox 4.10 (Victor Porguen)
En
el pr�logo de Fravia a mi ensayo anterior, '
Derrotando Controles de Integridad de Archivo A
trav�s de Redireccion', �l observ� que 'la
investigaci�n viral aplicada al reversing tiene
mucho que ofrecer... ' Este art�culo describir�
como las t�cnicas tradicionales de codificaci�n
viral son aplicadas al software de tiempo
limitado. Espec�ficamente, yo detallar� un
concepto simple, sincero de redireccionamiento
del c�digo y lo aplicar� al sistema de
protecci�n VBOX 4.10 de Preview Systems. El
parche resultante permitir� el uso completo de
cualquier programa protegido de versi�n de
ensayo o versi�n comercial del producto. Sin
embargo, como una advertencia inicial yo
se�alar� que *todos* los archivos '
VBOXx410.DLL ' no son id�nticos; de hecho,
incluso no son compatibles entre ellos(pues
ser�a ciertamente muy irritante si realmente
hubieras comprado una aplicaci�n protegida por
VBOX que dependiera de una versi�n que fuera
reemplazada como consecuencia de una sesi�n de
'prueba' de otro producto). Mientras la
codificaci�n espec�fica descrito aqu� dentro
puede aplicarse f�cilmente a cualquier ' juego
de archivos' VBOXx410.DLL, y de hecho yo lo he
probado con �xito en cada juego que pude
encontrar, es importante que el lector comprenda
que hay diferencias entre estos juegos.
Como un asunto de cortes�a profesional,
referir� al lector al reciente ensayo de
Marigold, a quien yo contemplo con respeto,
titulado 'VBOX el Hellraiser o un farol' (por
un momento fugaz yo estuve tentado a subtitular
este ensayo ' Hellraiser II, el Crack de Tontos'
pero juicios mejores me superaron). El lector
debe notar las referencias contenidas en ese
art�culo al ' control de debugger' usado por
VBOX en luz del hecho de que la t�cnica de
parcheado que yo perfilo dejar� ese c�digo
intacto, as� los programas protegidos con VBox
continuar�n no funcionando si un debugger est�
en segundo plano. El derrotando de esa rutina no
es dif�cil, sin embargo, pero yo le dejar� esa
ocupaci�n al lector.
Las Metas - yo empec� este ensayo con tres metas
en mente: 1) idear un crack simple que derrotase
completamente todas las aplicaciones protegidas
con VBOXx410; 2) Hacerlo as� con una cantidad
m�nima de cambios de bytes, digamos no m�s de
250; y 3) en vista de que los chequeos de
integridad son desenfrenados en VBOX, no hacer
ning�n cambio al c�digo del programa. Esta meta
�ltima puede parecer imposible (quiz�s lo es
si uno toma una interpretaci�n verdaderamente
estricta del significado), pero la meta se
logr� de hecho a trav�s del uso del
redireccionamiento del API (y el borrando de
alg�n texto sin usar).
Qu� pueden Ense�arnos los Virus - Cuando
nosotros empezamos escribiendo virus de
computaci�n inicialmente, y usando ' las
t�cnicas del sigilo' para esconder su presencia,
lo hicimos as� reemplazando la direcci�n para
los manipuladores de DOS int 21 y BIOS Int 13 en
la tabla del vector de interrupci�n (IVT). Las
llamadas de verificaci�n de integridad de
programas para abrir y leer archivos o sectores
podr�a interceptarse entonces y el c�digo viral
ser reemplazado con el c�digo original. Sin
embargo, simplemente enganchar la direcci�n en
el IVT no era de ninguna ayuda si la rutina de
control de integridad ya hab�a enganchado la
interrupci�n y as� hab�a estado sent�ndose
debajo de nosotros (FluShot era un ejemplo, como
donde un gran numero de programas de ' protege tu
disco duro de escritura' que enganchaban
interrupci�n 13). Nuestro primer esfuerzo por
superar este obst�culo fue el virus 4096 en el
que nosotros pusimos un JMP LEJANO al principio
para el c�digo viral del manipulador de la
interrupci�n 21 que entonces reemplazar�a los
cinco bytes ' interruptor ' permiti�ndonos
acceso completo a las rutinas de DOS. La trampa
flag estaba entonces poniendo el CPU en modo paso
a paso. Unas instrucciones en una llamada de DOS
nuestra rutina de interrupci�n 1entonces
reinsertar�a los cinco bytes 'interruptor'
manteniendo as� siempre el control encima del
sistema operativo DOS.
Descubrir el 'punto' m�s bajo ('lowest
point') de la cadena de vector de
interrupci�n del DOS o de la BIOS fue logrado
f�cilmente poniendo el flag trampa y enviando
una llamada inocua a trav�s de la cadena y
observando la direcci�n en la pila durante la
rutina de interrupci�n 1.
Por qu� Esto es Importante - La rutina de
disimulo llevada a cabo por el virus 4096 tuvo
bastante �xito (tanto as�, de hecho, que �l
' escap�' dentro del salvaje antes de que
tuvi�ramos una oportunidad para completarlo
totalmente... pero eso es otra historia). Si
puedes tomar control del sistema operativo, no
hay virtualmente ninguna restricci�n en tus
habilidades. Llevando a cabo el JMP LEJANO del
virus 4096 modificamos el sistema operativo de
DOS realmente. Nosotros podemos hacer lo mismo
con una aplicaci�n WIN95 muy protegida, con
limitaci�n de tiempo,(bien, casi - no
modificaremos el sistema operativo directamente
debido a los problemas de transici�n de anillo,
sin embargo lo haremos tambi�n). Tomando
dominio de los APIs apropiados nosotros repartir
fuera los valores de retorno requeridos a la
aplicaci�n as� como tambi�n ' alimentar' los
par�metros correctos a la aplicaci�n y al
propio sistema operativo - esto es lo que yo
quiero decir en ' Logrando Redireccionamiento A
trav�s del enga�o al API.'
VBOXx410: C�mo Crackearlo, paso a paso - El
primer paso crackeando cualquier programa con
tiempo limitado es lograr una ejecuci�n exitosa
de la aplicaci�n, aun dentro de un debugger,
despu�s de que la limitaci�n de tiempo ha
expirado; s�lo entonces puede el ' crack
te�rico' ser escrito al ejecutable. El sistema
de protecci�n VBOX, sin embargo, usa una rutina
para descubrir la presencia de un debugger y
Marigold lo describe en su ensayo. Mientras puede
llevar tiempo localizar semejante rutina
solamente con herramientas de software,
ejecutando la aplicaci�n simult�neamente en
m�quinas id�nticas, un equip� con SoftICE y el
otro con un hardware basado en el emulador del
circuito, f�cilmente resalta la diferencia en el
valor de retorno de EAX desde CALL 7019240 en
offset 7006F5A. Es comprensible que la inmensa
mayor�a de lectores no tiene acceso a
herramientas de hardware basado en debugging y es
suficiente con solo tener presente que un BMPB
7006F5A X seguido por una ejecuci�n de la
LLAMADA y poniendo manualmente EAX a cero
mientras est� bajo SoftICE nos bastar� para
permitir al programa ejecutar normalmente bajo un
debugger. El lector es avisado que, debido a las
rutinas de c�digo de integridad de VBOX, s�lo
debe usarse breakpoints de registro de debug (excepto,
por supuesto, dentro de nuestra rutina de
disimulo) como opuesto a tradicionales CC
breakpoints.
Caminando a trav�s del c�digo llegamos a la
llamada a DialogBoxParamA en offset 70025C3 en la
versi�n ' Trial' o en offset 8002912 en la
versi�n 'Comercial' que despliega la pantalla de
Limitaci�n de tiempo de VBOX. El valor del
retorno para ' Try' es cero, el valor para '
Quit' es uno. De nuevo, pulsando ' el bot�n de
Quit' y entonces poniendo manualmente el valor de
EAX a cero mientras estamos bajo SoftICE el
programa nos permitir� continuar. El
procedimiento final es caminar a trav�s del
c�digo hasta que alcancemos la llamada de
RaiseException en offset 7035629 qu� despliega
un mensaje de expiraci�n y termina. Si nosotros
simplemente ' caminamos sobre' esta llamada, y
ajustamos la pila en consecuencia, el programa se
ejecuta perfectamente. As�, el crack al sistema
de protecci�n de VBOX entera, tanto si es la
edici�n de Prueba o la Comercial es hacer a la
llamada de DialogBoxParamA devolver cero y hacer
a la llamada de RaiseException volver sin
ejecutar. Nada podr�a ser m�s simple; la parte
desafiante, sin embargo, es llevar a cabo el
crack en vista de las variadas y diversas rutinas
de protecci�n que VBOX lleva a cabo (es
decir, empaquetado, verificaci�n de la imagen de
memoria, encifrado, etc.)
Obviamente nosotros no podemos NOPear simplemente
el c�digo, ya que est� empaquetado y
repetidamente verificado. Sin embargo, �requiere
VBOX que las Llamadas sean ejecutadas
completamente? Sabemos que la respuesta es ' No'
para la llamada de RaiseException, pero �tiene
la llamada de DialogBoxParamA que ser ejecutada o
VBOX s�lo verifica el registro de EAX en el
retorno? De nuevo nosotros caminamos a trav�s
del c�digo con SoftICE (recordando tratar con
la rutina de control de debug) y rompe en
DialogBoxParamA. En lugar de ejecutar la LLAMADA,
le ponemos el registro EIP manualmente en el
offset de la instrucci�n que sigue a la LLAMADA
y ajustamos la pila en consecuencia. Entonces
ponemos EAX a cero y permitimos la ejecuci�n del
programa... y el programa falla. Ahora sabemos
que la llamada de DialogBoxParamA debe ejecutarse
para satisfacer el sistema de protecci�n de
VBOX.
El paso pr�ximo es determinar donde nuestro '
espacio de trabajo' residir�. Mirando a trav�s
de VBOXP410.DLL vemos se compil� con Microsoft
Visual C++ Run Time Library la que cort�smente
incluye una variedad de c�digo desaprovechado e
in�til y de texto. Un �rea que inmediatamente
aparece como un posible �rea de trabajo es la
inmensa lista de sitios geogr�ficos que comienza
alrededor del offset 206D4 o as� del archivo.
Comenzando con el querido hogar de Turqu�a (en
offset 20718 del archivo) borramos dos o
trescientos bytes de texto simplemente con ceros
y ejecutamos el programa - y corre perfectamente.
VBOX no est� verificando esta porci�n de
archivo ni en memoria ni en disco; as� que ahora
tenemos sitio suficiente en el que insertar
nuestra ' cautelosa rutina de cracking'. Una vez
m�s, arrancamos SoftICE y rompemos (recordando
s�lo usar registros de debug debido a las
rutinas de control de integridad) en el punto
de la entrada a VBOXP410.DLL que est� en offset
5001F99 de memoria . Esto corresponde al offset
1399 de archivo y es donde nosotros insertaremos
nuestro ' interruptor ' para la rutina de
disimulo.
Pero antes de que modifiquemos el ejecutable en
disco debemos determinar primero si VBOX est�
verificando la integridad del c�digo reemplazado
del propio archivo del disco (no estamos
interesados en si VBOX verifica el c�digo en
memoria porque lo habremos restaurado). Sin
embargo, ya que nuestra rutina de disimulo
estar� cambiando memoria, debemos modificar la
cabecera de PE para que las secciones .text y
.rdata sean escribibles. Actualmente, las
caracter�sticas para .text son C�digo,
Ejecutable, Le�ble (60000020) mientras .rdata
tiene las caracter�sticas de Datos
Inicializados, Le�ble (40000040). Estas dos
entradas de 'double word' deben modificarse para
que las secciones sean escribibles (de otra
forma nuestras disimuladas modificaciones
crear�n fallos de p�gina). La
determinaci�n de si VBOX est� verificando la
integridad de �stas �reas del c�digo desde el
archivo del disco s� hace f�cilmente:
Simplemente cambia la cabecera en el archivo del
disco y entonces borra el ' interruptor ' con
cinco NOPs, ponemos un BMPB 5001F99 X y
ejecutamos la aplicaci�n. Cuando SoftICE rompe
en la carga de VBOXP410.DLL en 5001F99 insertamos
el c�digo original manualmente y permitimos a la
aplicaci�n continuar cargando y ejecutando
normalmente(recordando todav�a el c�digo de
descubrimiento de debug). El programa se
ejecuta normalmente y as� confirma que VBOX no
est� verificando la integridad de la cabecera o
la situaci�n del c�digo del interruptor del
archivo desde el disco - esto es todo
esencialmente ' colina abajo' desde aqu� .
Para facilitar la comprensi�n, lo siguiente es
el interruptor y las rutinas de disimulo en
formato' c�digo fuente'. Ap�ndice A tiene el
volcado de SoftICE de los valores del byte reales
que corresponden a offsets de memoria y valores
del byte del c�digo. Este es el crack que
derrota a VBOX 4.10:
Entry_Point
jmp Restore_Original_Code
^
|
|--- VBOXP410.DLL el c�digo est� aqu�
|
v
Restore_Original_Code:
mov dword ptr [Entry_Point],020496B8
mov byte ptr [Entry_Point+4],05
mov eax,[KERNEL32!EnterCriticalSection]
mov dword ptr [KERNEL32!EnterCriticalSection],New_Critical_Handler
mov [Critical_Section_Hdlr],eax
jmp Entry_Point
Counter:
dw 0
Critical_Section_Hdlr:
dd 0
DLG_Hdlr:
dd 0
DLG_Procedure_Hdlr:
dd 0
Return_From_DLG:
dd 0
New_Critical_Handler:
inc word ptr [Counter]
cmp word ptr [Counter],4000
jz Hook_DialogBox_for_VBOXC410
cmp word ptr [Counter],2EOO
jnz True_Critical_Handler
Hook_APIs_for_VBOXT410:
mov dword ptr [KERNEL32!RaiseException],New_Exception_Handler
mov eax,[USER32!DialogBoxParamA]
mov [DLG_Hdlr],eax
mov dword ptr [USER32!DialogBoxParamA],New_Dialog_Handler
jmp True_Critical_Handler
Hook_DialogBox_for_VBOXC410:
mov eax,[USER32!DialogBoxParamA]
mov [DLG_Hdlr],eax
mov dword ptr [USER32!DialogBoxParamA],New_Dialog_Handler
True_Critical_Handler:
jmp [Critical_Section_Hdlr]
New_Exception_Handler:
ret 10
New_Dialog_Handler:
mov eax,[esp+1O]
mov [DLG_Procedure_Hdlr],eax
mov dword ptr [esp+1O],New_DLG_Procedure_Handler
pop dword ptr [Return_From_DLG]
push Back_From_DLG_Call
jmp [Dlg_Hdlr]
Back_From_DLG_Call:
xor eax,eax
mov word ptr [New_Critical_Handler],4feb
jmp [Return_From_DLG]
New_DLG_Procedure_Handler:
cmp dword ptr [esp+08],18
jnz True_DLG_Procedure_Handler
mov dword ptr [esp+08],111
mov dword ptr [esp+OC],495
True_DLG_Procedure_Handler:
jmp [DLG_Procedure_Hdlr]
Una
Explicaci�n del C�digo - El punto de entrada es
la situaci�n de los cinco bytes, el c�digo '
interruptor ' y, espec�ficamente, est�
localizado en el offset 1399 de archivo y en el
offset 5001F99 de memoria. Al cargar el DLL, este
c�digo interruptor es restaurado por la rutina
de RestoreOriginalCode inmediatamente, as� todo
el c�digo de VBOX es id�ntico ahora a la
versi�n no parcheada. Hemos logrado la Meta #3 y
por consiguiente todas las rutinas de control de
memoria de VBOX confirmar�n la integridad de ese
c�digo. La rutina de RestoreOriginalCode
tambi�n sirve para otro prop�sito: ' engancha'
el EnterCriticalSection API que VBOX debe llamar
para permitir la sincronizaci�n de la exclusi�n
mutua y debe reemplazarlo con
New_Critical_Handler.
La rutina New_Critical_Handler es responsable de
espera por VBOXT410.DLL (y VBOXC410.DLL, para
la versi�n comercial)para desempaquetar y
entonces enganchar� el RaiseException y
DialogBoxParamA APIs que son el punto focal de
nuestro crack. El RaiseException API es vectorado
a la instrucci�n RET 10, qu� por supuesto no
hace nada m�s que RETORNAR con un bit de
limpieza de la pila. DialogBoxParamA es vectorado
a New_Dialog_Handler que es un poco m�s
inteligente.
La rutina de New_Dialog_Handler logra dos tareas:
1) reemplaza el valor de RETORNO en la pila con
el offset de Back_From_DLG_Call; y 2) engancha
DialogBoxProcedure que procesa los mensajes
enviados a la caja de di�logo con
New_DLG_Procedure_Handler.
New_DLG_Procedure_Handler mira por el mensaje de
ShowWindow para ser enviado por el sistema
operativo a la caja de di�logo y lo reemplaza
con el mensaje y par�metro necesario para cerrar
la caja. El control es devuelto a
Back_From_DLG_Call que pone un cero en el
registro EAX y entonces ' cierra la puerta' en
New_Critical_Handler poniendo un JMP a la
instrucci�n True_Critical_Handler (EB 4F) como
primera instrucci�n de esa rutina. Nosotros
entonces JMP atr�s al c�digo de VBOX que
sigui� a la LLAMADA DialogBoxParamaA que hab�a
transferido control a nuestro New_Dialog_Handler.
Brevemente despu�s de esto VBOX intentar�
desplegar el mensaje de 'expired' por v�a de
RaiseException API. Por supuesto, nosotros hemos
enganchado ese c�digo con New_Exception_Handler
y volveremos cort�smente a VBOX sin ejecutar la
LLAMADA. El programa se ejecutar� entonces
normalmente.
Un Resumen, Por favor - Aqu� est� el fluir de
la l�gica: 1) cargas VBOXP410.DLL; el c�digo
del interruptor salta a la rutina de disimulo que
reemplaza el c�digo del interruptor, engancha
EnterCriticalSection, y encadena atr�s a
VBOXP410.DLL. 2) el New_Critical_Handler espera
por VBOX para ' bajar sus pantalones' y entonces
engancha el RaiseException y DialogBoxParamA. 3)
el New_Dialog_Handler entonces ' enga�a ' al fin
de la caja de di�logo, y devuelve valores a la
aplicaci�n, para alimentar al procedimiento de
caja de di�logo de VBOX con los valores que le
gustar�a ver, en exactamente el momento correcto
que le gustar�a verlos, e interceptando el
retorno. 4) El RaiseException llamado por VBOX es
interceptado entonces y Retorna sin hacer nada.
Una Demanda Para El Lector - por supuesto, este
ensayo no est� pensado para animar al robo de
programas de software, o cualquier propiedad
intelectual de esa materia. En cambio est�
dise�ado para fomentar un entendimiento mejor de
las t�cnicas de ingenier�a inversa y los
sistemas de protecci�n del software. Yo espero
que hayas disfrutado con la lectura de este
ensayo, y que quiz�s hayas aprendido algo
tambi�n. Si lo hiciste, yo apreciar�a que si me
dejaras caer un email que me permita conocer tus
pensamientos. Yo disfrutar�a much�simo
oy�ndolo de ti.
Ap�ndice A - Valores de Bytes y Offsets de
Memoria
; (El C�digo del Interruptor) Esto corresponde al offset 1399 de Archivo en VBOXP410.DLL
5001F99 E97AF90100 JMP 05021918
^
|
|--- VBOXP410.DLL el c�digo est� aqu�
|
v
;(La Rutina de Disimulo) Esto corresponde al offset 20718 de Archivo en VBOXP410.DLL
5021918 C705991F0005B8960402 MOV DWORD PTR [05001F99],020496B8
5021922 C6059D1F000505 MOV BYTE PTR [05001F9D],05
5021929 A1AOB50205 MOV EAX,[0502B5A0]
502192E C705AOB5020554190205 MOV DWORD PTR [0502B5A0],05021954
5021938 A344190205 MOV [05021944],EAX
502193D E95706FEFF JMP 05001F99
5021942 0000
5021944 0000
5021946 0000
5021948 0000
502194A 0000
502194C 0000
502194E 0000
5021950 0000
5021952 0000
5021954 66FF0542190205 INC WORD PTR [05021942]
502195B 66813D421902050040 CMP WORD PTR [05021942],4000
5021964 742B JZ 05021991
5021966 66813D42190205002E CMP WORD PTR [05021942],2EOO
502196F 7534 JNZ 050219A5
5021971 C70590890507AB190205 MOV DWORD PTR [07058990],050219AB
502197B A1348A0507 MOV EAX,[07058A34]
5021980 A348190205 MOV [05021948],EAX
5021985 C705348A0507AE190205 MOV DWORD PTR [07058A34],050219AE
502198F EB14 JMP 050219A5
5021991 A1E8760808 MOV EAX,[080876E8]
5021996 A348190205 MOV [05021948],EAX
502199B C705E8760808AE190205 MOV DWORD PTR [080876E8],050219AE
50219A5 FF2544190205 JMP [05021944]
50219AB C21000 RET 0010
50219AE 8B442410 MOV EAX,[ESP+10]
50219B2 A34C190205 MOV [0502194C],EAX
50219B7 C7442410E1190205 MOV DWORD PTR [ESP+10],050219E1
50219BF 8F0550190205 POP DWORD PTR [05021950]
50219C5 68D0190205 PUSH 050219DO
50219CA FF2548190205 JMP [05021948]
50219DO 33CO XOR EAX,EAX
50219D2 66C70554190205EB4F MOV WORD PTR [05021954],4FEB
50219DB FF2550190205 JMP [05021950]
50219E1 837C240818 CMP DWORD PTR [ESP+08],18
50219E6 7510 JNZ 050219F8
50219E8 C744240811010000 MOV DWORD PTR [ESP+08],00000111
50219FO C744240C95040000 MOV DWORD PTR [ESP+OC],00000495
50219F8 FF254C190205 JMP [0502194C]
|
VBox 4.20 (PLUMe)
Herramientas
requeridas
TRW y
MKPE
SoftICE
Puedes haber o�do hablar ya de TR&TRW. Es un
debugger maravilloso proporcionado por Liutaotao.
Yo no podr�a decir lo mucho que me gusta.
VBOXT410.DLL no puede encontrar TRW en absoluto.
No podr�a darte un parche para VBox. Simplemente
puedo decirte c�mo trabaja VBox.
En primer lugar, instala el constructor de VBox (necesitas
recibir un archivo .prv desde su webserver, as�
que conecta a internet para esto y llena el
impreso necesario). Entonces escoge un
archivo .EXE para proteger (tambi�n podr�as
escoger un .DLL o un .OCX, pero escoge un .EXE
porque es mejor y m�s f�cil para los
prop�sitos de cracking. Yo escog� los Official
phrozen crew trial crackme) y envu�lvelo con
VBox usando el constructor (escoge ahora la
protecci�n de d�as de Prueba).
Ahora empieza la diversi�n. Y como podemos ver
f�cilmente, el esquema entero de protecci�n de
VBox consiste en s�lo un dll que es copiado en
tu directorio \\WINDOWS\\VBox\\command. El nombre
de nuestro blanco DLL es VBOXT402.DLL. Est�
empaquetado.
Paso 1
Aqu� te mostrar� c�mo usar TRW.
Ejecuta TRW, selecciona el bot�n 'hide'.
Entonces aparece un icono verde en la esquina
derecha.
Puedes hacer click con el bot�n derecho en �l.
Aparece as�.
Paso 2
Cambiemos el tiempo a 30 d�as despu�s. Ahora
puedes ejecutar CRACKME.EXE. Cuando la ventana de
VBox aparece, CTRL-N, entra en TRW. Puedes usar
'hwnd' para encontrar el hwnd de ventana de VBox.
Algo como xxxx.
bpmsg xxxx wm_destroy - simplemente como en
SoftICE
g - regresas a VBox
Aprieta el bot�n de 'quit'.
Ahora est�s en TRW.
bc * - elimina los breakpoints
Aprieta F12 unas veces, hasta que vengas aqu� en
VBOXT402.DLL
07006079: call [dword dialogparama]
0700607f: mov esi,eax ; si presionas 'try' eax=0, 'quit' eax=1; As� que
cambia eax a 0 ... r eax 0.
Ah�
tienes algunos otros controles
07001c03: cmp [ebp-10],eax ; si eax=[ebp-10], el dialogo de error aparecer�; as� que
cambia eax
07001c06: jne 07001c2c
07001c08: lea eax,[ebp+10]
07001c0b: lea ecx,[ebp-74]
07001c0e: push eax
07001c0f: mov [ebp-78],ebx
07001c12: call 0702e7d0
07001c17: lea eax,[ebp-7c]
07001c1a: push 07070568
07001c1f: push eax
07001c20: mov [dword ebp-7c],0706e004
07001c27: call 070570a0
07001c2c: lea ecx,[ebp-28]
07001c2f: mov [byte ebp-040,04
07001c2c: lea ecx,[ebp-28]
07001c2f: mov [byte ebp-04],04
07001c33: call 0702d440
07001c38: lea ecx,[ebp-18]
07001c3b: mov [byte ebp-04],02
07001c3f: call 0702d440
.......
07001c7c: call 07032570
07001c71: cmp [ebp-10],eax ; otro control.
07001c74: jne 07001f9b ; si eax=[ebp-10], el dialogo de error aparecer�; as� que
cambia eax
Ok,
ahora te�ricamente nuestro parche esta hecho ...
1. 07006079: call [dword dialogparama] parch. a
07006079: xor eax,eax
0700607b: nop
0700607c: nop
0700607d: nop
0700607e: nop
2. 07001c06: jne 07001c2c parch. a
07001c06: jmp 07001c2c
3. 07001c74: jne 07001f9b parch. a
07001c74: jmp 07001f9b
La
pantalla de VBox ya no aparecer� PERO: lo
hicimos s�lo en memoria que no es permanente,
como todos conocen muy bien... Debemos aplicar
nuestro parche ahora en el archivo real. �Pero
VBOXT403.DLL est� empaquetado?
Paso 3 Cierra TRW. (La funci�n bpm
de TRW parece no trabajar all�)
Ejecutemos SoftICE. (VBox desempaqueta el c�digo
primeramente, entonces comprueba SoftICE)
Carga crackme.exe
bpm xxxx: 07006079 w;
Ok, as� poniendo este breakpoint y rearrancando.
Aterrizaras en VBOXT410.DLL aqu�:
009c01b7: repz movsd
009c01b9: mov ecx,edx
009c01bb: and ecx,03
.......
�Oh
DIOS m�o! Est� encriptado antes de correr. Por
lo tanto no podr�s encontrar �ste c�digo
dentro de VBOXT410.DLL.
bpm xxxx: 009c01b7 w;
As� que pon este breakpoint y re-enciende.
Aterrizaras aqu�:
00a001b7:repz movsd
00a001b9:mov ecx,edx
00a001bb:and ecx,03
.......
Prueba
de nuevo.
bpm xxxx:00a001b7 w;
As� que pon este breakpoint y re-enciende.
Aterrizaras aqu�:
07093c27:mov [edi],al
07093c23:inc edi
07093c24:inc ebp
.......
Prueba
de nuevo.
bpm xxxx:070093c27 w;
As� que pon este breakpoint y re-enciende.
Aterrizaras aqu�:
:07093422 03D0 add edx, eax
:07093424 C1E902 shr ecx, 02
:07093427 F3 repz
:07093428 A5 movsd ; �aqu�!
:07093429 8BCD mov ecx, ebp
:0709342B 89542414 mov dword ptr [esp+14], edx
:0709342F 83E103 and ecx, 00000003
:07093432 F3 repz
:07093433 A4 movsb
:07093434 8B4344 mov eax, dword ptr [ebx+44]
Si,
puedes encontrar este c�digo en VBOTT410.DLL
Francamente, no encontr� una manera elegante de
parchearlo. Se modifica mucho. Si encuentras una
manera elegante de parchearlo, por favor h�zmelo saber.
Ahora intento conseguir una rutina limpia usando
otro acercamiento. Pero no siempre funciona,
�ten cuidado!
As� que olvid�monos de nuestros VBOXT402.DLL
durante alg�n tiempo. Simplemente queremos una
rutina limpia.
Corre TRW.
Cambia eax en:
1. 07006079: call [dword dialogparama]
2. 07001c06: jne 07001c2c
3. 07001c74: jne 07001f9b
As�
que solamente ejecuto nuestro 'Official phrozen
crew trial crackme' una ventana aparece. Aprieta
' ok', entra en la ventana de su rutina
principal.
Ahora encuentra su hwnd (sabes hacer esto,
espero :-), y entonces s�lo bpmsg en �l
dentro de TRW.
Ahora: g; te remontas a la ventana de phrozen,
presiona 'exit'.
Justo como antes TRW aparece. Aprieta F12 tanto
como sea necesario para encontrar el c�digo
pertinente ...
00401029: push 00
00401030: push 00401046
00401032: push 00
00401034: push 01
0040103a: push dword 0402dd87
0040103f: call 00401313
00401041: push 00 ; aterrizas aqu�
00401046: call 0040127d
.......: ...
Puedes
ir directamente a xxxx:00401029 y puedes
descargarlo de memoria usando el comando
'pedump'.
Entonces consigues dump1.exe.
MKPE dump1.exe -a -s -f -i3 -ldlllist.sam
FILEOUT.EXE es nuestra rutina 'limpia', y
funciona muy bien... as� que byebye VBox 4.2
Como puedes ver ahora -una vez m�s - las
protecciones comerciales 'usar y listo' no son
tan seguras como ellos afirman (mira en http://www.previewsoftware.com).
Pero a veces mi aproximaci�n de FILEOUT.EXE no
trabaja... Yo me pregunto por qu� ...
Desgraciadamente no encontr� ning�n modelo
claro para invertir este peque�o misterio. Si
entiendes esto, o si tienes cualquier otro
m�todo bueno para este objetivo, por favor h�zmelo saber,
modificaremos este ensayo juntos.
|
VBox 4.20 (alpine)
Herramientas
requeridas
SoftICE
ProcDump
Paso 1: El truco del molesto anti-debug
Arranca tu OS sin habilitar SoftICE. Carga tu
programa en TurboDebugger y ejec�talo (F9).
Romper� en un INT 3. Mira en SI y DI y ver�s
los valores m�gicos (SI=4647h; DI=4A4Dh).
Camina encima del INT 3 hasta que pases el RET.
Apunta la direcci�n del Salto (jmp [ebp-07]).
Puedes dejar TurboDebugger ahora.
ebp-07 apunta al buffer temporal donde se
ejecutan los INT 3 y otras instrucciones. Ahora
relanza con SoftICE habilitado.
El truco anunciado trabaja como lo siguiente: VBox prepara SEH y
entonces Llama nuestro INT 3. Si SoftICE est�
presente manejar� el INT 3 sin levantar una
excepci�n, por lo tanto VBox sabe que SoftICE
est� instalado. Si una excepci�n se levanta el
programa contin�a como normal.
Carga el programa en el Symbol Loader. Ahora pon
un breakoint en esa direcci�n, que anotaste
antes. Pero no uses BPX debido a los controles de
CRC. Usa BPMB X. Ahora ejec�talo; atr�s en
SoftICE levantaremos una excepci�n. Modifica el
valor guardado en [ebp-07] a 0 tecleando ed
(ebp-07) 0. Eso causar� una. Ahora aprieta F5 y
no consigues ese mensaje molesto pero consigues
un dialogbox. Aprieta ' Try' y ser�s lanzado
atr�s de nuevo a SoftICE.
Otra vez cambia el valor de [ebp-07] a 0. Antes
de apretar F5... tenemos que poner un breakpoint
Paso 2: Encontrando el salto final
Para encontrar el Salto final nosotros tenemos
que saber lo que el programa har� despu�s. Por
lo menos podemos suponerlo:) Tiene que conseguir
las direcciones de APIs que usamos en nuestro
programa. Esto est� hecho a trav�s de
GetProcAddress. Rompe en eso usando BPX
GetProcAddress. Ahora aprieta F5... atr�s en
SoftICE desactiva todos los breakpoints y sal de
la LLAMADA de GetProcAddress apretando F12.
Ahora una clase de cosa molesta viene: caminando
a trav�s de las masas de c�digo :)
No es tan duro... Lo abreviar�. Podr�as buscar
los c�digo de operaci�n para acortarlo:
53,53,FF,D6,5B,85,C0,74,2E,68,00,80,00
Eso deber�a ser algo como esto:
push ebx
push ebx
call esi
Sin
embargo encontrar�s tu camino hasta all� (1
min para caminar a esa situaci�n). Remonta
en CALL ESI all� encontrar�s s�lo una
LLAMADA... camina dentro de ella
Entonces camina, camina, camina hasta que te
encuentras con una LLAMADA EAX - no camines en
ella... la LLAMADA pr�xima es la �ltima en la
que nosotros vamos a caminar. Rastrea... y
encontrar�s
mov ebx,[ebp-14]
jmp ebx
Eso
es el Salto final (EBX es el punto de entrada
de tu programa por supuesto).
Salto (apunta a EBX). Camina a �l, pero
no ejecuta el Salto. Ahora entra en una vuelta
infinita con
' a eip'
'jmp eip'
Paso
3: Descargando el para�so
Abre ProcDump. Selecciona el programa de la lista
de la tarea. Click-derecho en �l y selecciona
descarga completa - gu�rdalo. Abre el PE-Editor
y cambia el punto de entrada a lo que viste en
EBX (recuerda entrypoint = ' lo que viste en
EBX'-'imagebase'). Ahora s�lo hazle m�s
compatible y abre el archivo en rebuild PE.
Tienes un programa ahora sin VBox :)
|
|
TX. Notas del
Traductor
Revisado por
X-Grimator.