Armadillo 3.x parte1 version2

Armadillo 3.x parte1 version2

por Tk0017

“A darle átomos!!”

Este será un tutorial breve y con pocas imágenes; es una simple explicación de como usar la herramienta ArmTools.

Comenzamos ejecutando nuestro archivo uedit32.exe, una vez cargado abrimos el LordPE y vemos que solo hay un proceso uedit32.exe, con lo cual descartamos los nanomites y el CopyMemII.

Busquemos el OEP de nuestra app, carguémosla en el Olly, escondemos el dbg, vamos a la ventana Memory Map y ponemos un F2 [Break-on-access] en la sección

Memory map

Address Size Owner Section Contains Type Access Initial

00001000 uedit32 PE header Imag R RWE

0015D000 uedit32 .text Imag R RWE

0055E000 00039000 uedit32 .rdata Imag R RWE

00597000 0004A000 uedit32 .data Imag R RWE

005E1000 00001000 uedit32 .SHARED data Imag R RWE

005E2000 00030000 uedit32 .text1 code Imag R RWE

00612000 00010000 uedit32 .adata code Imag R RWE

00622000 00020000 uedit32 .data1 imports Imag R RWE

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

Damos un F9 y se detiene aquí

|. 8945 08 MOV DWORD PTR SS:[EBP+8],EAX

|> 837D 10 08 /CMP DWORD PTR SS:[EBP+10],8

|. 0F82 6E010000 |JB uedit32.00604ABB

0060494D |. 8B4D 0C |MOV ECX,DWORD PTR SS:[EBP+C]

|. 33D2 |XOR EDX,EDX

|. 8A11 |MOV DL,BYTE PTR DS:[ECX]

|. 8B45 08 |MOV EAX,DWORD PTR SS:[EBP+8]

|. 33C2 |XOR EAX,EDX

|. 25 FF000000 |AND EAX,0FF

0060495E |. 8B4D 08 |MOV ECX,DWORD PTR SS:[EBP+8]

|. C1E9 08 |SHR ECX,8

|. 8B1485 0C6A6200 |MOV EDX,DWORD PTR DS:[EAX*4+626A0C]

Si observamos en la barra de estado dice “Break-on-access when reading [00401000]” y lo que nosotros queremos en un “when executing” así que ese no es nuestro OEP, más si se dan cuenta en la dirección 00604943 se hace una comprobación y luego se realiza un salto a una dirección de memoria muy abajo del listado, si seguimos este código veremos que es un bucle que termina en

00604AB0 |. 83E9 08 |SUB ECX,8

00604AB3 |. 894D 10 |MOV DWORD PTR SS:[EBP+10],ECX

00604AB6 |.^E9 88FEFFFF \JMP uedit32.00604943

00604ABB |> 837D 10 00 CMP DWORD PTR SS:[EBP+10],0

00604ABF |. 74 3C JE SHORT uedit32.00604AFD

En esa dirección ponemos un F2 y damos F9, una vez que para quitamos el Breakpoint dando F2 nuevamente y una vez mas ponemos un F2 en la sección .text del Mamory Map, damos F9 y para aquí

00514CB5 55 PUSH EBP

00514CB6 8BEC MOV EBP,ESP

00514CB8 6A FF PUSH -1

00514CBA 68 80885700 PUSH uedit32.00578880

00514CBF 68 A0855100 PUSH uedit32.005185A0

00514CC4 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]

00514CCA 50 PUSH EAX

00514CCB 64:8925 00000000 MOV DWORD PTR FS:[0],ESP

En la barra de estado dice “Break-on-access when executing [00514CB5]” y ese es nuestro OEP

Una vez obtenido nuestro OEP lo apuntamos para futuras referencias, antes de cerrar el Olly veamos que información nos da el Armadillo, demos F8 hasta llegar a la dirección

00514CDB FF15 9019F800 CALL DWORD PTR DS:[F81990]

Sigámosla con F7 y nos llevara a

003BEC4C A1 8CF13E00 MOV EAX,DWORD PTR DS:[3EF18C]

003BEC51 C3 RETN

La dirección de memoria puede variar, con F8 lleguemos hasta el RETN, si vemos EAX = 0A280105, para los que no tengan mucha experiencia o no sean muy observadores este es el valor que devuelve la API kernel32.GetVersion, así pues esta es la primera llamada a la IAT, pero la dirección de memoria a la que se llama es [00F81990], si ven el Memory Map verán que la memoria del nuestro comienza en 00400000 y termina en 007D0000, lo que significa que nuestra IAT fue redireccionada a una zona de memoria fuera de nuestro ejecutable

Trataremos ese asunto mas tarde, primero vamos a obtener nuestra IAT con las entradas correctas, en el Olly vallamos a la dirección 00F81990 en el Dump y veremos

00F81970 0C 9B D1 77 56 46 D1 77 .›ÑwVFÑw

00F81978 50 16 0F 77 66 94 D1 77 Pwfӄw

