Check Integrity Macro Themida :v

[josue9243]

¿Cómo se parchean?, todos los check integrity de themida son iguales pero nunca encontre un tutorial o algo que explique como parchearlos.

Lo que se es que leen sections y partes de códigos etc, tengo los ADDRESS de donde estan etc, si alguien es tan amable de explicarme que retornar o hacer xD.

[Geovane]

Si tienes todo, sin embargo no puedes hacer patcher, significa que esta compactado.



Saludos

[josue9243]

Yo se donde estan, pero no se como funciona este sistema, en si el código se entiende, y parte del código tiene junkcode, pero es muy simple, yo en si puedo modificar ese check integrity, pero no se como funciona, por lo tanto no se que modificar.

[apuromafo CLS]

¿Cómo se parchean?, todos los check integrity de themida son iguales pero nunca encontre un tutorial o algo que explique como parchearlos.

Lo que se es que leen sections y partes de códigos etc, tengo los ADDRESS de donde estan etc, si alguien es tan amable de explicarme que retornar o hacer xD.

themida posee crc , el cual usan script , ejemplo el de LCF de tuts4you,

Lo que pasa es que themida tiene máquina virtual, en esa emulacion hay codigos que son iguales siempre y ahi cae en una parte donde compara el valor original, versus el parchado, encontrar ese lugar es como de aguja en un pajar, pero como verás, hay personas que han logrado estudiar a fondo el packer, a pesar de tan grandes protecciones.


Asi que eso , las macros, son protecciones sdk de programa, y que cada uno elige si colocarlas o no


Saludos Apuromafo

pd: en crackslatinos hay tutoriales que apuntan a inline en themida, otros tambien apuntan a desempacado manual por completo, y otros a parcharlos en runtime (mientras se ejecutan)

[josue9243]

c, pero esas son versiones viejas, igual me voy a fijar, osea lo que yo quiero es parchear el código sin que el anti cheat salte "no segment code integrity", que seguro es una api de themida porque lo encontro el script en anteriores versiones de themida en ese mismo anticheat.

En si lo que quiero es parchear esa cosa, y no el CRC. xD

[Geovane]

¡Hola

¿Puede colocar la parte del programa que realiza esta comprobación?
"Anticheat"

Saludos

[josue9243]

ASM:

Código [Seleccionar] Expandir


