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.