Curiosity is insubordination in its purest form. -Vladimir Nabokov

sábado, 16 de febrero de 2019

Haciendo un cargador (loader) para crackear un programa MS-DOS en ejecucion

Y con esta ya son tres las entradas que llevamos de oldschool cracking. En esta ocasion el candidato sera un viejo (1992) juego español: La Colmena version CGA/EGA/Hercules/VGA-16 [1], de la desaparecida compañia Opera.

Usaremos DOSBox debugger [2] para ejecutar el programa paso a paso, pondremos breakpoints, identificaremos varios puntos donde podremos cambiar el codigo en memoria para que acepte cualquier clave que introduzcamos y explicaremos por que. Aplicaremos los cracks en caliente desde DOSBox debugger y conseguiremos pasar de la pantalla de claves, hasta aqui nada nuevo con respecto a las anteriores entradas de la serie, pero a la hora de ir a parchear el ejecutable con un editor hexadecimal nos toparemos con que los bytes que hemos modificado desde DOSBox debugger no estan en el archivo. WTF!! ¿Quieres saber si finalmente lograremos crear un crack permanente? Entonces sigue leyendo.

Comenzamos. Cargamos el juego en DOSBox y al llegar a la pantalla de claves

pulsamos ALT+PAUSA para activar el debugger, tal como vimos en entregas anteriores. Si ejecutamos paso a paso (F10 step in/F11 step into) enseguida nos toparemos con el siguiente codigo:
0308:0000015C B401      mov  ah,01            ; ¿Se ha pulsado alguna tecla?
0308:0000015E CD16      int  16
0308:00000160 7503      jne  00000165 ($+3)
0308:00000162 33C0      xor  ax,ax            ; NO: limpiamos ax
0308:00000164 C3        ret                   ;     y volvemos a empezar
0308:00000165 B80000    mov  ax,0000          ; SI: Obtenemos codigo tecla pulsada
0308:00000168 CD16      int  16               ; Devuelve: AH = BIOS scan code
                                              ; Devuelve: AL = ASCII character
BP 0308:0000016A C3     ret
Es la parte encargada de esperar la pulsacion de alguna tecla. Ponemos un breakpoint en el segundo ret
BP 0308:016A
volvemos a ejecutar con F5 y no tardamos en llegar a la parte donde se comprueba que tecla ha sido pulsada.
(...)
0308:000000E8 3D0D1C    cmp  ax,1C0D          ; Se ha pulsado Intro?
0308:000000EB 7433      je   00000120 ($+33)  ; SI: saltamos a gestionarlo
0308:000000ED E9E1FF    jmp  000000D1 ($-1f)  ; NO: vuelta a empezar
Ponemos un bp en la direccion de memoria a la que saltamos cuando se ha pulsado intro.
BP 0308:0120  ; Hemos pulsado intro
y no tardamos en llegar a la parte donde se comprueba si se han introducido los 4 caracteres de la clave, momento en que se llama a un call que compara la clave introducida con la clave que el juego espera. Cada simbolo se codifica con un byte (caracter) y ambas claves seran tratadas como cadenas.
0308:00000043 A07B07        mov  al,[077B]            ; Numero de caracteres introducidos
0308:00000046 3C04          cmp  al,04                ; Se han introducido los 4 caracteres de la clave?
0308:00000048 75F3          jne  0000003D ($-d)       ; NO -> otra vuelta al bucle
BP 0308:0000004A E83D00     call 0000008A ($+3d)   ; SI -> comprobamos la clave
0308:0000004D 75EE          jne  0000003D ($-12)      ; JNE = CHICO_MALO. **OPCION 1 DE CRACK->SM 0308:0000004D 90 90 NOP NOP
0308:0000004F E8DE02        call 00000330 ($+2de)     ; Camino CHICO_BUENO
0308:00000052 CD12          int  12
Entramos con F11 en el primer CALL y enseguida vemos codigo que comprueba la clave introducida con la clave que espera el juego como valida.
0308:0000008A BE7C07    mov  si,077C          ; Puntero a clave introducida por usuario ; **OPCION 5 de CRACK ->SM 0308:008B 80 mov si,0780
0308:0000008D BF8007    mov  di,0780          ; Puntero a clave buena ; **OPCION 6 de CRACK -> SM 0308:008E 7C mov di,077C
0308:00000090 B90400    mov  cx,0004          ; Numero de vueltas al bucle
0308:00000093 8A04      mov  al,[si]          ; Guardamos en AL un caracter de la clave introducida por el usuario ; OPCION 3 DE CRACK->SM 0308:0093 XX XX MOV AL,[DI]
0308:00000095 3A05      cmp  al,[di]          ; y lo comparamos con el caracter de la clave real ; OPCION 4 DE CRACK->SM 0308:0095 XX XX CMP AL,[SI]
0308:00000097 750D      jne  000000A6 ($+d)   ; JNE = CHICO_MALO ; **OPCION 2 DE CRACK->SM 0308:0097 90 90
0308:00000099 47        inc  di               ; Siguiente caracter de clave buena
0308:0000009A 46        inc  si               ; Siguiente caracter de clave introducida por usuario
0308:0000009B E2F6      loop 00000093 ($-a)   ; Decrementamos CX en 1, y si CX aun no es 0 -> Saltamos al principio del bucle
0308:0000009D B90600    mov  cx,0006          ; Camino CHICO_BUENO
0308:000000A0 E82400    call 000000C7 ($+24)
0308:000000A3 32C0      xor  al,al            ; Ponemos al=0
0308:000000A5 C3        ret                   ; Retornamos a 0308:0000004D 75EE jne 0000003D con codigo de retorno AL
                                              ; Como el codigo de retorno es 0 seguiremos en CHICO_BUENO