00F81980 B4 6A D1 77 B3 7B D1 77 ´jÑw³{Ñw

00F81988 DB 7B D1 77 E0 20 C4 77 Û{Ñwà Äw

00F81990 4C EC 3B 00 5F 3C D1 77 Lì;._<Ñw

00F81998 96 9C D1 77 DC 79 D1 77 –œÑwÜyÑw

00F819A0 D0 2B 00 10 10 A5 00 10 Ð+.¥.

00F819A8 0C 15 F4 77 22 5F D1 77 .ôw"_Ñw

00F819B0 EB E0 3B 00 71 EB D1 77 ëà;.qëÑw

Como se puede observar hay varias entradas correctas, en lo personal prefiero poner un Breakpoint, Hardware, on write, Dword en una entrada correcta, en este caso pongámoslo en 00F81970

Cerramos el Olly, volvemos a cargar nuestra app, escondemos el dbg damos F9 y se detendrá varias veces en las que se escribirá basura

00F81970 EE FE EE FE EE FE EE FE îþîþîþîþ

00F81978 EE FE EE FE EE FE EE FE îþîþîþîþ

Sigamos presionando F9 hasta que en la dirección de memoria 00F81970 se escriba un valor que se asemeje a una entrada de la IAT

00F81970 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

00F81978 EE FE EE FE EE FE EE FE îþîþîþîþ Esta y otras mas son basura

00F81970 FE AE 3B 00 0D F0 AD BA þ®;..ð­º

00F81978 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

Este ultimo se ve bien pero las demás direcciones de la IAT aun tienen el valor 0DF0ADBA, así que demos otro F9 y para en

003D6DE5 8B85 0CC8FFFF MOV EAX,DWORD PTR SS:[EBP-37F4]

003D6DEB 8B8D 60C2FFFF MOV ECX,DWORD PTR SS:[EBP-3DA0]

003D6DF1 8908 MOV DWORD PTR DS:[EAX],ECX

003D6DF3 8B85 0CC8FFFF MOV EAX,DWORD PTR SS:[EBP-37F4]

003D6DF9 83C0 04 ADD EAX,4

003D6DFC 8985 0CC8FFFF MOV DWORD PTR SS:[EBP-37F4],EAX

003D6E02 ^E9 CEFCFFFF JMP 003D6AD5

003D6E07 FF15 80F03D00 CALL DWORD PTR DS:[3DF080] ; kernel32.GetTickCount

00F81970 1E E1 3B 00 CE AD 3B 00 -á;.έ;.

00F81978 07 AE 3B 00 68 58 AA 71 ®;.hXªq

Si vemos la dirección de memoria vemos que la entrada no es correcta como lo era en el momento de poner el Hardware Breakpoint, esto es por que la tabla al ser redireccionada fuera de la memoria se aprovecha para que esta zona de redireccionamiento sea variable y potencialmente diferente cada vez que se ejecute nuestra app, como sea, si vemos un poco arriba de la zona de nuestro Breakpoint vemos que ya hay entradas correctas, por lo que vamos por buen camino, quitemos nuestro Hardware Breakpoint y demos F8 hasta llegar a

003D6C00 FFB5 78C8FFFF PUSH DWORD PTR SS:[EBP-3788]

003D6C06 FF15 ECF23D00 CALL DWORD PTR DS:[3DF2EC] ; msvcrt.strchr

003D6C0C 59 POP ECX

003D6C0D 59 POP ECX

003D6C0E 40 INC EAX

003D6C0F 8985 78C8FFFF MOV DWORD PTR SS:[EBP-3788],EAX

003D6C15 83BD 94C4FFFF 00 CMP DWORD PTR SS:[EBP-3B6C],0

003D6C1C 74 71 JE SHORT 003D6C8F

003D6C1E 8B85 94C4FFFF MOV EAX,DWORD PTR SS:[EBP-3B6C]

003D6C24 8985 54C2FFFF MOV DWORD PTR SS:[EBP-3DAC],EAX

003D6C2A EB 0F JMP SHORT 003D6C3B

003D6C2C 8B85 54C2FFFF MOV EAX,DWORD PTR SS:[EBP-3DAC]

003D6C32 83C0 0C ADD EAX,0C

003D6C35 8985 54C2FFFF MOV DWORD PTR SS:[EBP-3DAC],EAX

003D6C3B 8B85 54C2FFFF MOV EAX,DWORD PTR SS:[EBP-3DAC]

003D6C41 8378 08 00 CMP DWORD PTR DS:[EAX+8],0

003D6C45 74 48 JE SHORT 003D6C8F

003D6C47 68 00010000 PUSH 100

003D6C4C 8D85 54C1FFFF LEA EAX,DWORD PTR SS:[EBP-3EAC]

003D6C52 50 PUSH EAX

003D6C53 8B85 54C2FFFF MOV EAX,DWORD PTR SS:[EBP-3DAC]

003D6C59 FF30 PUSH DWORD PTR DS:[EAX]

003D6C5B E8 8B14FEFF CALL 003B80EB

003D6C60 83C4 0C ADD ESP,0C

003D6C63 8D85 54C1FFFF LEA EAX,DWORD PTR SS:[EBP-3EAC]

003D6C69 50 PUSH EAX

003D6C6A FFB5 5CC2FFFF PUSH DWORD PTR SS:[EBP-3DA4]

003D6C70 FF15 58F33D00 CALL DWORD PTR DS:[3DF358] ; msvcrt._stricmp

003D6C76 59 POP ECX

Esta zona es un estándar del Armadillo y nos dice que estamos muy cerca del Salto Mágico que reparara la IAT, resalté los dos indicadores principales de la zona, si se sigue el salto de la dirección 003D6C45 nos llevara a

003D6C8F 8B85 A0C4FFFF MOV EAX,DWORD PTR SS:[EBP-3B60]

003D6C95 40 INC EAX

003D6C96 8985 A0C4FFFF MOV DWORD PTR SS:[EBP-3B60],EAX

003D6C9C 83BD 60C2FFFF 00 CMP DWORD PTR SS:[EBP-3DA0],0

003D6CA3 75 42 JNZ SHORT 003D6CE7

003D6CA5 0FB785 64C2FFFF MOVZX EAX,WORD PTR SS:[EBP-3D9C]

003D6CAC 85C0 TEST EAX,EAX

003D6CAE 74 0F JE SHORT 003D6CBF

003D6CB0 0FB785 64C2FFFF MOVZX EAX,WORD PTR SS:[EBP-3D9C]

003D6CB7 8985 64ADFFFF MOV DWORD PTR SS:[EBP+FFFFAD64],EAX

003D6CBD EB 0C JMP SHORT 003D6CCB

003D6CBF 8B85 5CC2FFFF MOV EAX,DWORD PTR SS:[EBP-3DA4]

003D6CC5 8985 64ADFFFF MOV DWORD PTR SS:[EBP+FFFFAD64],EAX

003D6CCB 6A 01 PUSH 1

003D6CCD FFB5 64ADFFFF PUSH DWORD PTR SS:[EBP+FFFFAD64]

003D6CD3 FFB5 98C4FFFF PUSH DWORD PTR SS:[EBP-3B68]

003D6CD9 E8 4634FEFF CALL 003BA124

003D6CDE 83C4 0C ADD ESP,0C

003D6CE1 8985 60C2FFFF MOV DWORD PTR SS:[EBP-3DA0],EAX

003D6CE7 83BD 60C2FFFF 00 CMP DWORD PTR SS:[EBP-3DA0],0

003D6CEE 75 42 JNZ SHORT 003D6D32

003D6CF0 0FB785 64C2FFFF MOVZX EAX,WORD PTR SS:[EBP-3D9C]

003D6CF7 85C0 TEST EAX,EAX

003D6CF9 74 0F JE SHORT 003D6D0A

La primera marca es el Salto Mágico y la segunda en la call que devuelve la dirección correcta de la API solicitada, así pues si el salto en 003D6CA3 se produce la call de 003D6CD9 no se ejecutara y la entrada quedara desviada a una zona del Armadillo y no a la API que le corresponde

Una vez explicado esto pongamos un Hardware Breakpoint on execution en 003D6CA3 que es nuestro salto mágico, antes de cerrar el Olly hay que explicar otras zonas del Armadillo

Si no lo recuerdan el bucle que resuelve las entradas de la IAT termina en

003D6DFC 8985 0CC8FFFF MOV DWORD PTR SS:[EBP-37F4],EAX

003D6E02 ^E9 CEFCFFFF JMP 003D6AD5

003D6E07 FF15 80F03D00 CALL DWORD PTR DS:[3DF080] ; kernel32.GetTickCount

003D6E0D 2B85 9CC4FFFF SUB EAX,DWORD PTR SS:[EBP-3B64]

003D6E13 8B8D A0C4FFFF MOV ECX,DWORD PTR SS:[EBP-3B60]

Ahora si seguimos ese código con la rueda del ratón [solo viendo no ejecutando] llegamos a esta zona

003D6FA7 33D2 XOR EDX,EDX

003D6FA9 BE 10270000 MOV ESI,2710

003D6FAE F7F6 DIV ESI

003D6FB0 03C8 ADD ECX,EAX

003D6FB2 898D 50C1FFFF MOV DWORD PTR SS:[EBP-3EB0],ECX

003D6FB8 83A5 48C1FFFF 00 AND DWORD PTR SS:[EBP-3EB8],0

003D6FBF EB 0D JMP SHORT 003D6FCE

Por igual es una zona estándar del Armadillo, este código genera un numero que será usado para decirle al Armadillo cuentas veces moverá la memoria de la IAT para mezclar las entradas de esta, en la línea marcada es cuando este numero se gurda en una zona de memoria para su posterior uso, este numero se adultera cuando corregimos las entradas de la IAT pero es muy fácil regresarlo a su valor original, lo veremos cuando lleguemos a ese punto, mientras pongamos un Hardware Breakpoint on execution en 003D6FB2

Bajando un poco mas llegaremos a

003D7015 0FAF85 40C8FFFF IMUL EAX,DWORD PTR SS:[EBP-37C0]

003D701C 33D2 XOR EDX,EDX

003D701E B9 10270000 MOV ECX,2710

003D7023 F7F1 DIV ECX

003D7025 8985 40C1FFFF MOV DWORD PTR SS:[EBP-3EC0],EAX

003D702B 8B85 E0C6FFFF MOV EAX,DWORD PTR SS:[EBP-3920]

003D7031 8B00 MOV EAX,DWORD PTR DS:[EAX]

003D7033 8985 44C1FFFF MOV DWORD PTR SS:[EBP-3EBC],EAX

003D7039 8B85 40C1FFFF MOV EAX,DWORD PTR SS:[EBP-3EC0]

003D703F 8D0485 04000000 LEA EAX,DWORD PTR DS:[EAX*4+4]

003D7046 50 PUSH EAX

003D7047 8B85 E0C6FFFF MOV EAX,DWORD PTR SS:[EBP-3920]

003D704D 83C0 04 ADD EAX,4

003D7050 50 PUSH EAX

003D7051 FFB5 E0C6FFFF PUSH DWORD PTR SS:[EBP-3920]

003D7057 FF15 FCF23D00 CALL DWORD PTR DS:[3DF2FC] ; msvcrt.memmove

003D705D 83C4 0C ADD ESP,0C

003D7060 8B85 40C1FFFF MOV EAX,DWORD PTR SS:[EBP-3EC0]

Esta zona, también estándar, es la que se encarga de mover la memoria cuantas veces le indique el parámetro anterior, la primera marca es la línea en la cual se obtiene la base de la zona de la memoria a la cual se redirigirán las llamadas a las APIs desde el código de nuestra app, anotemos esta dirección para futuros usos 003D702B, la segunda marca es un indicador de esta zona

Cerremos el Olly y editemos el archivo IAT Script.osc, que es un script para OllyScript

dbh

eoe LABEL

eob BABEL

run

LABEL:

esto

jmp LABEL

BABEL:

cmp eip, 003D6CA3

jne FIN

mov !ZF, 1

run

jmp BABEL

FIN:

ret

Cada vez que usemos este script hay que cambiar la dirección marcada para que sea igual a la dirección donde pusimos el Hardware Breakpoint on execution del salto mágico

Ahora abramos el Olly, carguemos nuestra app y ejecutemos IAT Script.osc, el script repara la IAT y después de unos segundos para en

003D6FB0 03C8 ADD ECX,EAX

003D6FB2 898D 50C1FFFF MOV DWORD PTR SS:[EBP-3EB0],ECX

003D6FB8 83A5 48C1FFFF 00 AND DWORD PTR SS:[EBP-3EB8],0

El valor de ECX es 00000348 este valor esta adulterado por la ejecución del script lo único que hay que hacer es pasar de 00000348 a 00000248, siempre que se llegue a este punto y el valor de ECX sea 3xx solo se modifica a 2xx y funcionara bien, borremos todos los Hardware Breakpoints [2]

Bajemos con la rueda del ratón [viendo no ejecutando] hasta la zona donde se toma la base de la IAT que es

003D6FCE 8B85 48C1FFFF MOV EAX,DWORD PTR SS:[EBP-3EB8]

003D6FD4 3B85 50C1FFFF CMP EAX,DWORD PTR SS:[EBP-3EB0]

003D6FDA 0F83 9A000000 JNB 003D707A

003D6FE0 68 0D5EDF01 PUSH 1DF5E0D

003D6FE5 FFB5 4CC1FFFF PUSH DWORD PTR SS:[EBP-3EB4]

003D6FEB 8D8D 4CC1FFFF LEA ECX,DWORD PTR SS:[EBP-3EB4]

003D6FF1 E8 7BA0FDFF CALL 003B1071

003D6FF6 40 INC EAX

003D6FF7 33D2 XOR EDX,EDX

003D6FF9 B9 00E1F505 MOV ECX,5F5E100

003D6FFE F7F1 DIV ECX

003D7000 8995 4CC1FFFF MOV DWORD PTR SS:[EBP-3EB4],EDX

003D7006 8B85 4CC1FFFF MOV EAX,DWORD PTR SS:[EBP-3EB4]

003D700C 33D2 XOR EDX,EDX

003D700E B9 10270000 MOV ECX,2710

003D7013 F7F1 DIV ECX

003D7015 0FAF85 40C8FFFF IMUL EAX,DWORD PTR SS:[EBP-37C0]

003D701C 33D2 XOR EDX,EDX

003D701E B9 10270000 MOV ECX,2710

003D7023 F7F1 DIV ECX

003D7025 8985 40C1FFFF MOV DWORD PTR SS:[EBP-3EC0],EAX

003D702B 8B85 E0C6FFFF MOV EAX,DWORD PTR SS:[EBP-3920]

003D7031 8B00 MOV EAX,DWORD PTR DS:[EAX]

003D7033 8985 44C1FFFF MOV DWORD PTR SS:[EBP-3EBC],EAX

003D7039 8B85 40C1FFFF MOV EAX,DWORD PTR SS:[EBP-3EC0]

003D703F 8D0485 04000000 LEA EAX,DWORD PTR DS:[EAX*4+4]

003D7046 50 PUSH EAX

003D7047 8B85 E0C6FFFF MOV EAX,DWORD PTR SS:[EBP-3920]

003D704D 83C0 04 ADD EAX,4

003D7050 50 PUSH EAX

003D7051 FFB5 E0C6FFFF PUSH DWORD PTR SS:[EBP-3920]

003D7057 FF15 FCF23D00 CALL DWORD PTR DS:[3DF2FC] ; msvcrt.memmove

003D705D 83C4 0C ADD ESP,0C

003D7060 8B85 40C1FFFF MOV EAX,DWORD PTR SS:[EBP-3EC0]

003D7066 8B8D E0C6FFFF MOV ECX,DWORD PTR SS:[EBP-3920]

003D706C 8B95 44C1FFFF MOV EDX,DWORD PTR SS:[EBP-3EBC]

003D7072 891481 MOV DWORD PTR DS:[ECX+EAX*4],EDX

003D7075 ^E9 47FFFFFF JMP 003D6FC1

003D707A FFB5 44C8FFFF PUSH DWORD PTR SS:[EBP-37BC]

003D7080 E8 5FA2FDFF CALL 003B12E4

La primera marca es donde se toma la base, esta dirección ya la debíamos tener anotada, la segunda marca es donde termina el bucle de la IAT pongamos un Hardware Breakpoint on execution en esa línea y demos un F9

Para en la dirección 003D707A que es el fin del bucle, en el Dump del Olly vayamos a la dirección de memoria a la que apunta ECX que en mi caso es 00F81478 y veremos

00F81478 8C B7 E5 77 D9 55 D1 77 Œ·åwÙUÑw

00F81480 24 04 E5 77 5E 19 D3 77 $ åw^Ów

00F81488 20 50 D2 77 25 74 32 77 PÒw%t2w

00F81490 2F 86 D2 77 4B 2F E5 77 /†ÒwK/åw

00F81498 BC 1B E4 77 0D 0D D4 77 ¼äw..Ôw

00F814A0 EE 63 C4 77 4B 17 0F 77 îcÄwKw

00F814A8 A0 35 00 10 F3 0C D4 77  5.ó.Ôw

00F814B0 4C 6E D2 77 03 6E D2 77 LnÒw nÒw

00F814B8 25 6E D2 77 65 3F C5 77 %nÒwe?Åw

Así pues 00F81478 es el inicio de nuestra IAT, ahora veamos donde termina, bajemos hasta llegar a

00F82160 E5 4D E5 77 6D AE 3B 00 åMåwm®;.

00F82168 3A F1 E5 77 A9 2B C4 77 :ñåw©+Äw

00F82170 1C AE 3B 00 AB AB AB AB ®;.««««

00F82178 AB AB AB AB EE FE EE FE ««««îþîþ

El final de la tabla es 00F82170 de esto concluimos que

Final - Inicio = tamaño

00F82170 - 00F81478 = CF8

Ahora abramos el ImpRec, seleccionemos el proceso uedit32.exe y pongamos los datos

VA - Base = RVA

RVA: 00F81478 – 00400000 = 00B81478

Size: CF8

El OEP no importa, le damos a Get Imports, le damos a Save Tree y guardamos el archivo como IAT 1.txt, sin cerrar el ImpRec editemos el archivo que acabamos de crear y busquemos la cadena de texto ‘ntdll’, nuestra primera ocurrencia será en

1 00B815E4 ntdll.dll 0192 RtlAllocateHeap

Esta entrada no funcionara en Win98 por obvias razones por lo que hay que redirigirla, en el ImpRec buscamos la entrada le damos doble clic, elegimos el modulo kernel32.dll y elegimos la API HeapAlloc, con lo cual quedara

1 00B815E4 kernel32.dll 01FC HeapAlloc

Hay que corregir todas las entradas que apunten a ntdll, todas estas son

# línea

* 1 00B815E4 ntdll.dll 0192 RtlAllocateHeap

* 1 00B815E4 kernel32.dll 01FC HeapAlloc

* 1 00B81670 ntdll.dll 031B RtlSizeHeap

* 1 00B81670 kernel32.dll 0208 HeapSize

* 1 00B816B4 ntdll.dll 0343 RtlUnwind

* 1 00B816B4 kernel32.dll 02BE RtlUnwind

* 1 00B81968 ntdll.dll 02A5 RtlLeaveCriticalSection

* 1 00B81968 kernel32.dll 023A LeaveCriticalSection

* 1 00B819A8 ntdll.dll 02F5 RtlRestoreLastWin32Error

* 1 00B819A8 kernel32.dll 030D SetLastError

* 1 00B81B74 ntdll.dll 02E7 RtlReAllocateHeap

* 1 00B81B74 kernel32.dll 0206 HeapReAlloc

* 1 00B81D58 ntdll.dll 0210 RtlEnterCriticalSection

* 1 00B81D58 kernel32.dll 0090 EnterCriticalSection

* 1 00B81E10 ntdll.dll 0256 RtlGetLastWin32Error

* 1 00B81E10 kernel32.dll 0162 GetLastError

* 1 00B81F14 ntdll.dll 01EB RtlDeleteCriticalSection

* 1 00B81F14 kernel32.dll 007B DeleteCriticalSection

Una vez hechas estas correcciones demos a Save Tree y guardemos la IAT como IAT Scram OK.txt, ahora ya podemos cerrar el ImpRec y borrar el archivo IAT 1.txt

De regreso en el Olly borremos el Hardware Breakpoint que pusimos al final del bucle de la IAT, ahora pongamos un Hardware Breakpoint on execution en la dirección donde se toma la zona para el redireccionamiento de las llamadas a las APIs de nuestra app, esta dirección ya la tenemos anotada y es 003D702B

Cerramos el Olly, lo volvemos a abrir, cargamos nuestra app, escondemos el dbg, demos F9 y para en

003D7023 F7F1 DIV ECX

003D7025 8985 40C1FFFF MOV DWORD PTR SS:[EBP-3EC0],EAX

003D702B 8B85 E0C6FFFF MOV EAX,DWORD PTR SS:[EBP-3920]

003D7031 8B00 MOV EAX,DWORD PTR DS:[EAX]

003D7033 8985 44C1FFFF MOV DWORD PTR SS:[EBP-3EBC],EAX

En el Dump vayamos a la zona EBP-3920 y veremos

00129538 40 14 F8 00 00 E0 15 00 @ø..à.

00129540 75 46 00 00 E8 EF EA 00 uF..èïê.

Ese es la base de la IAT 00F81440, ahora hay que cambiar esa base para que apunte a una zona dentro de la memoria de nuestra app, en lo personal me agrada usar una de las secciones del Armadillo, busquemos una en el Memory Map

Memory map

Address Size Owner Section Contains Type Access Initial

00001000 uedit32 PE header Imag R RWE

00401000 0015D000 uedit32 .text Imag R RWE

0055E000 00039000 uedit32 .rdata Imag R RWE

00597000 0004A000 uedit32 .data Imag R RWE

005E1000 00001000 uedit32 .SHARED data Imag R RWE

005E2000 00030000 uedit32 .text1 code Imag R RWE

00010000 uedit32 .adata code Imag R RWE

00622000 00020000 uedit32 .data1 imports Imag R RWE

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

Usemos la sección .adata, esta es una sección del Armadillo, modifiquemos la base de 00F81440 a 00612000 y quedara así

00129538 00 E0 15 00 .b..à.

00129540 75 46 00 00 E8 EF EA 00 uF..èïê.

Quitemos el Hardware Breakpoint y pongamos un Hardware Breakpoint on execution en el OEP que es 00514CB5, demos un F9 y para en

00514CB5 55 PUSH EBP

00514CB6 8BEC MOV EBP,ESP

00514CB8 6A FF PUSH -1

00514CBA 68 80885700 PUSH uedit32.00578880

00514CBF 68 A0855100 PUSH uedit32.005185A0

00514CC4 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]

00514CCA 50 PUSH EAX

00514CCB 64:8925 00000000 MOV DWORD PTR FS:[0],ESP

00514CD2 83EC 58 SUB ESP,58

00514CD5 53 PUSH EBX

00514CD6 56 PUSH ESI

00514CD7 57 PUSH EDI

00514CD8 8965 E8 MOV DWORD PTR SS:[EBP-18],ESP

00514CDB FF15 18156200 CALL DWORD PTR DS:[612518]

00514CE1 33D2 XOR EDX,EDX

00514CE3 8AD4 MOV DL,AH

La primera marca es el OEP, si notan la segunda marca es la primera llamada que debe apuntar a GetVersion, esta llamada que antes apuntaba a [00F81990] ahora apunta a [00612518] que está en la sección .adata dentro de la memoria de nuestro ejecutable, ejecutemos el LordPE y demos un dump full… [si da error solo cambien el ‘active dump engine’ a IntelliDump] al proceso uedit32.exe, guardemos el archivo como uedit32_dmp.exe

El archivo uedit32_dmp.exe tendrá las llamadas a las APIs redirigidas a la memoria que comienza en 00612000 que se encuentra en la sección .adata de la memoria de nuestro ejecutable, ahora lo que falta es escribir un código que se ejecute antes del OEP, que cargue los módulos y resuelva las direcciones de las APIs, las coloque en su respectivo lugar en la sección .adata y después le regrese el control al OEP, aquí es donde usaremos Armadillo Tools, ejecutemos esta utilidad, vallamos a la sección de IATScrambler y veremos

Aquí nos pide varios datos, algunos ya los tenemos y otros tendremos que obtenerlos

1. Ruta al archivo IAT que guardamos con el ImpRec
2. Ruta de nuestro ejecutable dumpeado con las llamadas a las APIs ya redirigidas
3. VA base a la cual se copiaran las direcciones de las APIs
4. VA donde se comenzara a ejecutar el código que reparara la IAT y devolverá el control al OEP
5. VA del OEP
6. Cantidad de bytes disponibles para el código de la reparación de la IAT
7. VA en la IAT del Armadillo donde se guarda la dirección de la API LoadLibrary
8. VA en la IAT del Armadillo donde se guarda la dirección de la API GetProcAddress

Tenemos los datos 1, 2, 3, y 5, axial que busquemos 4, 6, 7 y 8

Veamos el Memory Map a ver cual sección podemos usar

Memory map

Address Size Owner Section Contains Type Access Initial

00001000 uedit32 PE header Imag R RWE

00401000 0015D000 uedit32 .text Imag R RWE

0055E000 00039000 uedit32 .rdata Imag R RWE

00597000 0004A000 uedit32 .data Imag R RWE

005E1000 00001000 uedit32 .SHARED data Imag R RWE

005E2000 00030000 uedit32 .text1 code Imag R RWE

00612000 00010000 uedit32 .adata code Imag R RWE

00622000 00020000 uedit32 .data1 imports Imag R RWE

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

No podemos usar la sección .adata ya que es en esa sección donde se armara la IAT, la sección .data1 contiene importaciones que nos serán de utilidad, así que nuestra opción obvia es .text1 que comienza en 005E2000 y tiene un tamaño de 00030000 bytes, este es un tamaño excesivo para nuestras necesidades, además recordemos que aun nos falta el CodeSplicing, así que redondeemos, si nuestro EP es 005E2000 y solo deseamos usar hasta la dirección 005F0000, entonces

005F0000 – 005E2000 = E000

Ya tenemos el valor para el dato 4 y el 6, para el 7 y el 8 hay que cargar en el Olly nuestro ejecutable dumpeado uedit32_dmp.exe, en el Dump ir a la sección .data1 que es donde se guardan las importaciones y buscar donde se guardan las direcciones de las APIs LoadLibrary y GetProcAddress, para esto escribimos en la barra de comandos

En la ventana Dump que esta en la dirección 00622000 [inicio de .data1] damos un Ctrl+B y ponemos el valor HEX: que nos dio la barra de comandos pero de manera invertida

Presionamos OK y parara en

0062205C 61 D9 E5 77 0C 15 F4 77 aÙåw.ôw

00622064 AF DD E5 77 5D 26 E5 77 ¯Ýåw]&åw

