Jak fungují DTA soubory Mafie

void Decrypt(void* Buffer, DWORD BufferSize, DWORD Key1, DWORD Key2)
// DWORD = 32-bitové celé číslo (4 bajty), hodnota 0 až ~4,3 miliardy
{
    __asm
    {
        mov    ecx, BufferSize        ; délka dat do registru ECX
        push   esi                    ; uložit registry (konvence volání)
        mov    eax, ecx
        push   edi
        shr    eax, 3                 ; vydělit 8 → počet celých 8-bajtových bloků
        lea    esi, ds:0[eax*8]       ; velikost zarovnaná na 8 bajtů
        sub    ecx, esi               ; zbytek po zarovnání (0–7 bajtů)
        mov    edx, ecx               ; uložit zbytek
        mov    ecx, Buffer            ; ukazatel na data
        test   eax, eax
        jz     short loc_0_100046F5  ; žádné celé bloky → přejít na zbytek
        mov    edi, Key1              ; první klíč do EDI
        push   Key2                   ; druhý klíč na zásobník
        push   ebx
        push   ebp
    loc_0_100046B4:                   ; --- smyčka přes 8-bajtové bloky ---
        mov    ebx, [ecx+eax*8-8]    ; načíst první 4 bajty bloku
        mov    ebp, [ecx+eax*8-4]    ; načíst druhé 4 bajty bloku
        dec    eax
        not    ebx                    ; NOT: překlopit všechny bity
        not    ebp
        mov    [ecx+eax*8], ebx
        mov    ebx, [esp + 8h]        ; druhý klíč ze zásobníku
        mov    [ecx+eax*8+4], ebp
        mov    ebp, [ecx+eax*8]
        xor    ebp, ebx               ; XOR s druhým klíčem
        mov    ebx, [ecx+eax*8+4]
        xor    ebx, edi               ; XOR s prvním klíčem
        mov    [ecx+eax*8], ebp
        mov    [ecx+eax*8+4], ebx
        mov    ebx, ebp
        mov    ebp, [ecx+eax*8+4]
        not    ebx                    ; druhý průchod NOT
        not    ebp
        test   eax, eax
        mov    [ecx+eax*8], ebx
        mov    [ecx+eax*8+4], ebp
        jnz    short loc_0_100046B4  ; opakovat dokud jsou bloky
        pop    ebp
        pop    ebx
    loc_0_100046F5:                   ; --- zbytek (méně než 8 bajtů) ---
        add    ecx, esi
        test   edx, edx
        jz     short loc_0_1000471A  ; žádný zbytek → konec
        lea    esi, Key2
        lea    eax, [ecx+edx]
        sub    esi, ecx
        mov    edi, edx
    loc_0_10004706:
        mov    cl, [eax-1]            ; bajt po bajtu
        dec    eax
        not    cl                     ; NOT na jeden bajt
        mov    [eax], cl
        mov    dl, [esi+eax]
        xor    dl, cl                 ; XOR s klíčem
        dec    edi
        not    dl                     ; druhý NOT
        mov    [eax], dl
        jnz    short loc_0_10004706
    loc_0_1000471A:
        pop    edi
        pop    edi
        pop    esi
    }
}

DWORD Result;  // DWORD = 32-bitové číslo, zde slouží jako pointer (adresa v paměti)

if (Result = dtaCreate("a9.dta"))  // připoj archiv; Result = adresa interní tabulky
{
    __asm  // inline assembler — přímé instrukce procesoru
    {
        mov eax, 06FEE6324h     ; první klíč (pro A9.dta) do registru EAX
        xor eax, 034985762h     ; zamaskuj ho XOR operací (pevná hodnota pro všechny DTA)
        push eax                ; ulož připravený klíč na zásobník

        mov eax, 0ACDA4783h     ; druhý klíč (pro A9.dta) do EAX
        xor eax, 039475694h     ; zamaskuj druhým pevným XOR faktorem
        push eax                ; ulož druhý klíč na zásobník

        mov ecx, Result         ; do ECX dej pointer vrácený z dtaCreate()
        mov eax, [ecx]          ; přečti adresu tabulky funkcí z tohoto pointeru
        call [eax + 0ch]        ; zavolej čtvrtou funkci v tabulce (+0x0C = offset 12)
                                ; → ta interně nastaví klíče pro dešifrování archivu
    }
}