Grsecurity, Pax, Libsafe

[Gość amdfanatyk]

grsecurity i libsafe - z czym to sie je?

 

wstep:

wsrod uzytkownikow nie posiadajacych doswiadczenia w kwestii zabezpieczania systemu panuje opinia, iz firewall stanowi swietna ochrone przed, jak to ladnie mawiaja "specjalisci" z firmy M, "hakerami"; w istocie jesli nie mamy u siebie serwera, poprawnie skonfigurowany firewall moze uczynic nasz komputer "niewidzialnym" (stealth) w sieci (brak odpowiedzi na zadanie echa, wszystkie porty zamkniete, brak raportowania stanu portow); schody zaczynaja sie jednak, gdy chcemy u siebie zrobic serwer; taka maszyna nie tylko musi odpowiadac na zadanie echa ale musi ona takze posiadac przynajmniej jeden otwarty port; otwarty, czyli taki, na ktorym np. demon ftp prowadzi nasluch; samo zbindowanie przez program portu nie oznacza jeszcze, ze usluga bedzie juz dostepna z zewnatrz - jesli netfiltr nie wpuszcza na bindowany port pakietow (-j DROP lub REJECT), nikomu nie uda sie polaczyc z demonem; musimy zatem utworzyc regule, ktora bedzie wpuszczac pakiety (-j ACCEPT) tak, by dotarly one do demona; tutaj konczy sie nasze "bezpieczenstwo", stajemy sie jawnie podatni na wlam; od tego momentu firewall nie decyduje juz praktycznie w ogole o naszym bezpieczenstwie; oczywiscie mozna dzieki niemu, w mniejszym lub wiekszym stopniu, zabezpieczyc sie przed pewnymi typami atakow, jednak ja zajme sie opisaniem metod zapobiegania skutkom atakow majacych na celu penetracje zasobow systemu, docelowo - uzyskanie praw jego administratora.

 

emaksem przez sendmejl, czyli jak oni to robia:

typowy atak polega najczesciej na "wstrzyknieciu" w dzialajacy juz program tzw. shellcode'u, czyli kodu wygenerowanego w wyniku kompilacji programu napisanego w asemblerze a majacego najczesciej na celu uruchomienie interpretera polecen powloki; w praktyce wyglada to tak, ze nadpisuje sie adres powrotu z funkcji, takim, ktory wskazuje na obszar pamieci, w ktorym znajduje sie podstawiony "obcy" kod; efektem wykonania "wstrzyknietego" kodu jest uruchomienie np. /bin/sh; po odkryciu bledu w aplikacji pisze sie tzw. exploita, czyli program, ktory znaleziona dziure wykorzysta; pol biedy jesli wyexploitowany program dziala z prawami zwyklego usera, gorzej gdy jest to program uruchomiony z prawami (_root'a_ → roota) ORT (!) lub ktorego wlascicielem jest root a program ma ustawiony SUID i uruchomil go zwykly user; wtedy wlamywacz od razu uzyskuje uprawnienia administratora i moze zrobic wszystko, na co ma ochote.

 

grsecurity:

domyslnie obszar pamieci oznaczony jako do odczytu/zapisu jest takze wykonalny, czyli jesli np. w wyniku ataku buffer overflow podstawimy kod w taki obszar pamieci, to zostanie on wykonany - exploit zadziala; z pomoca przychodzi nam lata na kernel grsecurity a konkretnie stanowiacy jej integralna czesc PaX; implementuje ona m.in. niewykonywalny stos/sterte dzieki temu skutecznie zapobiega wykonaniu "wstrzyknietego" przez intruza kodu;

 

1. late pobieramy ze strony projektu grsecurity

2. jesli jest taka potrzeba, to pobieramy pelne zrodlo najnowszego kernela np. linux-2.6.13.tar.bz2

3. pobieramy late na kernel, tak by update'owac go do obslugiwanej wersji np. patch-2.6.13.4.bz2 dla grsec 2.1.7

4. paczujemy: bzip2 -dc patch-2.6.13.4.bz2 | patch -p1 && gzip -dc grsecurity-2.1.7-dokladnawersja.gz | patch -p1

5. wykonujemy make xconfig lub make menuconfig

6. w sekcji "Security" pojawily sie nowe podkategorie: "Grsecurity" i "PaX"

 

 

7. konfigurujemy ...

8. $ make

9. # make modules_install && make install

 

przy konfigurowaniu grsec zalecam wybranie domyslnego poziomu "Low" co zablokuje podstawowe funcje ochronne jako wlaczone i powlaczanie kolejnych opcji zgodnie z uznaniem - nalezy pamietac, ze zle skonfigurowane grsec moze m.in. uniemozliwic wlaczenie srodowiska graficznego Xorg; nie bede tutaj opisywac kazdej funkcji poniewaz nie zamierzam kopiowac opisow znajdujacych sie w sieci;

 

 