push ecx
mov ecx,esp
add ecx,4
sub ecx,4
xchg dword ptr ss:[esp],ecx
pop esp
mov dword ptr ss:[esp],ebx
sub esp,4
mov dword ptr ss:[esp],edi
mov dword ptr ss:[esp],ecx
push 5A48BE57
mov dword ptr ss:[esp],ebp
mov dword ptr ss:[esp],edx
sub esp,4
mov dword ptr ss:[esp],eax
mov dword ptr ss:[esp],esi
push eax
mov eax,esp
add eax,4
sub eax,4
xchg dword ptr ss:[esp],eax
pop esp
mov dword ptr ss:[esp],edi
cmp byte ptr ss:[ebp+187BE0B0],0
je sxe.6391315
push A
call dword ptr ss:[ebp+1838325A]
jmp sxe.63912FB
mov byte ptr ss:[ebp+187BE0B0],1
lea esi,dword ptr ss:[ebp+187BE0B1]
push edx
mov edx,9
add esi,edx
mov edx,dword ptr ss:[esp]
add esp,4
push eax
mov eax,0
add eax,esi
push dword ptr ds:[eax]
pop ebx
pop eax
sub esp,4
mov dword ptr ss:[esp],eax
mov eax,4
add esi,eax
pop eax
cmp dword ptr ds:[esi],0 // First Check Integrity
jne sxe.6391360
cmp dword ptr ds:[esi+4],0
je sxe.639140D
push ecx
mov ecx,0
add ecx,esi
mov eax,dword ptr ds:[ecx]
mov ecx,dword ptr ss:[esp]
add esp,4
sub eax,7F7B962E
sub eax,3EE7A3E2
sub eax,ebx
add eax,3EE7A3E2
add eax,7F7B962E
push esi
mov esi,CD7BB89
xor eax,esi
mov esi,dword ptr ss:[esp]
add esp,4
push ecx
mov ecx,0
sub ecx,5AF584F1
add ecx,esi
add ecx,5AF584F1
mov dword ptr ds:[ecx],eax
pop ecx
rol ebx,1
push dword ptr ds:[esi+4]
pop eax
add eax,iertutil.772F1942
sub eax,ebx
push ebp
mov ebp,iertutil.772F1942
sub eax,ebp
pop ebp
push ebx
push 5B8A38A7
pop ebx
shl ebx,5
add ebx,9B90A6A9
xor eax,ebx
pop ebx
push eax
xor dword ptr ss:[esp],6F5F7103
pop dword ptr ds:[esi+4]
push ecx
mov ecx,4
add ecx,esi
xor dword ptr ds:[ecx],6F5F7103
pop ecx
rol ebx,1
push 3AAB77C9
mov dword ptr ss:[esp],eax
mov eax,8
add esi,eax
pop eax
jmp sxe.639134D
mov ebx,dword ptr ss:[ebp+18380AD1]
push dword ptr ds:[ebx+3C]
push edi
mov edi,5EFF845B
add dword ptr ss:[esp+4],edi
pop edi
pop eax
sub eax,5EFF845B
add ebx,77BF5D11
add ebx,eax
push esi
mov esi,2CEF75AD
or esi,5FF5A1EA
inc esi
not esi
sub esi,77FFE09E
and esi,7F4B4372
xor esi,7FBF5C61
sub ebx,esi
pop esi
push edx
mov edx,6BEFF75E
sub edx,2DFF8F90
sub edx,1
xor edx,44F6C88D
dec edx
add edx,86F951B9
add ebx,edx
pop edx
sub esp,4
mov dword ptr ss:[esp],ecx
mov ecx,C
add ecx,ebx
mov edi,dword ptr ds:[ecx]
pop ecx
add edi,dword ptr ss:[ebp+18380AD1]
lea esi,dword ptr ss:[ebp+187BE0B1]
push edi
push ebp
push 5BB968A4
pop ebp
xor ebp,5BB968A9
mov edi,ebp
pop ebp
add esi,edi
pop edi
xor eax,eax
cmp dword ptr ds:[esi],0 // Second Check Integrity
jne sxe.63914BA
cmp dword ptr ds:[esi+4],0
je sxe.639157C
push dword ptr ds:[esi]
sub dword ptr ss:[esp],56EFF560
pop edx
push ebp
mov ebp,56EFF560
add edx,ebp
pop ebp
sub edx,7FFF9E82
add edx,edi
push edi
mov edi,client.DDE3E3B
add edi,72216047
add edx,edi
pop edi
push dword ptr ds:[esi+4]
mov ebx,dword ptr ss:[esp]
add esp,4
add ebx,6BEB95DB
add ebx,edi
push eax
mov eax,7F554B92
inc eax
sub eax,1369B5B8
sub ebx,eax
pop eax
cmp edx,ebx
jae sxe.6391562
push user32.76ECFD2D
mov dword ptr ss:[esp],ecx
mov ecx,0
add ecx,edx
add al,byte ptr ds:[ecx]
pop ecx
push ebp
mov dword ptr ss:[esp],edx
mov dh,D4
add dh,5C
shr dh,3
or dh,70
sub dh,E3
add al,dh
pop edx
push ebx
mov bh,10
add bh,1
xor bh,30
xor al,bh
pop ebx
rol eax,1
push ebp
mov ebp,3C5F09A7
inc ebp
neg ebp
shr ebp,1
xor ebp,57642C5E
xor ebp,36B45773
add edx,ebp
pop ebp
jmp sxe.6391504
push edi
mov edi,8
sub esi,198D197B
add esi,edi
add esi,198D197B
pop edi
jmp sxe.63914A7
lea esi,dword ptr ss:[ebp+187BE0B1]
push edi
mov edi,9
add esi,77E50AC5
add esi,edi
sub esi,77E50AC5
pop edi
cmp eax,dword ptr ds:[esi]
je sxe.63915C8
sub esp,4
mov dword ptr ss:[esp],ecx
push 7FDFD001
pop ecx
sub ecx,1AAE010D
shl ecx,8
xor ecx,6A4B2939
xor ecx,5B85DD39
mov eax,ecx
pop ecx
jmp sxe.63915F3
push edi
mov edi,39554980
add edi,33BA66F1
xor edi,7EB7A484
push edx
mov edx,49DFF7D1
sub edx,7AAFFE83
dec edx
xor edx,DC97EDB9
xor edi,edx
pop edx
mov eax,edi
pop edi
push ebp
mov ebp,esp
add ebp,4
sub ebp,4
xchg dword ptr ss:[esp],ebp
pop esp
mov dword ptr ss:[esp],eax
lea esi,dword ptr ss:[ebp+187BE0B1]
push ecx
mov ecx,9
add esi,ecx
mov ecx,dword ptr ss:[esp]
add esp,4
push dword ptr ds:[esi]
add dword ptr ss:[esp],35FD663D
mov ebx,dword ptr ss:[esp]
add esp,4
sub ebx,35FD663D
push eax
mov eax,4
sub esi,3AF7F1D5
add esi,eax
add esi,3AF7F1D5
pop eax
cmp dword ptr ds:[esi],0 // Third Check Integrity
jne sxe.639165D
cmp dword ptr ds:[esi+4],0
je sxe.6391737
sub esp,4
mov dword ptr ss:[esp],edx
mov edx,0
add edx,esi
mov eax,dword ptr ds:[edx]
pop edx
push ebp
mov ebp,7FCEE7C2
shr ebp,1
xor ebp,3330C868
xor eax,ebp
mov ebp,dword ptr ss:[esp]
add esp,4
push ebx
mov ebx,3FEFBACC
sub ebx,13FFE3B2
xor ebx,7EDBC211
xor ebx,2383ECA9
sub eax,ebx
pop ebx
add eax,ebx
add eax,shell32.76B7F9A2
push ebx
mov dword ptr ss:[esp],eax
xor dword ptr ss:[esp],7EFFDAF1
pop dword ptr ds:[esi]
xor dword ptr ds:[esi],7EFFDAF1
rol ebx,1
push dword ptr ds:[esi+4]
mov eax,dword ptr ss:[esp]
add esp,4
sub esp,4
mov dword ptr ss:[esp],ebp
mov ebp,CD7BB89
xor eax,ebp
pop ebp
sub eax,794BBFD8
add eax,67EE9374
add eax,ebx
sub eax,67EE9374
add eax,794BBFD8
push eax
add dword ptr ss:[esp],77EEC400
pop dword ptr ds:[esi+4]
push edi
mov edi,4F3FD7BE
and edi,1BE7AF79
or edi,7FFFB426
sub edi,810F33E
sub dword ptr ds:[esi+4],edi
pop edi
rol ebx,1
push ebx
push edx
mov edx,7B3395E4
xor edx,57FBF0DA
add edx,D3379ACA
mov ebx,edx
pop edx
add esi,ebx
pop ebx
jmp sxe.639164A
mov byte ptr ss:[ebp+187BE0B0],0
push dword ptr ss:[esp]
pop eax
add esp,4
mov edi,dword ptr ss:[esp]
push ecx
mov ecx,esp
add ecx,4
add ecx,4
xchg dword ptr ss:[esp],ecx
pop esp
push dword ptr ss:[esp]
pop esi
add esp,4
mov edx,dword ptr ss:[esp]
push edi
mov edi,esp
add edi,4
add edi,4
xchg dword ptr ss:[esp],edi
pop esp
push dword ptr ss:[esp]
pop ecx
add esp,4
mov ebx,dword ptr ss:[esp]
push esi
mov esi,esp
add esi,4
add esi,4
xchg dword ptr ss:[esp],esi
pop esp
ret