0062206C 9B 58 E5 77 BC 1B E4 77 ›Xåw¼äw

00622074 58 E3 E5 77 7E 17 E4 77 Xãåw~äw

0062207C 6B 90 E4 77 4C A4 E5 77 k äwL¤åw

00622084 12 AC E5 77 C5 B6 E5 77 ¬åwŶåw

Por lo cual el valor para el dato 7 es 0062205C, hacemos lo mismo pero ahora ponemos en la barra de comandos la cadena ‘? GetProcAddress’ lo cual nos da un valor HEX: 77E5B332, en el Dump nos posicionamos en el inicio de la sección .data1, damos un Ctrl+B, ponemos el valor HEX: invertido, damos OK y para en

00622054 32 B3 E5 77 02 15 F4 77 2³åw ôw

0062205C 61 D9 E5 77 0C 15 F4 77 aÙåw.ôw

00622064 AF DD E5 77 5D 26 E5 77 ¯Ýåw]&åw

0062206C 9B 58 E5 77 BC 1B E4 77 ›Xåw¼äw

00622074 58 E3 E5 77 7E 17 E4 77 Xãåw~äw

0062207C 6B 90 E4 77 4C A4 E5 77 k äwL¤åw

El valor del dato 8 es 00622054, pongamos estos datos en el Armadillo Tools y quedara así

