Czasem przyjemnie jest zapomnieć o Undefined Behavior w C i po prostu napisać coś co działa tu i teraz, a niekoniecznie będzie działać jutro (przy nowej wersji kompilatora; innych opcjach kompilacji) lub w innym miejscu (innej platformie). Kilka tygodni temu nadarzyła się ku temu okazja za sprawą tematu na pewnym forum zatytułowanym "Hello world bez bibliotek i asm" (stąd nazwa niniejszego postu) - autor pytał czy możliwym jest napisać w C "Hello World" bez użycia bibliotek (w tym include'ów) ani wstawek assembly (w dowolnej formie). O ile na początku topic był powiązany jeszcze z poprawnym językiem C, to dość szybko przeszło na kod bardzo niskopoziomowy (zapisany nadal w C), zależny od danego systemu, architektury CPU czy nawet sposobu kompilacji użytego przez kompilator. Poniżej zamieszczam mój pomysł na wypisanie "Hello World" na konsoli GNU/Linux, natomiast zachęcam również do rzucenia okiem na sam topic (link powyżej).

Poniższy post został pierwotnie opublikowany na forum 4programmers.net w temacie "Hello world bez bibliotek i asm" (link).

--post start--
Kawałek kodu i ode mnie - bardziej ofc chodziło mi o zilustrowanie metody niż o zawsze-działający-kod :)

Kod napisany jest pod linuxa (32-bity x86), natomiast tą samą metodę można użyć na 64-bity oraz na Windowsa 32- / 64-bity.
Kod nie korzysta z żadnych bibliotek (nawet nie szuka żadnych w pamięci), ani nie ma żadnych wstawek asma/innych (przynajmniej jawnie ;>).
Wyjaśnienie zasady działania pod kodem.

volatile unsigned int something_wicked_this_way_comes(
   int a, int b, int c, int d) {
 a ^= 0xC3CA8900;  b ^= 0xC3CB8900;  c ^= 0xC3CE8900;  d ^= 0x80CDF089;
 return a+b+c+d;
}

void* find_the_witch(unsigned short witch) {
 unsigned char *p = (unsigned char*)something_wicked_this_way_comes;
 int i;
 for(i = 0; i < 50; i++, p++) {
   if(*(unsigned short*)p == witch) return (void*)p;
 }

 return (void*)0;
}

typedef void (*gadget)() __attribute__((fastcall));

int main(void) {
 gadget eax_from_esi_call_int = (gadget)find_the_witch(0xF089);
 gadget set_esi = (gadget)find_the_witch(0xCE89);
 gadget set_ebx = (gadget)find_the_witch(0xCB89);
 gadget set_edx = (gadget)find_the_witch(0xCA89);

 if(!eax_from_esi_call_int) return 1;
 if(!set_esi) return 3;
 if(!set_ebx) return 4;
 if(!set_edx) return 5;

 set_edx(12), set_ebx(1), set_esi(4);
 eax_from_esi_call_int("Hello World\n");

 return 0;
}