jesli chodzi o opcje PaX, to nalezy wybrac jeden ze sposobow markowania binariow; po skompilowaniu jadra chronione beda tylko aplikacje wskazane explicite przy uzyciu narzedzia paxctl (ew. chpax); pliki markuje sie konkretnymi atrybutami; obowiazkowo markujemy wszyskie pliki z ustawionym SUID - mozna je wyszukac wpisujac `find / -perm +4000 -print`; np. `/sbin/paxctl -PMRXS /bin/ping`; -M wywali Xorg wiec piszemy wtedy -PmRXS; oprocz plikow suid'owych markujemy takze wszystkie binaria, ktore prowadza nasluch na portach, np.: kadu, amule, vsftpd.

 

wlaczanie PaX'a

 

wybor sposobow markowania

 

najwazniejsze funkcje PaX'a

 

dodatowe "bajery"

 

libsafe:

libsafe dzieki preloadzie niejako przeslania "niebezpieczne" funkcje z libc ich "bezpiecznymi" wariantami i jest w stanie w wiekszosci przypadkow wykryc probe naduzycia, chroni zatem (przynajmniej w teorii) przed wiekszoscia atakow typu buffer overflow i format string; "bezpieczna biblioteka" nie jest w stanie chronic binariow statycznie zlinkowanych z biblioteka libc; instalacja biblioteki jest bardzo prosta; po pobraniu i rozpakowaniu libsafe wydajemy polecenia:

 

1. $ make

2. # make install

 

zakonczenie:

hybryda grsecurity+libsafe stanowi niezle zabezpieczenie systemu; chociaz nigdy nie mozemy czuc sie w 100% bezpieczni, to mamy dzieki niej znacznie wiekszy poziom bezpieczenstwa niz ten, prezentowany przez system zaraz po jego zainstalowaniu; na sam koniec zamieszczam wyniki dzialania exploitow dostarczonych z libsafe (w systemie dziala PaX i libsafe):

 

[user@localhost exploits]$ ./t1
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1.
   uid=500  euid=500  pid=18893
Call stack:
   0x51251973  /lib/libsafe.so.2.0.16
   0x51251ab6  /lib/libsafe.so.2.0.16
   0x804858b   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1
   0x80485b1   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1
   0x51119de1  /lib/libc-2.3.5.so
Overflow caused by strcpy()
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t1w
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1w.
   uid=500  euid=500  pid=19328
Call stack:
   0x55637973  /lib/libsafe.so.2.0.16
   0x55637ccd  /lib/libsafe.so.2.0.16
   0x804858d   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1w
   0x80485b3   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t1w
   0x554ffde1  /lib/libc-2.3.5.so
Overflow caused by wcscpy()
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t3
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3.
   uid=500  euid=500  pid=7679
Call stack:
   0x5661a973  /lib/libsafe.so.2.0.16
   0x5661aab6  /lib/libsafe.so.2.0.16
   0x80485be   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3
   0x80486bc   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3
   0x564e2de1  /lib/libc-2.3.5.so
Overflow caused by strcpy()
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t3w
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3w.
   uid=500  euid=500  pid=25982
Call stack:
   0x54701973  /lib/libsafe.so.2.0.16
   0x54701ab6  /lib/libsafe.so.2.0.16
   0x80485f2   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3w
   0x8048705   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t3w
   0x545c9de1  /lib/libc-2.3.5.so
Overflow caused by strcpy()
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t4
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4.
   uid=500  euid=500  pid=23167
Call stack:
   0x56e2a973  /lib/libsafe.so.2.0.16
   0x56e2aab6  /lib/libsafe.so.2.0.16
   0x80485ee   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4
   0x804868a   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4
   0x56cf2de1  /lib/libc-2.3.5.so
Overflow caused by strcpy()
parent process terminating
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t4w
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4w.
   uid=500  euid=500  pid=4405
Call stack:
   0x50f43973  /lib/libsafe.so.2.0.16
   0x50f43ab6  /lib/libsafe.so.2.0.16
   0x8048626   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4w
   0x80486d7   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t4w
   0x50e0bde1  /lib/libc-2.3.5.so
Overflow caused by strcpy()
parent process terminating
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t5
This program tries to use strcat() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Libsafe version 2.0.16
Detected an attempt to write across stack boundary.
Terminating /home/amdfanatyk/src/libsafe-2.0-16/exploits/t5.
   uid=500  euid=500  pid=2527
Call stack:
   0x51162973  /lib/libsafe.so.2.0.16
   0x51162fa1  /lib/libsafe.so.2.0.16
   0x80485ac   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t5
   0x80485d5   /home/amdfanatyk/src/libsafe-2.0-16/exploits/t5
   0x5102ade1  /lib/libc-2.3.5.so
Overflow caused by strncat()
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./t6
This program tries to use scanf() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./canary-exploit
This program tries to use printf("%n") to overwrite the
return address on the stack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Unicestwiony
[user@localhost exploits]$

 

