MALDITAS PROTECCIONES: quebrando AWAVE v4.5 Parchando archivos empaquetados con SnippetCreator

No soy ya muy asiduo a la eliminación de protecciones. Mi actividad se ha dirigido hacia otro oficio: mejorar los programas y poner al acceso de quien lo quiera de la posibilidad de hacerlo. Peor que desproteger un programa es hacerlo mejor y regalarlo. ¿Se puede hacer? Ya hemos visto que es posible al parchar NOTEPAD. Sin embargo haré un excepción. Voy a intentar desproteger un programita llamado AWAVE v4.5. Es un programa ejemplar para mostrar como romper protecciones de archivos ejecutables empaquetados a través de la inserción de código nuevo en ellos empleando Snippet Creator. Quiero subrayar que no tengo nada contra el programador que creó este buen programa. Por el trabajo que me dio, tengo la impresión de que sabía lo que hacía. Yo aconsejaría que quienes deseen usar el programa, lo registren. Si yo pudiera lo haría. Pero mi objetivo no es aprovechar el programa sino enseñar el estilo de romper protecciones que estoy implementando. Para romper las protecciones de archivos empaquetados, la táctica empleada generalmente es esperar que el archivo se despliegue en memoria y sobreescribir la rutina de protección en tiempo de ejecución. Esto comúnmente se ha hecho con un cargador (loader) que atrapa una llamada a alguna API de W32 que realice el programa, y entrega el control a la rutina que desprotegerá el programa: el mismo cargador tomará el control y cambiará en memoria el esquema de protección. El uso de loaders me parece que presenta una dificultad: en este método entran en juego dos procesos distintos, el del loader y el del programa mismo. Esto dificulta las cosas y nos obliga a escribir un número significativo de líneas de código. Las funciones de W32 para escribir procesos remotos, son complejas. El loader puede tener fácilmente un tamaño de 100 KB, especialmente si no lo escribimos en lenguaje ensamblador. Si hacemos que la rutina que rompe las protecciones del programa se ejecuten en su propio proceso, me liberaré de la carga que implica enganchar instrucciones en procesos remotos, sobrescribir y leer procesos remotos, etc. Esto lo podemos lograr simplemente insertando la rutina desprotectora en el mismo ejecutable del programa. Veamos el caso particular de AWAVE v4.5. El programa presenta dos limitaciones engorrosas. La primera es un NAG que aparece al comienzo y que recuerda que se trata de un programa no registrado y retarda el inicio del programa. La otra protección importante es que el programa no permite guardar más de un archivo por sección. Hay un par de cuestiones secundarias: son dos cadenas, una dice "Unregistered copy" y aparece en la parte izquierda del área cliente; la otra dice "(Unreg)" y aparece en la "Caption" de la ventana. Aunque no es tarea fácil, eliminaremos estas molestias. Si intentamos cargar el programa con SICE, no se disparará la ventana del depurador porque el programa está empaquetado y se han cambiado los atributos de las secciones. Entonces creamos en SnippetCreator un nuevo proyecto: awave, cuyo target sería awave.exe. Revisamos los atributos de las secciones y cambiamos los de las secciones .text y .adata, que son, respectivamente las secciones de código ejecutable y la rutina de descompresión. El punto de entrada está en esta última sección. Los atributos deben ser E0000020. Cambiados los atributos, encontramos que ahora si se dispara la ventana de SICE cuando cargamos awave.exe con SICE. Tenemos que buscar varias direcciones: 1. La dirección donde finaliza la rutina de descompresión. Cuando el programa llega a este punto, ya el archivo está totalmente descomprimido en la memoria. 2. Las direcciones de los puntos que deseamos cambiar o parchar. 3. El desplazamiento en el archivo donde escribiremos el recorte nuevo. Esto no se hace con SICE sino con un editor hexadecimal. Como el archivo está empaquetado, existen diferencias sustanciales entre la lista muerta que es el archivo mismo y el código vivo ya desempacado que vemos con SICE. Por este motivo no sirve establecer el desplazamiento en el archivo correspondiente a las direcciones de memoria donde deben hacerse cambios. Así que la estrategia es agregar una rutina al programa que sobreescriba en tiempo de ejecución las rutinas que queremos cambiar. Otro cambio que debemos introducir al archivo es el concerniente a la instrucción que entregará el control a nuestro nuevo recorte. Determinemos el desplazamiento del recorte. Con el editor hexadecimal podemos ubicar un espacio vacío en el desplazamiento 0004 3140h. A partir de él y los calculamos la dirección virtual de su ubicación utilizando la fórmula: Dir Virtual = (Desplazamiento del dato - RawData) + (ImageBase + RVA Offset) Los datos que necesitamos para este cálculo los hallamos con el mismo Snippet Creator. En Snippet Creator activamos el comando "Action\New Target". Pulsamos BROWSE y ubicamos AWAVE.EXE y pulsamos SAVE. Ahora activamos "PE Info/View PE header". Encontramos que: ImageBase = 0040000h Luego activamos "PE Info/View Section Info". Para la sección .text encontramos: RawData = 1000h RVA Offset = 1000h RawSize = 042200h Comprobamos que es en esta sección donde se encuentra el desplazamiento para nuestro injerto. Ahora calculemos la dirección virtual: (43140h - 1000h) + (400000h + 1000h) = 00443140h Debemos entregar el control a esta rutina cuando el archivo ya esté desempacado. Con SICE hemos ubicado esta rutina: 0050B54B     0385AC504400  add eax,[ebp+004450AC] 0050B551     5B                        pop eax 0050B552     ..... 0050B558     61                         popad 0050B559     7508                     jnz 0050B55B     B801000000        mov eax,1 0050B560     02C000                ret 0Ch 0050B563     50                         push eax 0050B564     C3                        ret Debemos insertar en alguna parte de este código la siguiente instrucción, que entregará el control al recorte: 68 00 44 31 40     push 00443140h C3                         ret Como vemos, la instrucción consta de seis bytes. Analizando el código de más arriba, vemos que la instrucción en 50B54B tiene ese tamaño, así que tomamos esa. Calculamos el desplazamiento en el archivo correspondiente a esta dir. virtual y es 05454Bh. Si revisamos con el editor hexadecimal este desplazamiento veremos que no se corresponden los valores con los que vemos en SICE. Lo que ocurre, me imagino, es que se trata de un desempacador compuesto de dos partes. El desempacador mismo está empacado. Hay pues dos desempacadores, uno desempaca el desempacador del programa. Así que necesitamos una dirección más: la dirección final del primer desempacador o ubicar una punto en el primer desempacador donde la instrucción que nos toca ya esté desempacada. Ubicada esta dirección, pasamos desde aquí el control al recorte; hacemos que el recorte escriba la instrucción 0050B54B para que vuelva a pasar el control al recorte, que romperá ahora las protecciones sobre el archivo desplegado. Para hallarla, cargamos el ejecutable en SICE y hacemos: D 50B54B Esto desplegará en la ventana de datos de SICE el contenido en hexadecimal que hay en 0050B54B. Luego ejecutamos F10 hasta ver en la ventana de datos de SICE algo como esto: 0385AC504400. Yo he determinado esta dirección: 0050B0B7     8B85B5504400     mov eax, [ebp + 004450B5] Como ven, la instrucción tiene seis bytes. El desplazamiento de esta dirección en el archivo es 0540B7h. Con el heditor hexadecimal escribimos en esta instrucción: 68 40 31 44 00 C3 que es el equivalente octal de las instrucciones "push 443140h" - "ret". Cuando se ejecute el programa y llegue a este punto, pasará el control a las rutinas escritas en el desplazamiento 43140h del archivo, correspondiente a la dirección virtual 00443140h del programa. La rutina del recorte deberá incluir una rutina que restaure la instrucción que hemos modificado (en 0050B0B7) y que modifique el final del segundo desempacador, cuando el programa ya está totalmente desempacado, para que se entregue el control de nuevo a una rutina que introducirá por fin los cambios definitivos en el programa. Tenemos ya las siguientes direcciones: 1. Dirección de la instrucción que entregará el control al recorte. Final del primer desempacador: 50B0B7h. La llamamos VA1. 2. Dirección del recorte en el archivo: 00443140h. VA2. 3. Dirección de la instrucción que devolverá de nuevo el control al recorte 50B54Bh. La llamamos VA3. Ahora, queda romper las protecciones para obtener las últimas direcciones: las que hay que cambiar para desproteger el programa. Necesito estas direcciones para escribir el código del recorte. Por razones de tiempo no entraré en detalles y las daré de inmediato: 1. Eliminar el NAG del comienzo: Reemplazar: 0045041E     8B1584F84A00     mov edx,[004AF884] por: 0045041E     EB19                      jmp 00450435 Con esto saltamos por encima de la llamada a DialogBoxParam que despliega el NAG del comienzo. 2. Permitir que el programa guarde más de un archivo en cada sección: Reemplazar: 0045F0FD     8A08                     mov CL,[eax] por: 0045F0FD     EB08                     jmp 455F0B Así saltamos la prueba que revisa si ya se ha guardado un archivo antes de la llamada a GetSaveFileName. 3. Eliminar cadena "Unregistered copy": Colocar en 004A2100 un 00h. Esto coloca cero al comienzo de una cadena ASCIIZ. 4: Eliminar cadena "(Unreg)": Colocar en 0049FCD3 un 00h. El código de parche rompedor sería entonces algo como esto: ; -------------------------------------------------------------------------------------------------- .386 locals jumps .model flat,STDCALL jmp init: OldInstruction1 db 08Bh,085h,0B5h,050h,044h,000h OldInstruction2 db 003h,085h,0ACh,050h,044h,000h NewInstruction2 db 068h,000h,004h,040h,000h,0C3h NewInstruction3 db 0EBh,019h PatchVA1 dd 0050B0B7h PatchVA2 dd 0050B54Bh init: ; Restaurar en 50B0B7h "add eax [ebp+004450AC]" pushad lea esi,OldInstruction1 mov edi,PatchVA1 mov ecx,6 rep movsb ; Escribir en 50B54Bh "push 00400400h - ret" lea esi,NewInstruction2 mov edi,PatchVA2 mov ecx,6 rep movsb popad push 0050B0B7h ret write_code: ; Resaturar código en 50B0B7h pushad lea esi,OldInstruction2 mov edi,PatchVA2 mov ecx,6 rep movsb ; Eliminar NAG: Saltarse la llamada a DialogBoxParamA mov edi,0045041Ah lea esi,NewInstruction3 mov ecx,2 rep movsb ; Permitir guardar más de un archivo mov edi,455EFDh mov byte ptr [edi],0EBh ; regresar popad push 0050B0B7h ret ; ------------------------------------------------------------------------------------------------- Hemos agregado aquí: 1. El código que restaura la instrucción que cambiamos en el primer desempacador. 2. La rutina que sobrescribe la instrucción al final del segundo desempacador. 3. La rutina que restaura la instrucción anterior. Antes de escribir este código en la ventana de edición de SC y ensamblarlo, necesitamos configurar el programa. En las opciones generales ("Action/Options), he empleado TASM. En las opciones del proyecto ("Action/Project Options")debes colocar la dirección del recorte: "Snippet VA" = 00443140. Después de gran cantidad de pruebas, noté que no se pueden escoger ciertas opciones ya que por algún motivo dañan el ejecutable. Así que parte del trabajo tendremos que hacerlo manualmente. Debemos escoger las siguientes opciones, para evitar que Snipet Creator escriba sobre el ejecutable: · Patch Into Existing Section · No Redirection · Don't Return Control to Program Otro cosa importante que debemos hacer es cambiar los atributos de las secciones que serán sobre-escritas durante la ejecución del proceso. De lo contrario, se cometerá error de protección. Estas secciones son, para awave, .adata, .text y .data. Esto lo hacemos fácilmente con SC. Abrimos "Section Information" ("PE Info/View Section Info"). Con el botón derecho del ratón pulsamos sobre cada una de estas secciones. Elegimos "Edit Section" en el menú. Saldrá la ventana "Modify Section Values". Pulsamos el botón "..." al lado de "Caractheristics" y en la ventana "Section Characteristics" establecemos "IMAGE_SCN_MEM_WRITE", lo cual permitirá que se pueda sobrescribir la sección cuando está en memoria.. SAVE. Ahora escribimos el código de arriba, lo ensamblamos y lo exportamos. Abrimos el archivo .BIN exportado con el editor hexadecimal lo copiamos y lo pegamos cuidadosamente en el archivo ejecutable en la dirección que hemos elegido para el recorte. No debemos copiar de más ni de menos; tampoco debemos comernos algún byte cuando peguemos el nuevo recorte, cualquier mínimo error deteriora el ejecutable. Antes de hacer cualquier otro cambio ejecuta el programa para constatar que no lo haz deteriorado. El copiado del recorte he tenido que hacerlo manualmente porque en varias ocasiones se me deterioró cuando lo hice con SC. Ahora escribimos el siguiente código en el desplazamiento correspondiente al final del primer desempacador: en la dirección 00500BB7h cuyo desplazamiento en el archivo es 0540B7h: 68 00 40 31 44 00   =   push 00443140h C3                           =   ret No ejecutes el programa todavía. Esto debería marchar bien, pero no hemos contado con que el espacio que hemos elegido para colocar el recorte será sobrescrito cuando el programa quede desempaquetado (grrr...). Entonces, cuando por segunda vez el programa original devuelva el control al recorte ya en la dirección del recorte no estará el código que escribimos sino el código del programa original. Podríamos hacer muchas pruebas y cálculos para determinar si podemos colocar el recorte en alguna sección donde no vaya a ser sobrescrito por el archivo original al desempacarse. Si creamos una sección nueva tenemos grandes posibilidades de deteriorar el archivo además de que aumentamos su tamaño. Así que lo que hice fue implementar una DLL. Esto facilita las cosas enormemente. Ahora la estrategia es re-escribir el recorte para que sólo haga los siguiente: 1. restaurar la dirección original 2. cargar nuestra DLL en el espacio de direcciones del proceso. 3. cambiar la dirección del final del segundo desempacador para que pase el control a la DLL: ; ---------------------------------- Código del recorte --------------------------------- extrn LoadLibraryA: Proc extrn GetProcAddress: Proc jmp init DllName db "aw_patch.dll",0 FunctionName db "patch",0 OldInstruction db 08Bh,085h,0B5h,050h,044h,000h NewInstruction db 068h,000h,000h,000h,000h,0C3h NewInstruction3 db 0EBh,019h FunctionName db 'patch',0 init: ; Restaurar antigua instrucción pushad mov edi,0050B0B7h lea esi,OldInstruction mov ecx,6 rep movsb ; Cargar librería y obtener su dirección en la memoria lea esi,DllName call LoadLibraryA,esi call GetProcAddress,eax,offset FunctionName ; Escribir nueva instrucción: entregará el control a la DLL mov edi,0050B54Bh lea esi,NewInstruction mov dword ptr [esi+1],eax ; Dir de DLL en la memoria mov ecx,6 rep movsb ; Regresar popad push 0050B0B7h ret ; ------------------------------------------------------------------------------------------------ Esto nos abre enormes posibilidades ya que nos permite disfrutar de todas las ventajas de usar DLLs. Ahora sólo será necesario colocar el recorte que cargue la DLL en el espacio de direcciones del proceso y luego el código de la DLL hará lo que, por razones de espacio, no puede hacer el recorte. Esto nos permitirá hacer cambios posteriores sin tener que tocar para nada el archivo original. Para introducir un cambio sólo necesitamos cambiar el código de la DLL. ¡Y todo esto sólo con un pequeño parchesito que carga la DLL en la memoria del proceso original!. La DLL debe hacer lo siguiente: 1. restaurar la dirección original. 2. realizar todos los parches. ; ---------------------------------- Código de la DLL ---------------------------------------- .386 locals jumps .model flat,STDCALL extrn GetModuleHandleA:Proc extrn GetProcAddress:Proc IDOK equ 1 IDM_ABOUT equ 0105 public patch public RestaureDialog .data OldInstruction db 003h,085h,0ACh,050h,044h,000h NewInstruction db 0EBh,019h ModuleName db 'aw_patch.dll',0 FunctionName db 'RestaureDialog',0 .code Start: dll proc instance:DWORD, reason:DWORD, reserved:DWORD mov eax,1 ret endp dll ; Rutina que parcha la víctima patch: ; Resaturar código en 50B54Bh pushad lea esi,OldInstruction mov edi,0050B54Bh mov ecx,6 rep movsb ; Eliminar NAG: saltarse la llamada a DialogBoxParamA mov edi,0045041Ah lea esi,NewInstruction mov ecx,2 rep movsb ; Permitir guardar más de un archivo mov edi,455EFDh mov byte ptr [edi],0EBh ; regresar popad push 0050B0B7h ret   ; ----------------------------------------------------------------------------------------------- Con esta estrategia también se podrían ampliar enormemente las funcionalidades del programa. Ahora escribimos el nuevo recorte, lo ensamblamos y los exportamos. Abrimos awave.bin con el editor hexadecimal y lo pegamos en la dirección correspondiente. Ensamblamos y enlazamos aparte nuestra DLL. Para ello pueden emplearse los siguientes archivos:   ; -----------------------------------aw_patch.def-----------------------------------------------   LIBRARY aw_patch EXPORTS MyAboutDialog EXPORTS patch DESCRIPTION 'ASM program' EXETYPE WINDOWS CODE PRELOAD MOVEABLE DATA PRELOAD MOVEABLE MULTIPLE ; -------------------------------------------------------------------------------------------------- ; ---------------------------------- makefile (TASM)-------------------------------------------- NAME = aw_patch OBJS = $(NAME).obj DEF = $(NAME).def RCS = $(NAME).rc RES = $(NAME).res IMPORT=C:\TA\lib\import32 TASMDEBUG=/zi LINKDEBUG=/v $(NAME).DLL: $(OBJS) $(RES) $(DEF) tlink32 /Tpd /aa /c $(OBJS),$(NAME),, $(IMPORT), $(DEF), $(NAME) .asm.obj: tasm32 /ml /m2 $&.asm .rc.res : brc32 -r $(NAME).rc ; ------------------------------------------------------------------------------------------------- Con esto sólo tenemos que ejecutar desde la línea de comando, mientras apunta al directorio donde está los archivos fuentes ( C:\temp\aw_parch, por ejemplo), el comando MAKE, suponiendo que tenemos en entorno el patch hacia el directorio donde tenemos los binarios del ensamblador. Una vez creada nuestra DLL, la colocamos en el mismo directorio del recorte. Ensamblado el recorte y pegado en la dirección indicada de la víctima, ejecutamos finalmente awave.exe: ¡Ja, ja!