Buferio perpildymo klaida Įvadas, techniniai klausimai

Transcription

1 Buferio perpildymo klaida Įvadas, techniniai klausimai Rolandas Griškevičius MSN: R. Griškevičius, Saugus programavimas, VGTU,

2 Įkrauta Linux programa Didžiausias adresas Argumentai ir aplinkos (env) kintamieji Stekas (auga žemyn) Nenaudojama atmintis Krūva, (heap), auga aukštyn Mažiausias adresas Neinicializuoti duomenys (.bss) Inicializuoti duomenys (.data) Programos kodas (.text) exec() inicializuoja nuliais Pvz. int notinit[ 1000 ]; exec() iniciaizuoja duomenimis iš vykdomojo elf failo Pvz. int inited[4] = {1,2,3,4}; exec() įkrauna į atmintį ir vykdomojo elf failo R. Griškevičius, Saugus programavimas, VGTU,

3 Krūva,.bss ir.data The heap: Most dynamic memory, whether requested via C's malloc() and similar or C++'s new is doled out to the program from the heap. The C library also gets dynamic memory for its own personal workspace from the heap as well. As more memory is requested "on the fly", the heap grows upward. Uninitialized Data Segment: Also named "bss" (block started by symbol) which was an operator used by an old assembler. This segment contains uninitialized global variables. All variables in this segment are initialized to 0 or NULL pointers before the program begins to execute. Initialized Data Segment: (.data) This segment contains global variables which are initialized by the programmer R. Griškevičius, Saugus programavimas, VGTU,

4 Stekas This area of memory holds some crucial information, like: 1. Storage space for all the automatic variables for the newly called function. 2. The line number of the calling function to return to when the called function returns. 3. The arguments, or parameters, of the called function. Each time a function is called, the address of where to return to and certain information about the caller's environment, such as some of the machine registers, are saved on the stack. The newly called function then allocates room on the stack for its automatic and temporary variables. This is how recursive functions in C can work. Each time a recursive function calls itself, a new stack frame is used, so one set of variables doesn't interfere with the variables from another instance of the function. The stack is a collection of stack frames. When a new frame needs to be added (as a result of a newly called function), the stack grows downward R. Griškevičius, Saugus programavimas, VGTU,

5 asm aiškiai matomi.text ir.data section.text global _start ;section declaration _start: ;write our string to stdout mov edx,len ;third argument: message length mov ecx,msg ;second argument: ptr to msg to write mov ebx,1 ;first argument: file handle (stdout) mov eax,4 ;system call number (sys_write) int 0x80 ;call kernel ;and exit via system call mov ebx,0 ;first syscall argument: exit code mov eax,1 ;system call number (sys_exit) int 0x80 ;call kernel section.data ;section declaration msg db "Hello, world!",0xa ;non-c string len equ $ - msg ;length of string C kalboje už programuotoją segmentų priskyrimus atlieka kompiliatorius/ linkeris objdump -h <elf_vykdomasis failas> - vykdomojo failo sekcijų išvedimas R. Griškevičius, Saugus programavimas, VGTU,

6 Buferio perpildymo klaida Programa buferio perpildymo klaidos testavimui Kur pažeidžiamumas? >./test2 aaaaaaaaaaaaaa buff1: aaaa buff2: aaaaaaaaaaaaaa >./test2 aaaaaaaaaaaaaaa buff1: aaaaa buff2: aaaaaaaaaaaaaaa Segmentation fault int main(int argc, char *argv[]) { char buffer1[5]; char buffer2[10]; } strcpy(buffer2,argv[1]); printf("\nbuff1: %s\nbuff2: %s\n\n", buffer1,buffer2); return 0; >gcc test2.c -o test >./test2 aaaaaaaaaa buff1: buff2: aaaaaaaaaa >./test2 aaaaaaaaaaa buff1: a buff2: aaaaaaaaaaa R. Griškevičius, Saugus programavimas, VGTU,

7 Buferio perpildymo klaida Stekas auga žemyn Funkcijos kintamieji kuriame steke Masyvai taip pat C masyvas tai nuoroda į atmintį, ribų kontrolės nėra C stringas - char masyvas int main(int argc, char *argv[]) { char buffer1[5]; char buffer2[10]; } strcpy(buffer2,argv[1]); printf("\nbuff1: %s\nbuff2: %s\n\n", buffer1,buffer2); return 0; >./test2 aaaaaaaaaaaaaa buff1: aaaa buff2: aaaaaaaaaaaaaa >./test2 aaaaaaaaaaaaaaa buff1: aaaaa buff2: aaaaaaaaaaaaaaa Segmentation fault R. Griškevičius, Saugus programavimas, VGTU,