[user@localhost exploits]$ ./exploit-non-exec-stack
This program demonstrates how a (stack) buffer overflow
can attack linux kernels with *non-executable* stacks.
This is variation on return-int-libc attack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Unicestwiony
[user@localhost exploits]$

 

jak widac w przypadku exploitow: t6, canary-exploit, exploit-non-exec-stack nie zadzialalo libsafe; programy zostaly zabite dzieki ochronie PaX'a.

 

KOPIOWANIE, ROZPOWSZECHNIANIE ITD TEGOZ TEKSTU BEZ PISEMNEJ ZGODY AUTORA ZABRONIONE!!

JESLI CHCESZ UMIESCIC TEN TEKST NA SWOJEJ STRONIE NAJPIERW SKONTAKTUJ SIE ZE MNA!!

[patpi]

niezłe, dzieki.

[gajownik]

wtedy wlamywacz od razu uzyskuje uprawnienia administratora i moze zrobic wszystko, na co ma ochote.

Pod warunkiem, że się wyłączyło SELinux lub program pracował w domenie unconfined_t. W przeciwnym wypadku włamywacz będzie miał tylko dostęp do plików, portów, obiektów, do których ma dana domena. Tak więc, jeśli zhaczony zostanie przykładowo httpd, to włamywacz nie będzie mógł grzebać np. w konfiguracji crona, itd.

na sam koniec zamieszczam wyniki dzialania exploitow dostarczonych z libsafe

Hehe, żaden z nich nie działa w standardowej instalacji Fedory, bo Exec-Shield wszystko ubija :-)

http://www.redhat.com/magazine/009jul05/fe...res/execshield/

 

[test3@X exploits]$ make
gcc -o t1 -Wall  t1.c
gcc -o t3 -Wall  t3.c
gcc -o t4 -Wall  t4.c
gcc -o t5 -Wall  t5.c
gcc -o t6 -Wall  t6.c
gcc -o t1w -Wall  t1w.c
gcc -o t3w -Wall  t3w.c
gcc -o t4w -Wall  t4w.c
gcc -o canary-exploit -Wall  canary-exploit.c
gcc -o exploit-non-exec-stack -Wall  exploit-non-exec-stack.c
[test3@X exploits]$ ./t1
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t1w
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t3
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t3w
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t4
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
parent process terminating
[test3@X exploits]$ ./t4w
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
parent process terminating
[test3@X exploits]$ ./t5
This program tries to use strcat() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t6
This program tries to use scanf() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./canary-exploit
This program tries to use printf("%n") to overwrite the
return address on the stack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./exploit-non-exec-stack
This program demonstrates how a (stack) buffer overflow
can attack linux kernels with *non-executable* stacks.
This is variation on return-int-libc attack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$

Jak ktoś nie wierzy, że to on, to niech wyda to polecenie:

echo 0 >/proc/sys/kernel/exec-shield

i sprawdzi exploity jeszcze raz.

 

Sprawdziłem też nowe opcje GCC, przy użyciu których jest skompilowana FC4 jak i przyszła FC5:

 

FC4 - z FORTIFY_SOURCE=2

