[gcc] Stack-Struktur bei Arrays

[nufan]

Tag
Nachdem ich diesen Thread gelesen habe, war mir klar was der Fehler ist, aber ich bin mit meinem falschen Ergebnis nicht ganz zufrieden ^^
Folgender Beispielcode:

Code: Alles auswählen

#include <stdio.h>

int main( int argc, char *argv[] )
{
  int x = 0x12345678;
  int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
  int z = 0x12345678;
  printf( "%p - %p\n", &(array[0]), &(array[9]) );
  return 0;
}

Kompilieren:

Code: Alles auswählen

$ gcc -o test main.c -g

Ausführen:

Code: Alles auswählen

$ gdb -q ./test 
Reading symbols from /home/daniel/proggen/test...done.
(gdb) break main
Breakpoint 1 at 0x400507: file main.c, line 5.
(gdb) run test-parameter
Starting program: /home/daniel/proggen/test test-parameter

Breakpoint 1, main (argc=2, argv=0x7fffffffe178, envp=0x7fffffffe190) at main.c:5
5         int x = 0x12345678;
(gdb) nexti
6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x0000000000400515      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x000000000040051c      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x0000000000400523      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x000000000040052a      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x0000000000400531      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x0000000000400538      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x000000000040053f      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x0000000000400546      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
0x000000000040054d      6         int array[] = { 9, 8, 5, 6, 7, 0, 1, 4, 3, 2 };
(gdb) nexti
7         int z = 0x12345678;
(gdb) nexti
8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x0000000000400560      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x0000000000400564      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x0000000000400568      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x000000000040056c      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x000000000040056f      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x0000000000400572      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x0000000000400577      8         printf( "%p - %p\n", &(array[0]), &(array[9]) );
(gdb) nexti
0x7fffffffe060 - 0x7fffffffe084
9         return 0;
(gdb) x/20x 0x7fffffffe060-24
0x7fffffffe048: 0xffffe190      0x00007fff      0xffffe178      0x00007fff
0x7fffffffe058: 0x004005d5      0x00000002      0x00000009      0x00000008
0x7fffffffe068: 0x00000005      0x00000006      0x00000007      0x00000000
0x7fffffffe078: 0x00000001      0x00000004      0x00000003      0x00000002
0x7fffffffe088: 0x12345678      0x12345678      0x00000000      0x00000000
(gdb) x/s 0x004005d5
0x4005d5 <__libc_csu_init+69>:   "H\205\355t\034\061\333\017\037@"

Die erste Zeile der Adressen steht natürlich für argv nd envp. 0x4005d5 ist anscheinend irgendeine Funktion in der libc. Der zweite Wert der zweiten Zeile ist wohl argc. Aber warum wird zuerst der Array angelegt und dann beide Integer-Variablen? Widerspricht das nicht dem üblichen Aufbau des Stacks?

[cloidnerux]

Die erste Zeile der Adressen steht natürlich für argv nd envp. 0x4005d5 ist anscheinend irgendeine Funktion in der libc. Der zweite Wert der zweiten Zeile ist wohl argc. Aber warum wird zuerst der Array angelegt und dann beide Integer-Variablen? Widerspricht das nicht dem üblichen Aufbau des Stacks?

Werden Variablen überhaupt auf dem Stack abgelegt?
Normalerweise müssten die doch einfach in einem freien Stück Speicher liegen und werden nur auf dem Stack gelegt, wenn die als Rückgabeelement einer Funktion dienen?
Zudem sieht das eher nach einer Designentscheidung von gcc aus, dass man erst alle Arrays anlegt und dann alle Einzelvariablen.

MfG cloidnerux.

[Xin]

Die erste Zeile der Adressen steht natürlich für argv nd envp. 0x4005d5 ist anscheinend irgendeine Funktion in der libc.

Vermutlich die Rücksprungadresse, an die main() zurückkehren soll.

Der zweite Wert der zweiten Zeile ist wohl argc. Aber warum wird zuerst der Array angelegt und dann beide Integer-Variablen? Widerspricht das nicht dem üblichen Aufbau des Stacks?

Gegenfrage: Warum nicht?

Muss der Compiler garantieren, dass Du beim Bufferoverflow Deine Wunschvariablen überschreibst? Was ist ein üblicher Aufbau und wer sagt, dass es überhaupt einen Stack geben muss? Ist das nicht alles ein Implementationsdetail, das vielleicht üblich ist, aber deswegen nicht zwangsweise "Standard"?

Werden Variablen überhaupt auf dem Stack abgelegt?
Normalerweise müssten die doch einfach in einem freien Stück Speicher liegen und werden nur auf dem Stack gelegt, wenn die als Rückgabeelement einer Funktion dienen?

Das freie Stück Speicher ist der Stack - üblicherweise. ^^

[nufan]

Die erste Zeile der Adressen steht natürlich für argv nd envp. 0x4005d5 ist anscheinend irgendeine Funktion in der libc.

Vermutlich die Rücksprungadresse, an die main() zurückkehren soll.

"__libc_csu_init" hört sich mehr nach der Initialisierung des Programms an, aber egal.

Muss der Compiler garantieren, dass Du beim Bufferoverflow Deine Wunschvariablen überschreibst?

Wäre nett ^^

Was ist ein üblicher Aufbau und wer sagt, dass es überhaupt einen Stack geben muss? Ist das nicht alles ein Implementationsdetail, das vielleicht üblich ist, aber deswegen nicht zwangsweise "Standard"?

Stimmt, ergibt Sinn... hatte das nur anders erwartet.

[Xin]

Die erste Zeile der Adressen steht natürlich für argv nd envp. 0x4005d5 ist anscheinend irgendeine Funktion in der libc.

Vermutlich die Rücksprungadresse, an die main() zurückkehren soll.

"__libc_csu_init" hört sich mehr nach der Initialisierung des Programms an, aber egal.

Und nachdem das Programm initialisiert ist, man aus dem Befehlsaufruf die Argumente gezählt und zu einem einem (char **) zusammengefasst hat, ruft man main() auf.