8 Disasembliuojam gdb <elf failas> disassemble main int main(int argc, char *argv[]) { char buffer1[5]; char buffer2[10]; } strcpy(buffer2,argv[1]); printf("\nbuff1: " "%s\nbuff2: %s\n\n", buffer1,buffer2); return 0; 0x <main+0>: lea 0x4(%esp),%ecx 0x <main+4>: and $0xfffffff0,%esp 0x b <main+7>: pushl -0x4(%ecx) 0x e <main+10>: push %ebp 0x f <main+11>: mov %esp,%ebp 0x <main+13>: push %ecx 0x <main+14>: sub $0x24,%esp 0x <main+17>: mov 0x4(%ecx),%eax 0x <main+20>: add $0x4,%eax 0x b <main+23>: mov (%eax),%eax 0x d <main+25>: mov %eax,0x4(%esp) 0x <main+29>: lea -0x13(%ebp),%eax 0x <main+32>: mov %eax,(%esp) 0x <main+35>: call 0x <strcpy@plt> 0x c <main+40>: lea -0x13(%ebp),%eax 0x f <main+43>: mov %eax,0x8(%esp) 0x <main+47>: lea -0x9(%ebp),%eax 0x <main+50>: mov %eax,0x4(%esp) 0x a <main+54>: movl $0x ,(%esp) 0x <main+61>: call 0x <printf@plt> 0x <main+66>: mov $0x0,%eax 0x b <main+71>: add $0x24,%esp 0x e <main+74>: pop %ecx 0x f <main+75>: pop %ebp 0x <main+76>: lea -0x4(%ecx),%esp 0x <main+79>: ret R. Griškevičius, Saugus programavimas, VGTU,

9 gdb Norint, kad sukompiliuota programa būtų susieta gdb'e su jos išeities kodu (source), reikia kompiliuoti su debug symbols gcc -o test2 test2.c -ggdb Programa debugeriui perduodama kaip komandinė eilutė arba komandos file pagalba Ar debug symbols buvo įkrauti kartu su programa, galima įsitikinti komandos list pagalba Komanda list išveda programos išeities tekstą, sunumeruotą eilučių numeriais Eilučių numerius galima naudoti b komandoje nustatant vykdymo pristabdymus (breakpoint) R. Griškevičius, Saugus programavimas, VGTU,

10 gdb 2 Programa paleidžiama komanda run <parametras1> <parametras n> Parametrų išdėstymas kaip ir leidžiant programą iš komandinės eilutės Jei yra nustatyti vykdymo pristabdymai (breakpointai), vykdymas bus pristabdytas artimiausiame Breakpoint 1, main (argc=2, argv=0xbfb8d734) at test2.c:5 5 strcpy(buffer2,argv[1]); Rodomas eilutės numeris, išeities teksto fragmentas R. Griškevičius, Saugus programavimas, VGTU,

11 gdb 3 Vykdymo valdymas run iš naujo paleidžia iki breakpoint'o, pabaigos (kokia bebūtų - normali, segmentation fault, etc) cont paleidžia vykdymą toliau iki pabaigos, kokia ji bebūtų step [n] n kartų vykdyti sekančią išeities teksto eilutę next [n] n kartų vykdyti sekančią išeities teksto eilutę, nelendant į call procedūros vidų stepi / nexti analogiškai, tik einama per vieną asemblerinę instrukciją R. Griškevičius, Saugus programavimas, VGTU,

12 gdb 4 Atvaizdavimas Kintamųjų ir registrų: print [/FMT] <kintamasis> print [/FMT] $<registras> Atminties: x [/FMT] <kintamasis> x [/FMT] $<registras> x [/FMT] 0x<atminties adresas> (gdb) help x FMT is a repeat count followed by a format letter and a size letter. Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal), t(binary), f(float), a(address), i(instruction), c(char) and s(string). Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes). The specified number of objects of the specified size are printed according to the format. Defaults for format and size letters are those previously used. Default count is R. Griškevičius, Saugus programavimas, VGTU,

13 Literatūra Klasika tapęs dokumentas Smashing stack for fun and profit Istoriškai labai vertingas ir must read, tačiau morališkai pasenęs Kodėl R. Griškevičius, Saugus programavimas, VGTU,