[test3@X exploits]$ make
gcc -o t1 `rpm --eval %{optflags}`  t1.c
gcc -o t3 `rpm --eval %{optflags}`  t3.c
gcc -o t4 `rpm --eval %{optflags}`  t4.c
gcc -o t5 `rpm --eval %{optflags}`  t5.c
gcc -o t6 `rpm --eval %{optflags}`  t6.c
t6.c: In function ‘foo’:
t6.c:55: warning: ignoring return value of ‘sscanf’, declared with attribute warn_unused_result
gcc -o t1w `rpm --eval %{optflags}`  t1w.c
gcc -o t3w `rpm --eval %{optflags}`  t3w.c
gcc -o t4w `rpm --eval %{optflags}`  t4w.c
gcc -o canary-exploit `rpm --eval %{optflags}`  canary-exploit.c
gcc -o exploit-non-exec-stack `rpm --eval %{optflags}`  exploit-non-exec-stack.c
[test3@X exploits]$ ./t1
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t1 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x6c52d7]
./t1[0x804856a]
./t1[0x8048582]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t1[0x8048411]
======= Memory map: ========
002f8000-002f9000 r-xp 002f8000 00:00 0          [vdso]
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
08048000-08049000 r-xp 00000000 03:06 175118     /home/test3/libsafe-2.0-16/exploits/t1
08049000-0804a000 rw-p 00000000 03:06 175118     /home/test3/libsafe-2.0-16/exploits/t1
083d7000-083f8000 rw-p 083d7000 00:00 0          [heap]
b7f5a000-b7f5c000 rw-p b7f5a000 00:00 0
b7f72000-b7f74000 rw-p b7f72000 00:00 0
bfc5f000-bfc74000 rw-p bfc5f000 00:00 0          [stack]
Przerwane
[test3@X exploits]$ ./t1w
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./t3
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t3 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x6c52d7]
./t3[0x80485bc]
./t3[0x8048640]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t3[0x80484a1]
======= Memory map: ========
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00e2d000-00e2e000 r-xp 00e2d000 00:00 0          [vdso]
08048000-08049000 r-xp 00000000 03:06 175132     /home/test3/libsafe-2.0-16/exploits/t3
08049000-0804a000 rw-p 00000000 03:06 175132     /home/test3/libsafe-2.0-16/exploits/t3
08ec6000-08ee7000 rw-p 08ec6000 00:00 0          [heap]
b7f6b000-b7f6d000 rw-p b7f6b000 00:00 0
bf96f000-bf985000 rw-p bf96f000 00:00 0          [stack]
Przerwane
[test3@X exploits]$ ./t3w
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t3w terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x6c52d7]
./t3w[0x80485fc]
./t3w[0x8048690]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t3w[0x80484e1]
======= Memory map: ========
0047e000-0047f000 r-xp 0047e000 00:00 0          [vdso]
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
08048000-08049000 r-xp 00000000 03:06 175138     /home/test3/libsafe-2.0-16/exploits/t3w
08049000-0804a000 rw-p 00000000 03:06 175138     /home/test3/libsafe-2.0-16/exploits/t3w
09815000-09836000 rw-p 09815000 00:00 0          [heap]
b7f1c000-b7f1e000 rw-p b7f1c000 00:00 0
bf821000-bf836000 rw-p bf821000 00:00 0          [stack]
Przerwane
[test3@X exploits]$ ./t4
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t4 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x6c52d7]
./t4[0x80485fc]
./t4[0x8048684]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t4[0x80484e1]
======= Memory map: ========
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00cfd000-00cfe000 r-xp 00cfd000 00:00 0          [vdso]
08048000-08049000 r-xp 00000000 03:06 175134     /home/test3/libsafe-2.0-16/exploits/t4
08049000-0804a000 rw-p 00000000 03:06 175134     /home/test3/libsafe-2.0-16/exploits/t4
09ea8000-09ec9000 rw-p 09ea8000 00:00 0          [heap]
b7f89000-b7f8b000 rw-p b7f89000 00:00 0
b7fa1000-b7fa3000 rw-p b7fa1000 00:00 0
bf98d000-bf9a3000 rw-p bf98d000 00:00 0          [stack]
parent process terminating
[test3@X exploits]$ ./t4w
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t4w terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x6c52d7]
./t4w[0x804862f]
./t4w[0x80486c8]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t4w[0x8048511]
======= Memory map: ========
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00752000-00753000 r-xp 00752000 00:00 0          [vdso]
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
08048000-08049000 r-xp 00000000 03:06 175139     /home/test3/libsafe-2.0-16/exploits/t4w
08049000-0804a000 rw-p 00000000 03:06 175139     /home/test3/libsafe-2.0-16/exploits/t4w
08a71000-08a92000 rw-p 08a71000 00:00 0          [heap]
b7fc0000-b7fc2000 rw-p b7fc0000 00:00 0
b7fd8000-b7fda000 rw-p b7fd8000 00:00 0
bfdc5000-bfdda000 rw-p bfdc5000 00:00 0          [stack]
parent process terminating
[test3@X exploits]$ ./t5
This program tries to use strcat() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t5 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
/lib/libc.so.6[0x6c5401]
./t5[0x804858b]
./t5[0x80485a3]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./t5[0x8048411]
======= Memory map: ========
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
007f5000-007f6000 r-xp 007f5000 00:00 0          [vdso]
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
08048000-08049000 r-xp 00000000 03:06 175135     /home/test3/libsafe-2.0-16/exploits/t5
08049000-0804a000 rw-p 00000000 03:06 175135     /home/test3/libsafe-2.0-16/exploits/t5
08b68000-08b89000 rw-p 08b68000 00:00 0          [heap]
b7fc9000-b7fcb000 rw-p b7fc9000 00:00 0
b7fe1000-b7fe3000 rw-p b7fe1000 00:00 0
bfccd000-bfce3000 rw-p bfccd000 00:00 0          [stack]
Przerwane
[test3@X exploits]$ ./t6
This program tries to use scanf() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./canary-exploit
This program tries to use printf("%n") to overwrite the
return address on the stack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test3@X exploits]$ ./exploit-non-exec-stack
This program demonstrates how a (stack) buffer overflow
can attack linux kernels with *non-executable* stacks.
This is variation on return-int-libc attack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./exploit-non-exec-stack terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x6c5c45]
./exploit-non-exec-stack[0x80485c7]
/lib/libc.so.6(__libc_start_main+0xdf)[0x5fcd5f]
./exploit-non-exec-stack[0x8048471]
======= Memory map: ========
005ca000-005e4000 r-xp 00000000 03:05 856094     /lib/ld-2.3.5.so
005e4000-005e5000 r-xp 00019000 03:05 856094     /lib/ld-2.3.5.so
005e5000-005e6000 rwxp 0001a000 03:05 856094     /lib/ld-2.3.5.so
005e8000-0070b000 r-xp 00000000 03:05 856113     /lib/libc-2.3.5.so
0070b000-0070d000 r-xp 00123000 03:05 856113     /lib/libc-2.3.5.so
0070d000-0070f000 rwxp 00125000 03:05 856113     /lib/libc-2.3.5.so
0070f000-00711000 rwxp 0070f000 00:00 0
00917000-00918000 r-xp 00917000 00:00 0          [vdso]
00988000-00991000 r-xp 00000000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
00991000-00992000 rwxp 00009000 03:05 856089     /lib/libgcc_s-4.0.2-20051126.so.1
08048000-08049000 r-xp 00000000 03:06 175141     /home/test3/libsafe-2.0-16/exploits/exploit-non-exec-stack
08049000-0804a000 rw-p 00000000 03:06 175141     /home/test3/libsafe-2.0-16/exploits/exploit-non-exec-stack
08c6e000-08c8f000 rw-p 08c6e000 00:00 0          [heap]
b7fc3000-b7fc5000 rw-p b7fc3000 00:00 0
b7fdb000-b7fdd000 rw-p b7fdb000 00:00 0
bfbc7000-bfbdd000 rw-p bfbc7000 00:00 0          [stack]
Przerwane
[test3@X exploits]$