Podemos crackear el juego de multiples formas, he numerado varias, veamoslas.

A destacar las opciones 5 y 6 donde el juego quedaria crackeado cambiando UN solo byte. En la 5 hacemos que el puntero a la clave introducida por el usuario apunte a la clave buena, de tal forma que estaremos comparando la clave buena consigo misma y obviamente sera tomada como correcta. La 6 sigue la misma idea pero hacemos que el puntero a la clave buena apunte a la clave introducida por el usuario, con lo cual estaremos comparando la clave introducida consigo misma que obviamente tambien sera tomada como correcta.

En las opciones 3 y 4 haremos que el CMP compare [si] con [si] o bien [di] con [di], con lo que el resultado obviamente siempre sera que ambas cadenas coinciden.

Yo voy a elegir la opcion 2, es decir, anular este salto:
0308:00000097 750D      jne  000000A6 ($+d)
cambiandolo por dos NOP:
0308:00000097 9090      nop nop
con lo cual seguiremos el camino CHICO_BUENO independientemente del resultado de la comprobacion cmp al,[di]. Vamos a ello, desde DOSBox debugger:
SM 0308:0097 90 90
Continuamos ejecucion con F5 y eureka! cualquier clave que introduzcamos

el juego la da por valida y pasamos de la pantalla de claves al juego en si.

Entonces, con todo el subidon por haberlo conseguido nos disponemos a cargar COLMENA.EXE en nuestro editor hexadecimal favorito y buscamos una ristra de bytes que incluya los bytes que queremos modificar. Y... no la encontramos. Pero que no cunda el panico. ¿Sera que estan en otro archivo? Podria ser. mmmm ¿Y si pudieramos saber los archivos que un ejecutable va abriendo? Pues podemos.

Una manera rapida seria usar KGB [3] (incluye codigo fuente en ASM!), un genial TSR que captura la INT 21h y escribe las llamadas que un ejecutable va haciendo a funciones de tratamiento de archivos de la INT 21h como abrir, crear, ejecutar, etc. Crea un archivo de texto c:\HISTORY.DAT donde va guardando estas llamadas. Su uso es muy sencillo:

C:\> KGB
Runtime saving of file actions.
ver. 1.04
Petr Hor�k, Praha 1992
Usage: kgb [file] [/Options] ..
Options:
    /u unload
    /dX drive X (A-Z)
    /on (off)