Kod korzysta z metody bardzo podobnej do metody exploitacji języków JITowanych przy zabezpieczonej pamięci via XD/NX/XN/DEP/etc - tj. niejawnie starałem się w pamięć wykonywalną wrzucić kilka "gadżetów" (w rozumieniu ret2libc aka return oriented programing - http://gynvael.coldwind.pl/?id=144) i następnie je użyć do zrobienia syscalla do systemu (tak więc żadne biblioteki nie są potrzebne, natomiast oczywiście zachodzi bezpośrednia interakcja z kernelem).

Owe gadzety są [umieszczone] w funkcji something_wicked_with_way_comes, a konkretniej są to stałe przy xor'ach:

a ^= 0xC3CA8900;  b ^= 0xC3CB8900;  c ^= 0xC3CE8900;  d ^= 0x80CDF089;
Powyższy kod w assemblerze / kodzie maszynowym zostanie zapisany następująco:

[...]
  6:        35 00 89 ca c3               xor    eax,0xc3ca8900
  b:        89 45 08                     mov    DWORD PTR [ebp+0x8],eax
  e:        8b 45 0c                     mov    eax,DWORD PTR [ebp+0xc]
 11:        35 00 89 cb c3               xor    eax,0xc3cb8900
 16:        89 45 0c                     mov    DWORD PTR [ebp+0xc],eax
 19:        8b 45 10                     mov    eax,DWORD PTR [ebp+0x10]
 1c:        35 00 89 ce c3               xor    eax,0xc3ce8900
 21:        89 45 10                     mov    DWORD PTR [ebp+0x10],eax
 24:        8b 45 14                     mov    eax,DWORD PTR [ebp+0x14]
 27:        35 89 f0 cd 80               xor    eax,0x80cdf089
[...]
Czyli gdyby disassemblować "źle", czyli z przesunięciem o jeden/dwa bajty, to dostanie się trochę inny kod:

 6: 35 00 89 ca c3 → mov edx, ecx ; ret
11: 35 00 89 cb c3 → mov ebx, ecx ; ret
1c: 35 00 89 ce c3 → mov esi, ecx ; ret
27: 35 89 f0 cd 80 → mov eax, esi ; int 0x80
Tak więc dzięki temu jestem pewien, że w pamięci wykonywalnej są potrzebne mi gadgety. [Oczywiście, gdyby kompilator wygenerował inny kod, to tych opkodów w pamięci w cale by nie musiało być; natomiast w tym konkretnym wypadku bazując na powyższym listingu można stwierdzić, że opkody w pamięci jednak są; dop. własny]
Idąc dalej, używam funkcji find_the_witch do ich znalezienia w kodzie maszynowym funkcji something_wicked_this_way_comes [parametr funkcji find_the_witch to pierwsze dwa bajty szukanego gadżetu jako uint16_t, czyli little endian; dop. własny]:

 gadget eax_from_esi_call_int = (gadget)find_the_witch(0xF089);
 gadget set_esi = (gadget)find_the_witch(0xCE89);
 gadget set_ebx = (gadget)find_the_witch(0xCB89);
 gadget set_edx = (gadget)find_the_witch(0xCA89);
I teraz jeszcze jedna istotna sprawa - typ gadget to:

typedef void (*gadget)() attribute((fastcall));
Są tu dwie istotne rzeczy:
1. W C argumenty () oznaczają "dowolne nieokreślone argumenty" (w przeciwieństwie do C++ gdzie to jest tożsame z (void) aka brak argumentów).
2. Ustawiona jest konwencja wywołania na fastcall, czyli parametry funkcji polecą do rejestrów zamiast na stos (a konkretniej, pierwszy argument poleci do rejestru ecx w tym konkretnym przypadku).

Dalej po prostu "składam" zwykły asmowy hello world za pomocą tych gadgetów:
 set_edx(12), set_ebx(1), set_esi(4);
 eax_from_esi_call_int("Hello World\n");
Co runtime będzie wykonane jako:


(main)   mov ecx, 12
         mov eax, set_edx
         call eax
(gadżet) mov edx, ecx
         ret
(main)   ...
...      ...
(gadżet) ...
         int 0x80
Pomijając części z main:

[gadzet 1] mov edx, 12 (długość napisu)
[gadzet 2] mov ebx, 1 (stdout)
[gadzet 3] mov esi, 4 (sys_write)
[fastcall to załatwi] mov ecx, address "Hello World\n"
[gadzet 4] mov eax, esi
[gadzet 4] int 0x80
Oczywiście w tej postaci po wypisaniu hello world program się "wywali", natomiast można go dość łatwo przerobić na taki który się mimo wszystko nie "wywala" :)

Test:

$ gcc -m32 test.c -O0
$ ./a.out
Hello World
Segmentation fault (core dumped)
$
--post stop--

Jeśli chodzi o problem niezbyt łagodnego wyjścia, to bardzo fajne rozwiązanie podał Azarien w kolejnym poście - mianowicie utworzył on jeszcze jedną funkcję nazwaną graceful_exit, która za pomocą istniejących gadgetów wywoływała syscall exit, a następnie dodał jej wywołanie przed return w funkcji something_wicked_this_way_comes, ale bezpośrednio za d ^= 0x80CDF089; - czyli po wykonaniu gadzętu 89 F0 CD 80 (przypominam: nie ma tu C3 czyli instrukcji ret) CPU "poleci dalej", a dalej jest wywołanie funkcji graceful_exit.

Fragment kodu o którym mowa wyżej (zmiany Azarien'a są pogrubione; dodam, że była jeszcze jedna zmiana - przerzucenie struktury gadget wyżej w kodzie, ale ją pominę dla przejrzystości):

void graceful_exit()
{
 set_ebx(0);
 set_esi(1);
 eax_from_esi_call_int(0);
}

volatile unsigned int something_wicked_this_way_comes(
   int a, int b, int c, int d) {
 a ^= 0xC3CA8900;  b ^= 0xC3CB8900;  c ^= 0xC3CE8900;  d ^= 0x80CDF089;
 graceful_exit();
 return a+b+c+d;
}
Bardzo eleganckie rozwiązanie moim zdaniem :)

Warto również rzucić okiem na post MSM'a oraz dyskusję w komentarzach do niego - metoda MSM'a opiera się znaną technikę z poszukaniem adresu biblioteki kernel32 w liście załadowanych bibliotek w PEB, znalezienie GetProcAddress w tablicy importów i załadowanie potrzebnych funkcji do wyświetlenia "Hello World" (chociaż nie do końca jest to metoda zgodna z "bez bibliotek", niemniej jednak warto rzucić okiem).

I tyle.