FORTIFY_SOURCE nie poradziło sobie z t1w (tu libsafe było lepsze) oraz z t6 i canary-exploit. W odróznieniu jednak od libsafe wykryło jednak bład w exploit-non-exec-stack.

 

Rawhide - -Wp,-D_FORTIFY_SOURCE=2 -fstack-protector --param=ssp-buffer-size=4

[test@X exploits]$ vim Makefile
[test@X exploits]$ make
gcc -o t1 `rpm --eval %{optflags}`  t1.c
gcc -o t3 `rpm --eval %{optflags}`  t3.c
gcc -o t4 `rpm --eval %{optflags}`  t4.c
gcc -o t5 `rpm --eval %{optflags}`  t5.c
gcc -o t6 `rpm --eval %{optflags}`  t6.c
gcc -o t1w `rpm --eval %{optflags}`  t1w.c
gcc -o t3w `rpm --eval %{optflags}`  t3w.c
gcc -o t4w `rpm --eval %{optflags}`  t4w.c
gcc -o canary-exploit `rpm --eval %{optflags}`  canary-exploit.c
gcc -o exploit-non-exec-stack `rpm --eval %{optflags}`  exploit-non-exec-stack.c
[test@X exploits]$ ./t1
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t1 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x96b9c5]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x96af67]
./t1[0x80485c0]
./t1[0x80485f6]
/lib/libc.so.6(__libc_start_main+0xdc)[0x8a57a4]
./t1[0x8048461]
======= Memory map: ========
00111000-0011c000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
0011c000-0011d000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00584000-00585000 r-xp 00584000 00:00 0          [vdso]
00890000-009b3000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
009b3000-009b6000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
009b6000-009b7000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
009b7000-009ba000 rwxp 009b7000 00:00 0
00f10000-00f29000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
00f29000-00f2a000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
00f2a000-00f2b000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
08048000-08049000 r-xp 00000000 03:02 517194     /home/test/libsafe-2.0-16/exploits/t1
08049000-0804a000 rw-p 00000000 03:02 517194     /home/test/libsafe-2.0-16/exploits/t1
083dd000-083fe000 rw-p 083dd000 00:00 0          [heap]
b7f5e000-b7f60000 rw-p b7f5e000 00:00 0
b7f6c000-b7f6e000 rw-p b7f6c000 00:00 0
bfc59000-bfc6e000 rw-p bfc59000 00:00 0          [stack]
Przerwane
[test@X exploits]$ ./t1w
This program tries to use strcpy() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t1w terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x80b9c5]
/lib/libc.so.6[0x80c0cb]
./t1w[0x80485c0]
./t1w[0x80485f6]
/lib/libc.so.6(__libc_start_main+0xdc)[0x7457a4]
./t1w[0x8048461]
======= Memory map: ========
00730000-00853000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00853000-00856000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00856000-00857000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00857000-0085a000 rwxp 00857000 00:00 0
00cd6000-00cd7000 r-xp 00cd6000 00:00 0          [vdso]
00d8c000-00da5000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
00da5000-00da6000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
00da6000-00da7000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
00fbb000-00fc6000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00fc6000-00fc7000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
08048000-08049000 r-xp 00000000 03:02 517692     /home/test/libsafe-2.0-16/exploits/t1w
08049000-0804a000 rw-p 00000000 03:02 517692     /home/test/libsafe-2.0-16/exploits/t1w
09491000-094b2000 rw-p 09491000 00:00 0          [heap]
b7faa000-b7fac000 rw-p b7faa000 00:00 0
b7fb8000-b7fba000 rw-p b7fb8000 00:00 0
bfba5000-bfbba000 rw-p bfba5000 00:00 0          [stack]
Przerwane
[test@X exploits]$ ./t3
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t3 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0xb0a9c5]
/lib/libc.so.6(__strcpy_chk+0x3f)[0xb09f67]
./t3[0x804862e]
./t3[0x80486ac]
/lib/libc.so.6(__libc_start_main+0xdc)[0xa447a4]
./t3[0x8048501]
======= Memory map: ========
007dd000-007de000 r-xp 007dd000 00:00 0          [vdso]
007f3000-007fe000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
007fe000-007ff000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00811000-0082a000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
0082a000-0082b000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
0082b000-0082c000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
00a2f000-00b52000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00b52000-00b55000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00b55000-00b56000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00b56000-00b59000 rwxp 00b56000 00:00 0
08048000-08049000 r-xp 00000000 03:02 517526     /home/test/libsafe-2.0-16/exploits/t3
08049000-0804a000 rw-p 00000000 03:02 517526     /home/test/libsafe-2.0-16/exploits/t3
084f2000-08513000 rw-p 084f2000 00:00 0          [heap]
b7f49000-b7f4b000 rw-p b7f49000 00:00 0
bfb43000-bfb59000 rw-p bfb43000 00:00 0          [stack]
Przerwane
[test@X exploits]$ ./t3w
This program will exec() a new program.  The new program will
overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t3w terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x8a39c5]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x8a2f67]
./t3w[0x804866e]
./t3w[0x804870c]
/lib/libc.so.6(__libc_start_main+0xdc)[0x7dd7a4]
./t3w[0x8048541]
======= Memory map: ========
005dc000-005dd000 r-xp 005dc000 00:00 0          [vdso]
007c8000-008eb000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
008eb000-008ee000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
008ee000-008ef000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
008ef000-008f2000 rwxp 008ef000 00:00 0
00908000-00913000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00913000-00914000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00c0e000-00c27000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
00c27000-00c28000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
00c28000-00c29000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
08048000-08049000 r-xp 00000000 03:02 517746     /home/test/libsafe-2.0-16/exploits/t3w
08049000-0804a000 rw-p 00000000 03:02 517746     /home/test/libsafe-2.0-16/exploits/t3w
093cb000-093ec000 rw-p 093cb000 00:00 0          [heap]
b7f70000-b7f72000 rw-p b7f70000 00:00 0
bfc6b000-bfc80000 rw-p bfc6b000 00:00 0          [stack]
Przerwane
[test@X exploits]$ ./t4
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t4 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0xa099c5]
/lib/libc.so.6(__strcpy_chk+0x3f)[0xa08f67]
./t4[0x804865e]
./t4[0x80486ec]
/lib/libc.so.6(__libc_start_main+0xdc)[0x9437a4]
./t4[0x8048531]
======= Memory map: ========
002cf000-002da000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
002da000-002db000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
0092e000-00a51000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00a51000-00a54000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00a54000-00a55000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00a55000-00a58000 rwxp 00a55000 00:00 0
00a87000-00a88000 r-xp 00a87000 00:00 0          [vdso]
00c75000-00c8e000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
00c8e000-00c8f000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
00c8f000-00c90000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
08048000-08049000 r-xp 00000000 03:02 517584     /home/test/libsafe-2.0-16/exploits/t4
08049000-0804a000 rw-p 00000000 03:02 517584     /home/test/libsafe-2.0-16/exploits/t4
08926000-08947000 rw-p 08926000 00:00 0          [heap]
b7f15000-b7f17000 rw-p b7f15000 00:00 0
b7f23000-b7f25000 rw-p b7f23000 00:00 0
bff0f000-bff25000 rw-p bff0f000 00:00 0          [stack]
parent process terminating
[test@X exploits]$ ./t4w
This program will fork() child process, and the child
will overflow the buffer using strcpy().
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t4w terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0x1ec9c5]
/lib/libc.so.6(__strcpy_chk+0x3f)[0x1ebf67]
./t4w[0x804869e]
./t4w[0x804873c]
/lib/libc.so.6(__libc_start_main+0xdc)[0x1267a4]
./t4w[0x8048571]
======= Memory map: ========
00111000-00234000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00234000-00237000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00237000-00238000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00238000-0023b000 rwxp 00238000 00:00 0
0070d000-00726000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
00726000-00727000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
00727000-00728000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
00f61000-00f62000 r-xp 00f61000 00:00 0          [vdso]
00fcc000-00fd7000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00fd7000-00fd8000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
08048000-08049000 r-xp 00000000 03:02 517748     /home/test/libsafe-2.0-16/exploits/t4w
08049000-0804a000 rw-p 00000000 03:02 517748     /home/test/libsafe-2.0-16/exploits/t4w
08a1a000-08a3b000 rw-p 08a1a000 00:00 0          [heap]
b7f21000-b7f23000 rw-p b7f21000 00:00 0
b7f2f000-b7f31000 rw-p b7f2f000 00:00 0
bfe1b000-bfe31000 rw-p bfe1b000 00:00 0          [stack]
parent process terminating
[test@X exploits]$ ./t5
This program tries to use strcat() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./t5 terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0xf269c5]
/lib/libc.so.6[0xf26085]
./t5[0x8048619]
./t5[0x8048656]
/lib/libc.so.6(__libc_start_main+0xdc)[0xe607a4]
./t5[0x80484a1]
======= Memory map: ========
00113000-00114000 r-xp 00113000 00:00 0          [vdso]
005d9000-005f2000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
005f2000-005f3000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
005f3000-005f4000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
00cc8000-00cd3000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00cd3000-00cd4000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00e4b000-00f6e000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00f6e000-00f71000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00f71000-00f72000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00f72000-00f75000 rwxp 00f72000 00:00 0
08048000-08049000 r-xp 00000000 03:02 517585     /home/test/libsafe-2.0-16/exploits/t5
08049000-0804a000 rw-p 00000000 03:02 517585     /home/test/libsafe-2.0-16/exploits/t5
09dfe000-09e1f000 rw-p 09dfe000 00:00 0          [heap]
b7f3d000-b7f3f000 rw-p b7f3d000 00:00 0
b7f4b000-b7f4d000 rw-p b7f4b000 00:00 0
bfa37000-bfa4d000 rw-p bfa37000 00:00 0          [stack]
Przerwane
[test@X exploits]$ ./t6
This program tries to use scanf() to overflow the buffer.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
If you see this statement, it means that the buffer
overflow never occurred.
[test@X exploits]$ ./canary-exploit
This program tries to use printf("%n") to overwrite the
return address on the stack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
Naruszenie ochrony pamięci
[test@X exploits]$ ./exploit-non-exec-stack
This program demonstrates how a (stack) buffer overflow
can attack linux kernels with *non-executable* stacks.
This is variation on return-int-libc attack.
If you get a /bin/sh prompt, then the exploit has worked.
Press any key to continue...
*** buffer overflow detected ***: ./exploit-non-exec-stack terminated
======= Backtrace: =========
/lib/libc.so.6(__chk_fail+0x41)[0xe969c5]
./exploit-non-exec-stack[0x804864c]
/lib/libc.so.6(__libc_start_main+0xdc)[0xdd07a4]
./exploit-non-exec-stack[0x80484d1]
======= Memory map: ========
00199000-001a4000 r-xp 00000000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
001a4000-001a5000 rwxp 0000a000 03:02 969975     /lib/libgcc_s-4.1.0-20060219.so.1
00232000-0024b000 r-xp 00000000 03:02 904976     /lib/ld-2.3.90.so
0024b000-0024c000 r-xp 00018000 03:02 904976     /lib/ld-2.3.90.so
0024c000-0024d000 rwxp 00019000 03:02 904976     /lib/ld-2.3.90.so
00c74000-00c75000 r-xp 00c74000 00:00 0          [vdso]
00dbb000-00ede000 r-xp 00000000 03:02 904984     /lib/libc-2.3.90.so
00ede000-00ee1000 r-xp 00122000 03:02 904984     /lib/libc-2.3.90.so
00ee1000-00ee2000 rwxp 00125000 03:02 904984     /lib/libc-2.3.90.so
00ee2000-00ee5000 rwxp 00ee2000 00:00 0
08048000-08049000 r-xp 00000000 03:02 517750     /home/test/libsafe-2.0-16/exploits/exploit-non-exec-stack
08049000-0804a000 rw-p 00000000 03:02 517750     /home/test/libsafe-2.0-16/exploits/exploit-non-exec-stack
08f3f000-08f60000 rw-p 08f3f000 00:00 0          [heap]
b7efc000-b7efe000 rw-p b7efc000 00:00 0
b7f0a000-b7f0c000 rw-p b7f0a000 00:00 0
bf8f7000-bf90c000 rw-p bf8f7000 00:00 0          [stack]
Przerwane
[test@X exploits]$