Pseudo of snowman: (x32dbg)

Código [Seleccionar] Expandir

struct s0 {
    int32_t f0;
    int32_t f4;
};

struct s1 {
    int32_t f0;
    uint32_t f4;
};

struct s2 {
    int8_t[60] pad60;
    int32_t f60;
};

struct s3 {
    int32_t f0;
    void* f4;
};

struct s4 {
    uint32_t f0;
    uint32_t f4;
};

void fun_63912b6(int32_t ecx, int32_t a2, int32_t a3) {
    int32_t v4;
    int32_t edi5;
    int32_t ebp6;
    int32_t ebp7;
    int32_t ebp8;
    struct s0* esi9;
    void* ebp10;
    int32_t v11;
    int32_t ebx12;
    struct s1* esi13;
    uint32_t eax14;
    uint32_t v15;
    int32_t ebp16;
    uint32_t eax17;
    uint32_t* ecx18;
    struct s2* ebx19;
    int32_t v20;
    void* v21;
    int32_t ebp22;
    struct s3* esi23;
    void* edi24;
    int32_t eax25;
    int32_t v26;
    int8_t* edx27;
    void* edi28;
    void* v29;
    int8_t* ebx30;
    uint8_t al31;
    int32_t ebp32;
    int32_t* esi33;
    int32_t v34;
    int32_t ebx35;
    struct s4* esi36;
    uint32_t eax37;
    uint32_t v38;
    int32_t v39;

    v4 = edi5;
    while (*(int8_t*)(ebp6 + 0x187be0b0)) {
        *(int32_t*)(ebp7 + 0x1838325a)(10, v4);
    }
    *(int8_t*)(ebp8 + 0x187be0b0) = 1;
    esi9 = (struct s0*)((int32_t)ebp10 + 0x187be0b1 + 9);
    v11 = esi9->f0;
    ebx12 = v11;
    esi13 = (struct s1*)&esi9->f4;
    while (esi13->f0 || esi13->f4) {
        eax14 = (uint32_t)(esi13->f0 - 0x7f7b962e - 0x3ee7a3e2 - ebx12 + 0x3ee7a3e2 + 0x7f7b962e);
        *(uint32_t*)(0x5af584f1 - (int32_t)esi13 + 0x5af584f1) = eax14 ^ 0xcd7bb89;
        asm("rol ebx, 0x1");
        v15 = esi13->f4;
        ebp16 = ebp16;
        eax17 = v15 + 0x772f1942 - ebx12 - 0x772f1942 ^ 0xcd7bb89;
        ebx12 = ebx12;
        esi13->f4 = eax17 ^ 0x6f5f7103;
        ecx18 = &esi13->f4;
        *ecx18 = *ecx18 ^ 0x6f5f7103;
        asm("rol ebx, 0x1");
        ++esi13;
    }
    ebx19 = *(struct s2**)(ebp16 + 0x18380ad1);
    v20 = ebx19->f60;
    v21 = (void*)((int32_t)*(void**)(12 + ((int32_t)ebx19 + 0x77bf5d11 + (v20 + 0x5eff845b - 0x5eff845b) - 0x77bf5d11 + 0xf8)) + (int32_t)*(struct s2**)(ebp16 + 0x18380ad1));
    ebp22 = ebp16;
    esi23 = (struct s3*)(ebp16 + 0x187be0b1 + 13);
    edi24 = v21;
    eax25 = 0;
    while (esi23->f0 || esi23->f4) {
        v26 = esi23->f0;
        ebp22 = ebp22;
        edx27 = (int8_t*)(v26 - 0x56eff560 + 0x56eff560 - 0x7fff9e82 + (int32_t)edi24 + 0x7fff9e82);
        edi28 = edi24;
        v29 = esi23->f4;
        ebx30 = (int8_t*)((int32_t)v29 + 0x6beb95db + (int32_t)edi28 - 0x6beb95db);
        eax25 = eax25;
        while ((uint32_t)edx27 < (uint32_t)ebx30) {
            al31 = (uint8_t)(*(uint8_t*)&eax25 + *edx27);
            *(uint8_t*)&eax25 = (uint8_t)((uint8_t)(al31 - 0x6d) ^ 33);
            ebx30 = ebx30;
            asm("rol eax, 0x1");
            edx27 = (int8_t*)((uint32_t)edx27 + ((uint32_t)-0x3c5f09a8 >> 1 ^ 0x57642c5e ^ 0x36b45773));
            ebp22 = ebp22;
        }
        esi23 = (struct s3*)((int32_t)esi23 - 0x198d197b + 8 + 0x198d197b);
        edi24 = edi28;
    }
    if (eax25 == *(int32_t*)(ebp22 + 0x187be0b1 + 0x77e50ac5 + 9 - 0x77e50ac5)) {
    }
    ebp32 = ebp22;
    esi33 = (int32_t*)(ebp32 + 0x187be0b1 + 9);
    v34 = *esi33;
    ebx35 = v34 + 0x35fd663d - 0x35fd663d;
    esi36 = (struct s4*)((int32_t)esi33 - 0x3af7f1d5 + 4 + 0x3af7f1d5);
    while (esi36->f0 || esi36->f4) {
        eax37 = esi36->f0;
        esi36->f0 = (eax37 ^ 0xcd7bb89) - 0x76b7f9a2 + ebx35 + 0x76b7f9a2 ^ 0x7effdaf1;
        esi36->f0 = esi36->f0 ^ 0x7effdaf1;
        asm("rol ebx, 0x1");
        v38 = esi36->f4;
        ebp32 = ebp32;
        esi36->f4 = (v38 ^ 0xcd7bb89) - 0x794bbfd8 + 0x67ee9374 + ebx35 - 0x67ee9374 + 0x794bbfd8 + 0x77eec400;
        esi36->f4 = esi36->f4 - 0x77eec400;
        asm("rol ebx, 0x1");
        ++esi36;
        ebx35 = ebx35;
    }
    *(int8_t*)(ebp32 + 0x187be0b0) = 0;
    goto v39;
}

