[asm] EAT func adressen laden

[Tyrar]

ich hab da einen kleinen denk fehler, ich versuche folgenden code in asm um zu coden

 Spoiler

    HMODULE kernel32base = *(HMODULE*)(*(DWORD*)(*(DWORD*)(*(DWORD*)(*(DWORD*)(__readfsdword(0x30) + 0x0C) + 0x14))) + 0x10);

    DWORD base = (DWORD)kernel32base;
    IMAGE_NT_HEADERS* pe = PIMAGE_NT_HEADERS(base + PIMAGE_DOS_HEADER(base)->e_lfanew);
    IMAGE_EXPORT_DIRECTORY* exportDir = PIMAGE_EXPORT_DIRECTORY(base + pe->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
    DWORD* namePtr = (DWORD*)(base + exportDir->AddressOfNames);
    WORD* ordPtr = (WORD*)(base + exportDir->AddressOfNameOrdinals);
    for(; strcmp((const char*)(base + *namePtr), "GetProcAddress"); ++namePtr, ++ordPtr)
        ;
    DWORD funcRVA = *(DWORD*)(base + exportDir->AddressOfFunctions + *ordPtr * 4);

    typedef FARPROC (WINAPI *GetProcAddress_t)(HMODULE, const char*);
    GetProcAddress_t GetProcAddress = (GetProcAddress_t)(base + funcRVA);

mein bisheriges ergebnis

 Spoiler

mov edx, DWORD [eax+0x3C] ; pe header
add edx, eax
mov edx, DWORD [edx+0x78] ; eat
add edx, eax
mov DWORD [ddKernel32EAT], edx

mov ebx, DWORD [edx+0x20] ; address of names
mov ecx, DWORD [edx+0x24] ; address of name ordinals
add ebx, eax
add ecx, eax

.K32Import_Loop:
push ebx
push ecx
push sGetProcAddress
mov eax, DWORD [ebx]
add eax, DWORD [ddKernel32]
push eax
call strcmp
pop ecx
pop ebx
test eax, eax
je .K32Import_LoopEnd
add ebx, 4
add ecx, 2
jmp .K32Import_Loop

.K32Import_LoopEnd:
mov eax, DWORD [ddKernel32] ; <----
mov edx, DWORD [ddKernel32EAT]
add eax, DWORD [edx+0x28] ; address of functions
add ax, WORD [ecx]
xor edx, edx
mov dl, 4
mul edx
add eax, DWORD [ddKernel32]
mov DWORD [ddGetProcAddress], eax ; <---

allerdings habe ich ein problem mit dieser zeile:

DWORD funcRVA = *(DWORD*)(base + exportDir->AddressOfFunctions + *ordPtr * 4);

der asm ausschnitt ist mit '<---' gekennzeichnet.

jemand ne idee woran es liegen könnte?

fehler beispiel:
Kernel32 image base: 76E30000
Kernel32 EAT: 76EEF6A0
funcRVA befindet sich angeblich an: DBBBE438

[link]

Du solltest Strukturen benutzen, AddressOfFunctions hat nämlich ein Offset von 1Ch.
Mit direkten Offsets zu arbeiten ist sehr unleserlich und so gut wie gar nicht wartbar.
Außerdem braucht man kein mul, da man einfach das SIB-Byte für die Adressierung benutzen kann (sprich mov eax,[eax+ebx*4+55h]).
Und wenn du einen kleineren Teil eines Registers veränderst und im größeren dann das Ergebnis erwartest, musst du das Carry-Flag berücksichtigen.

mov eax, DWORD [ddKernel32] ; <----
mov edx, DWORD [ddKernel32EAT]
add eax, DWORD [edx+0x28] ; address of functions
add ax, WORD [ecx]
xor edx, edx
mov dl, 4
mul edx
add eax, DWORD [ddKernel32]
mov DWORD [ddGetProcAddress], eax ; <---

->

mov eax, DWORD [ddKernel32] ; <----
mov edx, DWORD [ddKernel32EAT]
add eax, DWORD [edx+0x1C] ; address of functions
movzx edx,word [ecx]
mov eax,[eax+edx*4]
add eax, DWORD [ddKernel32]
mov DWORD [ddGetProcAddress], eax ; <---

Btw. ich würde statt der Variablen noch esi, edi und ebp hinzuziehen

[Tyrar]

Originally Posted by link

Und wenn du einen kleineren Teil eines Registers veränderst und im größeren dann das Ergebnis erwartest, musst du das Carry-Flag berücksichtigen.

war mir bisher ehrlich gesagt gar nicht bewusst

Originally Posted by link

mov eax,[eax+ebx*4+55h]

natürlich self-

die register sind in diesem code allerdings mit absicht nicht verwendet worden

ty

[link]

Wenn deine Adresse z.B. 76EEF6A0h und der Wert an [ecx], den du auf ax addierst, gleich B00h ist, dann steht in eax 76EE01A0h statt 76EF01A0h.
Dafür gibt es eigentlich add with carry, aber da der höherwertige 16-byte Part der Register nicht ansprechbar ist, müsste man mit adc einen Umweg gehen oder z.B. jc mit add eax,10000h hinzufügen, deswegen ist es einfacher, wenn du direkt movzx benutzt, sodass du den Wert auf 4-Bytes vergrößerst und ihn auf das komplette eax-Register addierst.
Das mit den Variablen sieht halt eher unschön aus, außerdem sind Speicherzugriffe ziemlich langsam.

[Tyrar]

Wenn deine Adresse z.B. 76EEF6A0h und der Wert an [ecx], den du auf ax addierst, gleich B00h ist, dann steht in eax 76EE01A0h statt 76EF01A0h.
Dafür gibt es eigentlich add with carry, aber da der höherwertige 16-byte Part der Register nicht ansprechbar ist, müsste man mit adc einen Umweg gehen oder z.B. jc mit add eax,10000h hinzufügen, deswegen ist es einfacher, wenn du direkt movzx benutzt, sodass du den Wert auf 4-Bytes vergrößerst und ihn auf das komplette eax-Register addierst.

das ergibt natürlich sinn, hätte ich allerdings nicht dran gedacht

Originally Posted by link

Das mit den Variablen sieht halt eher unschön aus, außerdem sind Speicherzugriffe ziemlich langsam.

da die func nur ein einziges mal zum start gecalled wird, macht das nichts... grundsätzlich setze ich auch auf register (natürlich wenn möglich ohne lokale variablen)