W FC5 dodatkowo wykorzystywany jest Stack Smashing Protector. Z powyższych exploitów, bład nie został wykryty w canary-exploit.

 

Jak widać FORTIFY_SOURCE oraz Exec-Shield całkiem nieźle chronią przed exploitami dla mas ;-) Trzeba się teraz bardziej natrudzić, by to obejść.

 

Warto tez się pobawić zmiennymi SELinux takimi jak allow_execmem, allow_execstack, itd (getsebool -a | grep exec).

[InIrudeBwoy]

świetne info, szacunek

 

jestem zielony w tych sprawach. Dziękuję za odrobinę wiedzy, która sie przyda z pewnością.

Kierując sie wypowiedziami mogę powiedzieć, że patchy na razie nie potrzebuję.

 

pokój

[Gość amdfanatyk]

wtedy wlamywacz od razu uzyskuje uprawnienia administratora i moze zrobic wszystko, na co ma ochote.

Pod warunkiem, że się wyłączyło SELinux lub program pracował w domenie unconfined_t. W przeciwnym wypadku włamywacz będzie miał tylko dostęp do plików, portów, obiektów, do których ma dana domena. Tak więc, jeśli zhaczony zostanie przykładowo httpd, to włamywacz nie będzie mógł grzebać np. w konfiguracji crona, itd.