Presionemos el botón Parchar, nos dirá que el proceso ha terminado, se creara una copia de seguridad con el nombre de uedit32_dmp.exe.bak y nos dará un poco de información extra

Esto nos dice que en el archivo IAT había 830 entradas, de las cuales solo 637 eran verdaderas, estas 637 APIs perteneces a 18 módulos lo demás son las direcciones de las listas que usa el código que fue copiado a la dirección 005E2000 [por si a alguien le interesa], ahora debemos editar el archivo uedit32_dmp.exe con el LordPE y cambiar el EntryPoint para que apunte a 005E2000 así

Presionamos Save, OK y listo nuestro ejecutable ya tiene la IAT reparada, carguemos, en el Olly, el archivo uedit32_dmp.exe y vemos

Este es el código que cargara cada modulo, resolverá cada API y la copiara a su lugar correspondiente, en la línea que esta seleccionada es donde EAX tendrá la dirección de la API actual, si EAX es igual a cero significa que la API no fue encontrada, pongamos un Breakpoint condicional

Y un F2 en 005E20DC que es donde se le regresara el control al OEP, demos un F9 y el Breakpoint condicional no para lo que quiere decir que cada API fue encontrada y copiada a su lugar correspondiente, una vez en 005E20DC demos un F2 para quitar el Breakpoint, quitemos también el Breakpoint condicional y demos un F8, ya en el OEP veremos