C:\> COLMENA
Llegamos hasta la pantalla de claves, miramos el contenido de C:\HISTORY.DAT y tenemos:
Exec        : colmena.EXE 
OpenFile-R  : col0.ovl
Vemos que COLMENA.EXE abre en modo lectura el archivo col0.ovl

Otra forma seria poner breakpoints en llamadas a interrupciones en el debugger de DOSBox. Tenemos practicamente toda la info posible sobre interrupciones (que funciones hay, en que registro se pasa cada argumento, si retorna algo en que registro lo hace...) en las dos biblias: Ralf Brown's Interrupt List [4] y HelpPC Interrupt List [5]. Hint: INT 21h es muy importante.

Llamadas interesantes que nos podrian interesar ahora son INT 21/3D (Open file using handle) e INT 21/4B (load and execute program), asi que ponemos los siguientes breakpoints:
BPINT 21 3d
BPINT 21 4b
Ejecutamos con F5 y llegamos a una llamada a INT 21h/3d. Justo antes de que se ejecute la instruccion INT 21h tenemos en DS:DX el nombre del archivo en ASCIIZ. Pulsamos ALT+X para cambiar la vista de datos a DS:DX y ahi tenemos el nombre del archivo que se va a abrir:
col0.ovl\00
Bien, vamos a abrir col0.ovl con un editor hexadecimal para cambiar bytes. Nada, tampoco encontramos la ristra de bytes que queremos parchear. WTF?

No desesperemos, volvamos a cargar el juego, volvamos a poner el BPINT y desde ahi sigamos ejecutando paso a paso (F10 step in/F11 step into). Acabaremos viendo que COLMENA.EXE va leyendo los bytes de col0.ovl y va tejiendo en memoria en tiempo de ejecucion los bytes que formaran el subprograma que nos pide las claves, y cuando termina el desempaquetado salta a la direccion de memoria donde comienza, que esta en otro segmento distinto. Y se ejecuta. Y aparece ante nosotros la pantalla de claves. Si la clave que introducimos es correcta, retornamos y COLMENA.EXE hace lo mismo con col1.ovl, que es el juego en si.

Sabiendo esto tenemos al menos dos opciones. Una seria localizar el punto exacto de la rutina de descifrado, entenderla y parchear en la posicion correspondiente los bytes que queremos conseguir (90 90) pero _codificados_ de tal forma que cuando la rutina de descifrado desempaquete col0.ovl los bytes resultantes sean los que anulan la proteccion (90 90 en este caso).

La otra opcion, que es la que vamos a seguir, es crear un cargador (loader) en ASM que parchee los bytes que queremos modificar cuando col0.ovl haya sido desempaquetado. Para ello necesitamos capturar una interrupcion que llame el juego una vez estan en memoria los opcodes que queremos parchear.

Bien, vamos a hacer un volcado del subprograma de claves una vez ha sido desempaquetado y con ayuda de IDA [6] sacaremos un listado de las interrupciones a las que llama. Necesitamos encontrar la primera instruccion de col0.ovl desempaquetado y aqui tenemos al retf que hace que el flujo de ejecucion de COLMENA.EXE salte a la primera instruccion del subprograma col0.ovl
BP 9000:0000018B CB     retf
Si ponemos un BP y lo ejecutamos veremos que la instruccion siguiente ya se encuentra en otro segmento distinto. Es la primera instruccion del subprograma de claves:
0308:00000000 2EC6064C0600      mov  byte cs:[064C],00
Justo cuando estamos en esa instruccion, sin llegar a ejecutarla volcamos los opcodes desde ese punto asi:
MEMDUMPBIN CS:IP 50000
Y se habra creado un archivo binario llamado MEMDUMP.BIN de 50000 bytes. Habra muchos 0's al final, podriamos quitarlos pero no importa, lo abrimos en IDA como si fuera un .COM y buscamos las ocurrencias del opcode CD, que es el que corresponde a la instruccion INT. De las interrupciones que aparecen yo he elegido una llamada a INT 16h/AH=1