tak (_na prawde_ → naprawdę) ORT to kazda usluga bindujaca port powinna byc wrzucona do jail'a i wtedy bylby spokoj;

 

nalezy tez pamietac, ze troche czym innym jest uruchamianie sobie "takich exploitow", ktore nic nie exploituja a prawdziwych exploitow dzialajacych na usludze;

 

rowniez inaczej zabezpiecza sie system jesli spodziewamy sie ataku lokalnie a inaczej jesli zdalnie; w pierwszym przypadku najlepiej skorzystac z ids'a, w drugim zas z pax'a; osobiscie nie widze zbytnio mozliwosci zdalnego wlamu przez program chroniony pax'em, prawdopodobienstwo powodzenia oceniam osobiscie na ok. 0.1%; jesli chodzi o ograniczenia lokalne to rowniez grsecurity oferuje wiele opcji, wiec ostatecznie sam administrator powinien rozwazyc, czy skorzysta z grsec czy np. lids'a; nalezy pamietac, ze ten drugi nie oferuje niewykonywalnosci stosu/sterty, chodzi jedynie o maksymalne okrojenie praw takze root'owi, ktory przy dobrze napisanych regulach ma znikome prawa; zeby zmienic cos w systemie trzeba wylaczyc sobie lids'a lokalnie podajac haslo do lids'a i dopiero zalogowac sie na (_root'a_ → roota) ORT; lids dostarcza rowniez mechanizmow TPE (Trusted Path Execution), TDE (Trusted Domain Enforcement) i SANDBOX (program wrzucony do piaskownicy nie moze nic, wszystkie niezbedne do jego dzialania reguly musza byc napisane explicite przez administratora).