00514CB5 55 PUSH EBP

00514CB6 8BEC MOV EBP,ESP

00514CB8 6A FF PUSH -1

00514CBA 68 80885700 PUSH uedit32_.00578880

00514CBF 68 A0855100 PUSH uedit32_.005185A0

00514CC4 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]

00514CCA 50 PUSH EAX

00514CCB 64:8925 00000000 MOV DWORD PTR FS:[0],ESP

00514CD2 83EC 58 SUB ESP,58

00514CD5 53 PUSH EBX

00514CD6 56 PUSH ESI

00514CD7 57 PUSH EDI

00514CD8 8965 E8 MOV DWORD PTR SS:[EBP-18],ESP

00514CDB FF15 18256100 CALL DWORD PTR DS:[612518] ; kernel32.GetVersion

00514CE1 33D2 XOR EDX,EDX

Como se puede observar la API kernel32.GetVersion fue resuelta y copiada a su lugar correspondiente, la IAT se reparara automáticamente cada vez que se ejecute el archivo

Con la IAT reparada veamos el CodeSplicing

Carguemos el uedit32.exe en el Olly, escondamos el dbg, pongamos un Hardware Breakpoint on execution en la dirección 00514CB5 [OEP], demos un F9 y para aquí

00514CB5 55 PUSH EBP

00514CB6 8BEC MOV EBP,ESP

00514CB8 6A FF PUSH -1

00514CBA 68 80885700 PUSH uedit32.00578880

00514CBF 68 A0855100 PUSH uedit32.005185A0

00514CC4 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]

00514CCA 50 PUSH EAX

00514CCB 64:8925 00000000 MOV DWORD PTR FS:[0],ESP

00514CD2 83EC 58 SUB ESP,58

00514CD5 53 PUSH EBX