Sigamos. Queremos sustituir esto:
0308:00000097 750D      jne  000000A6
por esto:
0308:00000097 90      nop
0308:00000098 90      nop
siempre y cuando en la direccion [0097] esten los opcodes 75 0D (no queremos parchear mas de una vez) y se haya entrado a nuestra INT 16h tras una llamada a INT 16h/AH=1. Manos a la obra. He llenado el codigo de comentarios, no es quejareis.
OVERLAY segment para 'code'
        assume cs:OVERLAY, ds:OVERLAY
        org 100h    ; Esto sera un programa .COM

; El codigo residente en memoria empieza aqui
START: jmp INITCODE     ; Codigo de inicializacion

OLDINT dw 0,0           ; Espacio para el puntero a la INT 16h del sistema

NEWINT proc far
    pushf               ; Guardamos flags. Si modificaramos algun registro habria que guardarlo tambien.
    cmp ah, 1           ; Se ha llamado a INT 16h con la funcion AH=1 ?
    jnz EXIT            ; NO: saltamos a la antigua INT 16h

    cmp Word Ptr [0097], 0d75h  ; ¿Tenemos en [0097] los opcodes 75 0D? Ojo!! x86 es little endian, asi que van "al reves" 
    jnz EXIT            ; NO: saltamos a la antigua INT 16h

    mov Byte Ptr [0097], 90h   ; Crack: escribimos el byte 90 en [0097]
    mov Byte Ptr [0098], 90h   ; Crack: escribimos el byte 90 en [0098]

EXIT:
    popf                ; Restauramos flags
    jmp DWord Ptr cs:[OLDINT]     ; Saltamos a la antigua INT 16h
NEWINT endp

FINAL equ $
; El codigo residente en memoria acaba aqui

INITCODE:
    mov ax, 3516h           ; Queremos el valor del puntero a la INT 16h del sistema
    int 21h
    mov OLDINT[0], bx       ; Guardamos puntero a la INT 16h del sistema
    mov OLDINT[2], es       ;  (necesitaremos llamarla despues)

    mov ax,2516h            ; Sobreescribimos en el vector de interrupciones el puntero a INT 16h por
    lea dx, NEWINT          ; un puntero a nuestra rutina NEWINT proc far
    int 21h

    mov ax, 3100h           ; Terminate and Stay Resident (TSR)
    lea dx, FINAL           ; Guardamos offset de FINAL en DX
    int 21h

OVERLAY ends

end START
Guardamos como CRACK.ASM y lo ensamblamos. Usare A86 [7]
a86 CRACK.ASM
Y tendremos un ejecutable CRACK.COM de tamaño 66 bytes.

Si lo ejecutamos aparentemente no hara nada y volveremos a ver el prompt c:\> de MS-DOS, pero en ese punto el programa se habra quedado residente en memoria y habra una nueva INT 16h en el sistema lista para acechar la comprobacion de claves del juego. Cargaremos COLMENA.EXE, que como vimos con IDA acabara llamando a INT 16h/AH=1, llamada que sera interceptada por nuestro TSR que parcheara el codigo del juego en memoria y devolvera el control a la INT 16h del sistema. El juego entonces aceptara cualquier clave introducida como valida. Si vuelve a haber llamadas a INT 16h/AH=1 seran aun interceptadas por nuestro TSR, pero al detectar que el juego ya esta parcheado no hara nada y simplemente redirigira la peticion a la INT 16h original del sistema.

Pero... ¿y el cargador donde esta? esto es un TSR que no carga nada. ¿Seria posible que solo tuvieramos que ejecutar CRACK.COM y este ya cargara COLMENA.EXE? Pues si, haciendo uso de las funciones "Modify Allocated Memory Block" (INT 21h/4Ah) y "EXEC/Load and Execute Program" (INT 21h/4Bh). La captura de interrupciones, el parcheo del codigo en memoria de COLMENA.EXE, todo es igual, la unica diferencia es que esto ya no sera un TSR, sera un cargador en toda regla. Ahi va el listado.
SIZE EQU 1024       ; este programa y su pila caben en 1 KB
OVERLAY segment para 'code'
        assume cs:OVERLAY, ds:OVERLAY
        org 100h    ; Esto sera un programa .COM