[Geovane]

Entonces, estáticamente, no puedo hacer nada.
Disculpe.
Buena suerte
Saludos

[apuromafo CLS]

los parches se deben hacer de forma dinámica, por otro lado muchas veces se relaciona con apis de integridad, quizas no es themida este tutorial pero te ayudará a quitarte la duda

puedes usar google traductor si no entiendes alguna palabra

Patching the Winlicense 2.0.5.0 Checksum.
by quosego/snd
------------------------------------------

Intro;
In this tut I'll try to explain how Winlicense checks if the app has been
tampered with and how to patch it.

The checking;
Winlicense his anti patching procedure only holds an simple checksum check, it 
uses imagehlp.CheckSumMappedFile to compute this checksum and then compares it
to the one stored by Winlicense and if it isn't the same it fails.

To be exactly it does the following,
-Alloc an memorybuffer to store itself from disk.
-Store the PE in this memorybuffer.
-Use GetProcaddress to obtain CheckSumMappedFile.
-Use CheckSumMappedFile to compute a checksum.
-Use some logical instructions to modify the checksum.
-Compare the checksum to the one stored at the end of the file.
-If it passes proceed, if it fails give an error.

Analysis;
If you'd breakpoint GetProcaddress and wait for quite some while sooner or later
WL will obtain the CheckSumMappedFile location. If you'd then bp this api and
return to WL code you'll end up somwhere similar to here;
(If the app is using cisc VM, risc VM has a different VM entry.)