[gajownik]

Kierując sie wypowiedziami mogę powiedzieć, że patchy na razie nie potrzebuję.

Musisz jednak używać dystrybucyjnego jądra albo własnego kernela skompilowanego z dystrybycyjnych źródeł. Oprócz tego co podałem wyżej posiada on też patch ograniczający dostęp do /dev/mem, co utrudnia w dużym stopniu możliwość zainstalowania rootkita.

 

Źródła z kernel.org nie mają tych zabezpieczeń.

osobiscie nie widze zbytnio mozliwosci zdalnego wlamu przez program chroniony pax'em

Niektórym się udaje → http://www.stanford.edu/~blp/papers/asrandom.pdf ;-)

 

Obejściem niewykonywalnego stosu są ataki typu return-to-libc. Tutaj przeszkodą jest "address space randomization", ale i to można, jak widać, obejść :-) Najlepiej postawić sobie 64-bitowy system i używać dodatkowo innych zabezpieczających technik (np. wspomniany wcześniej Stack Smashing Protector).

 

Exec-Shiled też dostarcza "address space randomization" i zabronienie wykonywalnego stosu, ale jak to się ma do PaX, to ciężko mi powidzieć -- mi na desktopie wystarczy ;-)

 

[Gość amdfanatyk]

niezbyt rozumiem jak mozna zrobic atak return-into-libc zdalnie; w skrocie przypomne, ze polega on na nadpisaniu adresu powrotu z funkcji przy wykorzystaniu funkcji pochodzacej z libc, ktora to biblioteka zostala juz w pamieci zamapowana jako wykonywalna;

 

http://cc-team.org/index.php?name=artykuly&show=75

 

nie znam exec-shield ale wiem, ze na wylaczonym soft-mode z pax czesc programow nie dziala m.in. gimp, czesc oo, gnat i wszystko nim skompilowane; jesli w dystrybucyjnym kernelu jest wlaczone exec-shield to np. oo by nie dzialal poprawnie.

[InIrudeBwoy]

Musisz jednak używać dystrybucyjnego jądra albo własnego kernela skompilowanego z dystrybycyjnych źródeł. Oprócz tego co podałem wyżej posiada on też patch ograniczający dostęp do /dev/mem, co utrudnia w dużym stopniu możliwość zainstalowania rootkita.

 

Źródła z kernel.org nie mają tych zabezpieczeń.

Jasne, na razie tylko takich używam. Po prostu nie potrzebuję innych rzeczy.