Ya en el OEP, vayamos al Memory Map y busquemos una zona con las siguientes características

Memory map

Address Size Owner Section Contains Type Access Initial

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

007D0000 00002000 Map R E R E

00890000 00002000 Map R E R E

008A0000 00103000 Map R R

009B0000 0004C000 Map R E R E

00CB0000 00001000 Priv RW RW

00DB0000 0000D000 Priv RW RW

00DC0000 0000C000 Priv RW RW

00DD0000 00002000 Map R R

00DE0000 00018000 Priv RW RW

00E00000 000AF000 Priv RW RW

00EC1000 00001000 Priv RW RW

00EC5000 0000A000 Priv RW RW

00EE0000 00006000 Priv RW RW

00EF0000 00003000 Priv RW RW

00F30000 00001000 Map RW RW

00F40000 00001000 Priv RW RW

00F58000 00001000 Priv RW RW

00F81000 00002000 Priv RW RW

01140000 00003000 Priv RW RW

01150000 00010000 Priv RW RW

01550000 00003000 Priv RW RW

01590000 00001000 Priv RW RW

015A0000 00003000 Priv RW RW

015C0000 00002000 Map R R

015D0000 00010000 Priv RW RW

016D0000 00001000 SftpDLL PE header Imag R RWE

016D1000 00065000 SftpDLL .text code Imag R RWE

01736000 0000F000 SftpDLL .rdata imports,expo Imag R RWE

01745000 0000C000 SftpDLL .data data Imag R RWE

01751000 0000E000 SftpDLL .rsrc resources Imag R RWE

0175F000 00006000 SftpDLL .reloc relocations Imag R RWE

01770000 00001000 Priv RW RW

018EE000 00002000 Priv RW Guar RW

031C0000 00020000 Priv RWE RWE

10000000 00001000 SSCE4332 PE header Imag R RWE

10001000 00013000 SSCE4332 .text code Imag R RWE

La zona marcada es la que buscamos, tiene 2 características esenciales de una zona de CodeSplicing, las cuales son

Terminación en 0000 de la dirección [031C0000], esta es el primer indicador

Tamaño de 20000 bytes de la sección [00020000], esta es el segundo indicador

Como se puede observar ninguna otra zona cumple con estos 2 parámetros por lo que la zona donde esta el código del CodeSplicing es 031C0000, vayamos a esta dirección en el desensamblado y veremos

031C0000 53 PUSH EBX

031C0001 55 PUSH EBP

031C0002 56 PUSH ESI

031C0003 57 PUSH EDI

031C0004 8BF1 MOV ESI,ECX

031C0006 0FCF BSWAP EDI

031C0008 66:97 XCHG AX,DI

031C000A 50 PUSH EAX

031C000B 66:87FB XCHG BX,DI

031C000E 87D3 XCHG EBX,EDX

031C0010 87D3 XCHG EBX,EDX

031C0012 66:87FB XCHG BX,DI

031C0015 58 POP EAX

031C0016 66:87F6 XCHG SI,SI

031C0019 66:97 XCHG AX,DI

031C001B 0FCF BSWAP EDI

031C001D 6A 01 PUSH 1

031C001F -E9 A41424FD JMP uedit32.004014C8

031C0024 6A 00 PUSH 0

La línea marcada es un salto a la zona del código de nuestro ejecutable, sigamos ese salto y

004014C0 5B POP EBX

004014C1 5E POP ESI

004014C2 C3 RETN

004014C3 E9 38EBDB02 JMP 031C0000

004014C8 52 PUSH EDX

004014C9 5A POP EDX

004014CA 90 NOP

La línea marcada es donde nos lleva el salto de la zona 031C0000, si observan la instrucción anterior es un salto que lleva a la dirección 031C0000, este salto es el que nos interesa, por que al mover aleatoreamente la zona de la memoria donde esta el código del CodeSplicing, este salto debe modificarse para que apunte a la zona correcta, si se analiza la línea veremos que

004014C3 E9 38EBDB02 JMP 031C0000

El primer byte E9 es el OpCode [código de operación] este byte le indica a la maquina que la siguiente instrucción será un salto [JMP], los siguientes 4 bytes son la dirección relativa a la cual se dirigirá el salto, así pues

VA Base + Tamaño + Desplazamiento = VA resultante

004014C3 + 5 + 02DBEB38 = 031C0000

El VA Base y el tamaño de la instrucción son constantes, por lo cual, para que el salto apunte a otra dirección lo que se debe modificar son los 4 bytes de desplazamiento, estos bytes comienzan en la dirección 004014C4, apuntemos este dato, vayamos al Memory Map y demos doble clic en la primera sección superior a la memoria de nuestro ejecutable, la primera es

Memory map

Address Size Owner Section Contains Type Access Initial

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

007D0000 00002000 Map R E R E

00890000 00002000 Map R E R E

008A0000 00103000 Map R R

009B0000 0004C000 Map R E R E

Al dar doble clic saldrá una ventana de Dump, presionemos Ctrl+B y pongamos nuestro valor 004014C4 de forma invertida

Demos OK y no encontrara nada, presionemos Esc para cerrar la ventana Dump y demos doble clic sobre la siguiente zona de memoria, saldrá otra ventana de Dump, ahora solo presionemos Ctrl+L y se repetirá la búsqueda que hicimos anteriormente, una vez mas no encontrara nada, repitamos este procedimiento con cada zona de memoria sin dueño [Owner] hasta llegar a

00EC5908 C4 14 40 00 38 EB DB 02 20 00 1C 03 A4 14 24 FD Ä@.8ëÛ . ¤$ý

00EC5918 D7 14 40 00 49 EB DB 02 31 00 1C 03 A6 14 24 FD ×@.IëÛ 1. ¦$ý

00EC5928 F3 14 40 00 3E EB DB 02 51 00 1C 03 A2 14 24 FD ó@.>ëÛ Q. ¢$ý

00EC5938 06 15 40 00 4B EB DB 02 6A 00 1C 03 9C 14 24 FD @.KëÛ j. œ$ý

00EC5948 1F 15 40 00 4B EB DB 02 8C 00 1C 03 93 14 24 FD ­@.KëÛ Œ. “$ý

00EC5958 2C 15 40 00 60 EB DB 02 B5 00 1C 03 77 14 24 FD ,@.`ëÛ µ. w$ý

La zona de la memoria puede variar, si notan el primer valor marcado es la dirección donde comienzan los 4 bytes de desplazamiento del salto que va a 031C0000, los siguientes 4 bytes en esta zona de memoria son el valor que fue escrito en la zona indicada por los 4 bytes anteriores, de esto se concluye que

00EC5908 C4 14 40 00 38 EB DB 02 20 00 1C 03 A4 14 24 FD Ä@.8ëÛ . ¤$ý

00EC5918 D7 14 40 00 49 EB DB 02 31 00 1C 03 A6 14 24 FD ×@.IëÛ 1. ¦$ý

00EC5928 F3 14 40 00 3E EB DB 02 51 00 1C 03 A2 14 24 FD ó@.>ëÛ Q. ¢$ý

00EC5938 4B EB DB 02 6A 00 1C 03 9C 14 24 FD @.KëÛ j. œ$ý

00EC5948 1F 4B EB DB 02 8C 00 1C 03 93 14 24 FD ­@.KëÛ Œ. “$ý

00EC5958 2C 60 EB DB 02 B5 00 1C 03 77 14 24 FD ,@.`ëÛ µ. w$ý

