Z perspektywy czasu jednym z błędów, które zrobiłem tworząc kurs asemblera na YouTube parę lat temu było wprowadzenie mechanizmu ASLR (a raczej: zdanie się na istniejący mechanizm ASLR w mmap/VirtualAlloc) przy wyborze adresu, pod który ma zostać załadowany kod maszynowy do uruchomienia. O ile sam mechanizm dobrze obrazuje realia współczesnych systemów operacyjnych, o tyle triki, które trzeba używać przy adresowaniu relatywnym w x86-32 wprowadzają trochę niepotrzebnego zamieszania dla osób początkujących. Lepszym rozwiązaniem byłoby zaczęcie od jednego, zdefiniowanego adresu gdzie zostanie załadowany program i korzystanie z adresowania bezwzględnego, i wprowadzenie ASLR w połowie/pod koniec serii. Niemniej jednak wyszło jak wyszło, więc od czasu do czasu pojawiają się pytanie o to, dlaczego nie można w łatwy sposób zaadresować fragmentów kodu lub danych korzystając z asmloadera. Poniższy post jest de facto fragmentem odpowiedzi na jedno z takich pytań, której udzieliłem chwilę temu w komentarzach na YT, ale po namyśle zdecydowałem, że może zainteresuje ona więcej osób (a przynajmniej będę miał do czego linkować w przyszłości).

Komentarz na YT autorstwa Kapa PL, zacytowany w całości (istotne z uwagi na przykładowy kod):

Nie rozumiem dlaczego tak nie może być :/ ET to nie jest adres danej linijki kodu ?

[bits 32]
push ET
call [ebx+3*4];printf
add esp,4
push 0
call [ebx];exit

ET:db 'Hello World',0xa,0
Odpowiedź:
Sprowadza się to do dość ciekawej rzeczy, którą jest ASLR (Address Space Layout Randomization), który jest używany w pewnej formie w asmloaderze. Konkretniej, ET jest adresem linijki kodu, który w momencie kompilacji jest znany assemblerowi, tj. który jest liczony od podanego (za pomocą dyrektywy [org TUADRES]) lub domyślnego (0) adresu początku kodu.
Natomiast, jeśli program będzie załadowany w losowe miejsce w pamięci (a nie w dokładnie to samo, które założył assembler w momencie kompilacji), to adresy bezwzględne (takie jak ET) będą niepoprawne.

Przykładowo, ET w Twoim przypadku jest pod adresem 0xF, co można odczytać np. disasemblując program (via IDA):

00000000                 push    0Fh
00000005                 call    dword ptr [ebx+0Ch]
00000008                 add     esp, 4
0000000B                 push    0
0000000D                 call    dword ptr [ebx]
0000000F aHelloWorld     db 'Hello World',0Ah,0
Jak widać, push ET został przez assembler zmieniony na bezwzględną wersję, tj. push 0Fh (gdzie 0Fh to wspomniany adres ET ustalony w momencie kompilacji).

W momencie załadowania programu przez asmloader program jednak nie będzie załadowany pod adres 0, tylko pod adres wybrany przez system operacyjny w momencie realizowania żądania alokacji pamięci (który, w uproszczeniu, można traktować tożsamo z mechanizmem ASLR). Informacja o tym gdzie program jest ładowany pojawia się w drugiej linii outputu asmloader, np.:

gynvael:haven-windows> asmloader aaa
Simplified Assembly Loader v.0.0.2 by gynvael.coldwind//vx
Code loaded at 0x001c0100 (28 bytes)
W tym wypadku kod trafił pod adres 0x001c0100, a więc poprawnym adresem stringu "Hello World\n" będzie 0x1c010f a nie 0xf:

(hexdump pamięci)
001c0108 83 c4 04 6a 00 ff 13 48 65 6c 6c 6f 20 57 6f 72 6c 64 0a 00 cc  ...j...Hello World...
...

(zrzut disassemblera)
001c0100 680f000000      push    0Fh
001c0105 ff530c          call    dword ptr [ebx+0Ch]
001c0108 83c404          add     esp,4
001c010b 6a00            push    0
001c010d ff13            call    dword ptr [ebx]
001c010f 48              dec     eax  (48, czyli litera 'H' z 'Hello World')
...
Co istotne, adres ten będzie za każdym uruchomieniem inny (tak działa ASLR).

Więc w tym wypadku, tj. w sytuacji w której stosowany jest ASLR (lub podobny mechanizm sprawiający, że nie znamy docelowego adresu gdzie kod znajdzie się w pamięci), nie możemy korzystać z bezwzględnych adresów.

Trik z call którego używam jest jednym z rozwiązań tego problemu. Można by go rozwiązać na jeszcze kilka innych sposobów, np. stosując relatywne adresowanie względem jakiegoś rejestru, w którym jest adres początku kodu (co jest trochę lepszym rozwiązaniem), np.:

[bits 32]
call addr
addr:
pop ebp        ; w ebp jest adres addr
sub ebp, addr  ; zakladajac org 0, przesuwam ebp
              ; na poczatek kodu programu

; od teraz mozna uzywac ebp+ETYKIETA do adresowania
; relatywnego

lea eax, [ebp+ET]  ; tozsame z eax = ebp + ET
push eax

call [ebx+3*4];printf
add esp,4
push 0
call [ebx];exit

ET:db 'Hello World',0xa,0

Oczywiście gdybyśmy znali adres gdzie będzie załadowany nasz kod, to można by go podać w dyrektywie [org TUADRES] i nie bawić się w relatywne adresowanie, tylko korzystać z adresów bezwzględnych. W przypadku asmloadera niestety nie ma takiej opcji (choć z perspektywy czasu powinienem od tego zacząć w kursach).

I tyle :)

P.S. Od jakiegoś czasu bawię się pomysłem częstszego publikowania na blogu moich odpowiedzi z forów/mejli/komentarzy/etc - sporo pytań się powtarza, więc być może niektóre odpowiedzi by zainteresowały większe grono osób. Ma ktoś jakiś pomysł jak można by oznaczać takie posty? Myślałem o "FAQ:" albo "Q&A:", choć one nie do końca odpowiadają znaczeniowo tego typu postom.