START: jmp INITCODE     ; Codigo de inicializacion

OLDINT dw 0,0           ; Espacio para el puntero a la INT 16h del sistema

NEWINT proc far
    pushf               ; Guardamos flags. Si modificaramos algun registro habria que guardarlo tambien.
    cmp ah, 1           ; Se ha llamado a INT 16h con la funcion AH=1 ?
    jnz EXIT            ; NO: saltamos a la antigua INT 16h

    cmp Word Ptr [0097], 0d75h  ; ¿Tenemos en [0097] los opcodes 75 0D? Ojo!! x86 es little endian, asi que van "al reves" 
    jnz EXIT            ; NO: saltamos a la antigua INT 16h

    mov Byte Ptr [0097], 90h   ; Crack: escribimos el byte 90 en [0097]
    mov Byte Ptr [0098], 90h   ; Crack: escribimos el byte 90 en [0098]

EXIT:
    popf                ; Restauramos flags
    jmp DWord Ptr cs:[OLDINT]     ; Saltamos a la antigua INT 16h
NEWINT endp

INITCODE:
    mov sp, SIZE            ; redefinimos la pila
    mov bx, SIZE/16
    mov ah, 4ah             ; redimensionamos bloque memoria
    int 21h

    lea dx, MSG
    mov ah, 9               ; Escribimos texto por pantalla
    int 21h

    xor ah, ah              ; Esperamos pulsacion de tecla
    int 16h

    mov ax, 3516h           ; Queremos el valor del puntero a la INT 16h del sistema
    int 21h
    mov OLDINT[0], bx       ; Guardamos puntero a la INT 16h del sistema
    mov OLDINT[2], es       ;  (necesitaremos llamarla despues)

    mov ax,2516h            ; Sobreescribimos en el vector de interrupciones el puntero a INT 16h por
    lea dx, NEWINT          ; un puntero a nuestra rutina NEWINT proc far
    int 21h

    lea bx, EXEC_INFO
    mov DWord Ptr [bx], 0
    mov DWord Ptr [bx+2], 80h   ; PSP
    mov Word Ptr [bx+4], cs
    mov Word Ptr [bx+6], 5ch    ; FCB 0
    mov Word Ptr [bx+8], cs
    mov Word Ptr [bx+0ah], 6ch  ; FCB 1
    mov Word Ptr [bx+0ch], cs

    lea dx, FILENAME
    mov ax, 4b00h
    int 21h             ; cargar y ejecutar programa

    push cs
    pop ds              ; DS = CS
    mov ax, 4c00h       ; terminar
    int 21h

FILENAME    db "COLMENA.EXE",0   ; programa a ejecutar
EXEC_INFO   db 22 DUP (0)
MSG         db 0dh,0ah
            db "La Colmena CGA/EGA/Hercules/VGA-16 crack.",0dh,0ah
            db "2019, vlan7",0dh,0ah,"$"

OVERLAY ends

end START
Feliz reversing.

[1] La Colmena CGA/EGA/Hercules/VGA-16 https://www.mediafire.com/file/036ztp6dxslstsl/COLMENA.7z/file
[2] DOSBox Debugger https://www.vogons.org/viewtopic.php?t=7323
[3] KGB https://www.mediafire.com/file/wbwtd69s3txcbt2/kgb.zip/file
[4] Ralf Brown's Interrupt List http://www.delorie.com/djgpp/doc/rbinter/ix/
[5] HelpPC Interrupt List http://stanislavs.org/helppc/idx_interrupt.html
[6] IDA 5.0 free https://www.scummvm.org/frs/extras/IDA/idafree50.exe
[7] A86 http://www.eji.com/a86/

Related Posts by Categories



0 comentarios :