Los valores en amarillo son direcciones de memoria dentro del código de nuestro ejecutable, los valores en verde son los bytes que serán escritos en las zonas que indican los bytes amarillos, correspondiéndose una a una, lo mismo pasa con los valores en turquesa, solo que estos están en la zona del código del CodeSplicing y sus valores correspondientes son los que están en fucsia

Con esta tabla podemos redirigir los saltos de la zona de código de nuestro ejecutable y que se correspondan con los saltos del código del CodeSplicing en cualquier zona de memoria que elijamos, esta tabla se arma en tiempo de ejecución, así que pongamos un Breakpoint, Hardware, on write, Dword en la dirección 00EC595C, elijo una dirección mas abajo del inicio de la tabla por que a veces esta tabla se mueve un poco hacia arriba o hacia abajo, así pues si la tabla se mueva unos bytes hacia abajo el Breakpoint aun estará en una buena zona

Cerremos el Olly, volvamos a abrirlo, carguemos nuestra app, ocultemos el dbg, demos un F9 y para algunas veces poniendo valores basura, sigamos presionando F9 hasta que pare en

003D4DB0 8985 4CC6FFFF MOV DWORD PTR SS:[EBP-39B4],EAX

003D4DB6 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4DBC 8B8D 2CC6FFFF MOV ECX,DWORD PTR SS:[EBP-39D4]

003D4DC2 8908 MOV DWORD PTR DS:[EAX],ECX

003D4DC4 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4DCA 83C0 04 ADD EAX,4

003D4DCD 8985 4CC6FFFF MOV DWORD PTR SS:[EBP-39B4],EAX

003D4DD3 8B85 24C6FFFF MOV EAX,DWORD PTR SS:[EBP-39DC]

003D4DD9 8B8D 08C7FFFF MOV ECX,DWORD PTR SS:[EBP-38F8]

003D4DDF 8D4401 04 LEA EAX,DWORD PTR DS:[ECX+EAX+4]

00EC5940 B5 00 DE 02 77 14 62 FD µ.Þ wbý

00EC5948 DF 16 40 00 D6 E9 9D 02 ß@.Öé

00EC5950 CD 00 DE 02 12 16 62 FD Í.Þ bý

00EC5958 EC 16 40 00 E1 E9 9D 02 ì@.áé

00EC5960 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

00EC5968 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

00EC5970 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

Esta es la zona que buscábamos, en el desensamblado presionemos F8 hasta llegar a

003D4D4D 8985 44C6FFFF MOV DWORD PTR SS:[EBP-39BC],EAX

003D4D53 8B85 44C6FFFF MOV EAX,DWORD PTR SS:[EBP-39BC]

003D4D59 8B00 MOV EAX,DWORD PTR DS:[EAX]

003D4D5B 8985 28C6FFFF MOV DWORD PTR SS:[EBP-39D8],EAX

003D4D61 8B85 44C6FFFF MOV EAX,DWORD PTR SS:[EBP-39BC]

003D4D67 83C0 04 ADD EAX,4

003D4D6A 8985 44C6FFFF MOV DWORD PTR SS:[EBP-39BC],EAX

003D4D70 A1 B0F13E00 MOV EAX,DWORD PTR DS:[3EF1B0]

003D4D75 0385 20C6FFFF ADD EAX,DWORD PTR SS:[EBP-39E0]

003D4D7B 8B8D 24C6FFFF MOV ECX,DWORD PTR SS:[EBP-39DC]

003D4D81 8B95 08C7FFFF MOV EDX,DWORD PTR SS:[EBP-38F8]

003D4D87 8D4C0A 04 LEA ECX,DWORD PTR DS:[EDX+ECX+4]

003D4D8B 2BC1 SUB EAX,ECX

003D4D8D 8985 2CC6FFFF MOV DWORD PTR SS:[EBP-39D4],EAX

En la línea marcada es donde se toma el valor base de la zona de memoria donde está el código del CodeSplicing y con esta base se creara la tabla para redirigir los saltos de las dos zonas para que se correspondan, un poco mas abajo hay mas referencias a esta zona de memoria [003EF1B0], pero nosotros solo buscamos la primera que esta en la dirección 003D4D70, quitemos el Hardware Breakpoint que pusimos en 00EC595C, pongamos un Hardware Breakpoint on execution en la línea adonde se toma la base del CodeSplicing que es 003D4D70, antes de cerrar el Olly pongamos otro Hardware Breakpoint on execution en la dirección donde termina el bucle de la creación de la tabla del CodeSplicing que es en

003D4E2B 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4E31 83C0 04 ADD EAX,4

003D4E34 8985 4CC6FFFF MOV DWORD PTR SS:[EBP-39B4],EAX

003D4E3A ^E9 C8FEFFFF JMP 003D4D07

003D4E3F 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4E45 8320 00 AND DWORD PTR DS:[EAX],0

003D4E48 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4E4E 83C0 04 ADD EAX,4

003D4E51 8985 4CC6FFFF MOV DWORD PTR SS:[EBP-39B4],EAX

003D4E57 FF15 80F03D00 CALL DWORD PTR DS:[3DF080] ; kernel32.GetTickCount

Ahora cerramos el Olly, lo volvemos a abrir, cargamos nuestra app, escondemos el dbg, damos F9 y para en

003D4D67 83C0 04 ADD EAX,4

003D4D6A 8985 44C6FFFF MOV DWORD PTR SS:[EBP-39BC],EAX

003D4D70 A1 B0F13E00 MOV EAX,DWORD PTR DS:[3EF1B0]

003D4D75 0385 20C6FFFF ADD EAX,DWORD PTR SS:[EBP-39E0]

003D4D7B 8B8D 24C6FFFF MOV ECX,DWORD PTR SS:[EBP-39DC]

En el Dump vayamos a la zona de memoria 003EF1B0 y veremos

003EF1B0 00 00 00 00 ..–....

003EF1B8 00 00 00 00 00 00 00 00 ........

003EF1C0 00 00 00 00 00 00 00 00 ........

003EF1C8 00 00 00 00 00 00 00 00 ........

003EF1D0 00 00 00 00 00 00 00 00 ........

Esta es la nueva base 01960000, ahora hay que modificar este valor para que apunte a una zona dentro de nuestro ejecutable, veamos el Memory Map para ver que sección podemos usar

Memory map

Address Size Owner Section Contains Type Access Initial

00001000 uedit32 PE header Imag R RWE

00401000 0015D000 uedit32 .text Imag R RWE

0055E000 00039000 uedit32 .rdata Imag R RWE

00597000 0004A000 uedit32 .data Imag R RWE

005E1000 00001000 uedit32 .SHARED data Imag R RWE

005E2000 00030000 uedit32 .text1 code Imag R RWE

00612000 00010000 uedit32 .adata code Imag R RWE

00622000 00020000 uedit32 .data1 imports Imag R RWE

00642000 00110000 uedit32 .pdata Imag R RWE

00752000 0006F000 uedit32 .rsrc resources Imag R RWE

No podemos usar la sección .adata ya que en esa memoria se armara la IAT, no podemos usar .data1 por que ahí hay importaciones que necesitamos, la sección obvia es .text1, como recordaran usamos la zona de memoria que va desde 005E2000 hasta 005F0000, exactamente para eso la redondee hasta llegar a un numero que terminara en 4 ceros, ahora si ven el tamaño es 30000 y nosotros solo usamos E000 por lo que todavía nos queda 22000 y el código del CodeSplicing solo mide 20000 así que tenemos 2000 bytes de sobra