0112A5AF           68 2C31AA09        PUSH 9AA312C
0112A5B4         ^ E9 3B7BF9FF        JMP 010C20F4

This'll of course leads you to nowhere since it's VM and studying it obfuud is
greatly annoying. However if you look at the stack and scroll up four dwords
you'll see the following;

(these are simply the arguments pushed into CheckSumMappedFile)
(http://msdn.microsoft.com/en-us/library/ms679281(VS.85).aspx)

0007FF6C              012A0000
0007FF70              000B41FC
0007FF74              0112A4D0   cisc_+_f.0112A4D0
0007FF78              0112A4D4   cisc_+_f.0112A4D4

and their meaning;

PIMAGE_NT_HEADERS CheckSumMappedFile(
  __in   PVOID BaseAddress,
  __in   DWORD FileLength,
  __out  PDWORD HeaderSum,
  __out  PDWORD CheckSum
);

The checksum is the most important (located at 0112A4D4). If you'd check out
that dword you'll find the checksum. You can, if you've patched WL, feed it here
the correct checksum. But that would include hooking the WL decrypting routines
or GetProcAddress or similar. There are easier methods.

WL does not directly compare the CheckSumMappedFile generated checksum with a
checksum it has stored, instead it does some computations before comparing the
checksum.

In my case it did the following computations, extracted from the Cisc Virtual
Machine.

ROL {checksum}, {last byte checksum}
;ROL 000B6D92,92                  = B648002D
XOR B648002D,2AC8914C               = 9C809161
ADD 9C809161,87C05B78               = 2440ECD9
XOR 2440ECD9,6D10B8E2               = 4950543B

In this case 4950543B is considered the final calculated checksum. If you now set
a memory breakpoint on access on the BaseAddress of the mapped PE (see the
CheckSumMappedFile structure) in the memory map. You'll see the VM accessing the
very last dword in the mapped file. This will if the executable is unmodified be
the same as the calculated checksum. WL will next do a compare and fail or proceed.

Patching the checksum;
So if you've modified your WL protected app you must update the checksum located in
a dword at the end of the file, however as I stated all calculations of this
checksum are done within the VM and it would be tedious to extract them everytime.

However WL stores the calculated checksum in the VM registers before comparing it
with the stored one. So to find it easily you can do the following;

- When you've returned from CheckSumMappedFile API memory bp the BaseAddress on
  access in the memory map. Press shift-f9. (It now has obtained the last dword of
  the mapped PE.)
- Follow edi in dump and look for the first dword that appears two times, this is
  the calculated checksum. In cisc VM's it should be [edi+4] and [edi+8], in risc
  VM's it should be further down with some empty dwords between it.
- Copy the calculated checksum to the end of the file (search for the old one or
  just scroll down). It'll now run again with it's new checksum.

Have fun,
q.

------------------------------------------

[josue9243]

Entonces, estáticamente, no puedo hacer nada.
Disculpe.
Buena suerte
Saludos

No se para que pedis el código si al final nunca podes hacer nada...........

los parches se deben hacer de forma dinámica, por otro lado muchas veces se relaciona con apis de integridad, quizas no es themida este tutorial pero te ayudará a quitarte la duda

puedes usar google traductor si no entiendes alguna palabra

Tenkiu, pero al final era sólo retornar el EAX a 1, si retorna 0 es que no es valido.

Al final puse un hwbp al inicio de la funcion y al final, entonces compare el no valido con valido y bingo.

MOD: No hacer doble post. Usa el botón modificar. (Esta no es la 1era vez.)