Modifiquemos la memoria en 003EF1B0 para que apunte a 005F0000 y queda así

003EF1B0 00 00 5F 00 00 00 00 00 .._.....

003EF1B8 00 00 00 00 00 00 00 00 ........

003EF1C0 00 00 00 00 00 00 00 00 ........

003EF1C8 00 00 00 00 00 00 00 00 ........

003EF1D0 00 00 00 00 00 00 00 00 ........

Quietemos el Breakpoint de 003D4D70, demos un F9 y para en

003D4E34 8985 4CC6FFFF MOV DWORD PTR SS:[EBP-39B4],EAX

003D4E3A ^E9 C8FEFFFF JMP 003D4D07

003D4E3F 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

003D4E45 8320 00 AND DWORD PTR DS:[EAX],0

003D4E48 8B85 4CC6FFFF MOV EAX,DWORD PTR SS:[EBP-39B4]

Este es el final del bucle, ya que paro aquí borremos este Breakpoint, ahora vayamos a la zona de memoria donde se arma la tabla que es mas o menos en la dirección 00EC595C, una vez ahí buscamos hacia arriba hasta llegar a

00EC58D8 00 00 00 00 00 00 00 00 ........

00EC58E0 81 11 20 2D 01 07 18 00

00EC58E8 C4 14 40 00 38 EB 1E 00 Ä@.8ë-.

00EC58F0 20 00 5F 00 A4 14 E1 FF ._.¤áÿ

00EC58F8 D7 14 40 00 49 EB 1E 00 ×@.Ië-.

00EC5900 31 00 5F 00 A6 14 E1 FF 1._.¦áÿ

00EC5908 F3 14 40 00 3E EB 1E 00 ó@.>ë-.

Este es el inicio de la tabla del CodeSplicing, ahora busquemos el final que esta en

00ECE4B0 AA FF 5F 00 1A EF E1 FF ªÿ_.ïáÿ

00ECE4B8 DA EE 41 00 D0 10 1E 00 ÚîA.Ð-.

00ECE4C0 C9 FF 5F 00 11 EF E1 FF Éÿ_.ïáÿ

00ECE4C8 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

00ECE4D0 0D F0 AD BA 0D F0 AD BA .ð­º.ð­º

Seleccionemos la zona de memoria que va desde 00EC58E8 hasta 00ECE4C8, le damos clic con el botón secundario del ratón, elegimos Binary, Binary copy, después abrimos el HexWorkshop, presionamos Ctrl+N, vamos al menú Edit, Paste Special…

Presionamos Paste y guardamos el archivo como CodeSPTab.bin, cerramos el archivo más no el HexWorkshop, en el Olly vayamos a la zona del código del CodeSplicing que es 01960000 y seleccionemos desde 01960000 hasta 01980000, damos un Binary copy, vamos al HexWorkshop, lo pegamos igual que el anterior y lo guardamos como CodeSPCode.bin, cerramos el HexWorkshop y el Olly

Ya teniendo los 2 archivo binarios y la tabla redirigida a la zona de nuestra elección, ejecutemos Armadillo Tools, en la sección del CodeSplicing pongamos los datos que nos pide

Presionamos Parchar, nos dirá que el archivo uedit32_dmp.exe.bak ya existe y si deseamos reemplazarlo, en lo personal yo nunca reemplazo lo baks, pero como ustedes deseen presionen Si o No, después nos dice que el proceso ha terminado y nos da un poco de información

Esto nos dice que según la tabla, el código debe ser copiado a la zona 005F0000 que es la que nosotros elegimos, así que todo salio bien

Ahora renombremos el archivo uedit32.exe a uedit32_or.exe y el archivo uedit32_dmp.exe a uedit32.exe, ejecutémoslo y corre bien solo que nos dice que el tiempo de evaluación de 45 días ha terminado, para evitar esto se tienen que modificar 2 bytes del código del uedit32.exe

Cargamos el uedit32.exe en el Olly y ponemos un Breakpoint condicional en la API LoadLibraryA, así [ESP+4]=="armaccess.dll", al parar damos un Ctrl+F9 un F8 y veremos que el uedit comprueba si se cargo la dll si no va a un RETN y luego hace esta comprobación

00401EC4 84C0 TEST AL,AL

00401EC6 75 03 JNZ SHORT uedit32.00401ECB

00401EC8 895D F0 MOV DWORD PTR SS:[EBP-10],EBX

Lo único que debemos hacer es cambiar el 7503 por un EB03, damos F9 y vuelve a parar en LoadLibraryA, una vez mas comprueba si se cargo la dll si no va a un RETN y luego hace esta comprobación

00401EFB 59 POP ECX

00401EFC 84C0 TEST AL,AL

00401EFE 59 POP ECX

00401EFF 75 03 JNZ SHORT uedit32.00401F04

00401F01 895D F0 MOV DWORD PTR SS:[EBP-10],EBX

Por igual cambiamos 7503 por EB03, quitamos el Breakpoint, damos F9 y nos sigue diciendo que el tiempo de evaluación termino, esto es por que comprueba que la variable ALTUSERNAME exista, por lo que debemos crear un pequeño código que haga

push VA

push VA

Call SetEnvironmentVariableA

El primer push empujara a la pila la dirección donde esta la cadena de texto terminada en 00h que será el valor de la variable, el segundo push empuja a la pila la dirección de la cadena terminada en 00h que será el nombre de la variable [ALTUSERNAME] y el call la pondrá en memoria, esta función se puede buscar igual que como buscamos las APIs LoadLibrary y GetProcAddress, al realizar estos cambios el uedit iniciara correctamente y estará registrado a nombre del valor de la variable ALTUSERNAME

Yo lo hice al final del código que repara la IAT y queda así

005E20CD |. 3C 00 |CMP AL,0

005E20CF |.^0F85 7BFFFFFF \JNZ uedit32.005E2050

005E20D5 |. 68 00CB5E00 PUSH uedit32.005ECB00 ; /Value = "Tk0017/TMT"

005E20DA |. 68 18CB5E00 PUSH uedit32.005ECB18 ; |VarName = "ALTUSERNAME"

005E20DF |. FF15 7C206200 CALL DWORD PTR DS:[<&KERNEL32.SetEnvironmentVariableA>]

005E20E5 |. 9D POPFD

005E20E6 |. 61 POPAD

005E20E7 |. 68 B54C5100 PUSH uedit32.00514CB5

005E20EC \. C3 RETN

005E20ED 90 NOP

Si usan la memoria de 005E2000 a 005F0000 deben tener cuidado ya que es la memoria que usa el código que repara la IAT, si notan yo use las zonas 005ECB00 y 005ECB18, esta es la memoria mas ‘alta’ que se puede usar ya que a partir de 005ECB40 [mas o menos] la memoria pertenece al código que repara la IAT, la memoria que se puede usar va desde desdé el NOP en 005E20ED hasta 005ECB40, lo que da un total de AA53 bytes [+42 KB], este es espacio suficiente para añadir otras variables a la memoria [si fuera necesario], hacer parches, crear procesos, etc.

Estos cambios darán este resultado

Bien, nos vemos en Armadillo 3.x parte2 version2

“That’s all folks”