Wie DataSunrise Security vor SQL-Injections schützt
In diesem Artikel demonstrieren wir Ihnen, wie DataSunrise SQL-Injections verhindert, welche zu den beliebtesten Hacker-Methoden gehören, um Webanwendungen zu kompromittieren. Um Ihnen zu zeigen, was genau passiert, wenn DataSunrise eine bösartige Anfrage abfängt, führen wir einen Penetrationstest mit einer speziellen Software durch.
Sqlmap
Obwohl es viele verschiedene Anwendungen für automatisierte Schwachstellenbewertungen gibt, verwenden wir in unserem aktuellen Experiment das Dienstprogramm Sqlmap. Dieses kostenlose Open-Source-Programm ist in der Python-Sprache geschrieben und aufgrund seiner Befehlszeilenschnittstelle einfach zu verwenden.
Gemäß der offiziellen Beschreibung kann Sqlmap die folgenden SQL-Injektionstechniken für Penetrationstests nutzen:
Boolean-basierte Blind-Injektion
Sqlmap fügt dem anfälligen Parameter in der HTTP-Abfrage eine syntaktisch gültige SQL-Anweisung hinzu, die eine SELECT-Subanweisung oder eine andere SQL-Anweisung enthält, um eine Ausgabe aus der Datenbank abzurufen. Dann vergleicht Sqlmap jede HTTP-Antwort mit der ursprünglichen Anfrage und erhält die Ausgabe der injizierten Anweisung Zeichen für Zeichen.
Time-basierte Blind-Injektion
Sqlmap fügt dem anfälligen Parameter eine syntaktisch gültige Anweisung hinzu, die eine Abfrage enthält, die eine Verzögerung im DBMS-Backend für eine bestimmte Anzahl von Sekunden verursacht. Dann führt das Dienstprogramm einen Vergleich zwischen der ursprünglichen Antwortzeit und der Zeit, die für die Antwort auf die injizierte Abfrage aufgewendet wurde, durch und schließt daraus die Ausgabe der injizierten Anweisung Zeichen für Zeichen.
Error-basierte Injektion
Sqlmap fügt dem anfälligen Parameter in der HTTP-Anfrage eine syntaktisch ungültige Anweisung hinzu, die eine datenbankspezifische Fehlermeldung verursacht. Dann analysiert Sqlmap die HTTP-Antwort, um Fehlermeldungen zu finden, die injizierten SQL-Code und die Ausgabe der Subabfrage enthalten. Diese Methode der SQL-Injektion funktioniert nur, wenn das DBMS so konfiguriert ist, dass Backend-DBMS-Fehlermeldungen angezeigt werden.
UNION-basierte Injektion
Sqlmap fügt dem anfälligen Parameter in der HTTP-Anfrage eine syntaktisch gültige SQL-Anweisung hinzu, die mit UNION ALL SELECT beginnt. Diese Methode ist nützlich, wenn die Webseite der Webanwendung eine FOR-Schleife oder ähnliches verwendet, um die Ausgabe der SELECT-Anweisung weiterzugeben, sodass jede Zeile der Abfrageausgabe auf dem Seiteninhalt gedruckt wird. Sqlmap kann auch „partielle“ UNION-basierte SQL-Injektionslücken ausnutzen. Solche Schwachstellen treten auf, wenn der FOR-Zyklus nicht verwendet wird und nur der erste Eintrag der Abfrageausgabe angezeigt wird.
Stapled Query-basierte Injektion (Piggybacking)
Wenn die Ziel-Webanwendung gestapelte Abfragen unterstützt, fügt Sqlmap dem anfälligen Parameter in der HTTP-Abfrage ein Semikolonzeichen ( ; ) hinzu, gefolgt von der zu injizierenden SQL-Anweisung. Diese Technik wird verwendet, um Injektionen von SQL-Anweisungen durchzuführen, die nicht SELECT sind (wie Datendefinitions- oder Datenmanipulationsanweisungen). Potenziell kann diese Methode verwendet werden, um Lese- / Schreibzugriff auf das Dateisystem und die Ausführung von Betriebssystembefehlen zu erhalten, abhängig vom DBMS-Backend und den Sitzungsbenutzerrechten.
Wie Sie sehen können, ist Sqlmap ein leistungsfähiges Tool, das nicht nur Schwachstellen aufdecken kann, sondern sie auch mit verschiedenen SQL-Injektionstechniken ausnutzen kann. Hier erfahren Sie mehr über Methoden zur Erkennung von SQL-Injektionen.
Vorbereitungen für den Test
Um unsere Demonstration durchzuführen, benötigen wir eine „Test-Dummy“-Anwendung, die SQL-injiziert werden kann, daher verwenden wir einen einfachen Webserver, der in Python geschrieben ist. Dieser Server ist so konzipiert, dass er Informationen aus einer Datenbank ausgibt, die durch die Parameter in der URL-Zeichenfolge definiert sind. Wir haben den Webserver-Code in der Datei webserv_inj.py gespeichert:
import re
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse
import pyodbc
global dbconnection
global dbcursor
class InjectedServer(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "text/html charset=windows-1251")
self.end_headers()
o = urlparse(self.path)
params = urllib.request.unquote(o.query)
m = re.search("id=(?P[^;]+);name=(?P[^;]+)", params)
id = m.group("id")
name = m.group("name")
dbconnection = pyodbc.connect(
"Driver=PostgreSQL ODBC Driver(ANSI);Server=localhost;Port=54321;Database=test_db;Uid=postgres;Pwd=admin;UseServerSidePrepare=1")
dbcursor = dbconnection.cursor()
queryStr = "select * from injected_table where id = " + id + " and name = '" + name + "' order by id"
dbcursor.execute(queryStr)
result = dbcursor.fetchall()
for row in result:
self.wfile.write(bytes(str(row[0]), "utf-8"))
self.wfile.write(bytes(str(row[1]), "utf-8"))
self.wfile.write(bytes(str(row[2]), "utf-8"))
myServer = HTTPServer(("127.0.0.1", 6589), InjectedServer)
try:
myServer.serve_forever()
except KeyboardInterrupt:
pass
myServer.server_close()
Wir werden versuchen, unseren selbst erstellten Webserver zu kompromittieren und einige Daten aus einer PostgreSQL-Datenbank zu erhalten. Wir haben den folgenden Code verwendet, um eine neue Datenbanktabelle („injected_table“) zu erstellen und mit zwei Einträgen zu füllen:
CREATE TABLE injected_table
(
id integer,
name character varying(200),
surname character varying(200)
)
INSERT INTO injected_table VALUES (1, Bob, Martin);
INSERT INTO injected_table VALUES (2, Denis, Morgan);
So sieht die neue Tabelle in der PGAdmin aus
Dann starten wir unseren Server, indem wir den folgenden Befehl über die Windows-Eingabeaufforderung ausführen:
python webserv_inj.py
Um sicherzustellen, dass alles wie erwartet funktioniert, senden wir die folgende Abfrage an den Webserver über den Webbrowser:
http://127.0.0.1:6589/?id=2;name=Denis
Als Ergebnis gab der Webserver den Eintrag „injected_table“ mit ID=2 und Name=Denis aus
Testen des Webservers mit Sqlmap
Jetzt ist es Zeit zu überprüfen, ob unser Webserver SQL-injiziert werden kann.
Zuerst starten wir das Sqlmap-Testverfahren über die Eingabeaufforderung:
python.exe sqlmap.py -u http://127.0.0.1:6589/?id=2;name=Denis
Wenn der Testvorgang abgeschlossen ist, werfen wir einen Blick auf die Sqlmap-Protokolldatei (sie wurde automatisch erstellt und im Ordner „output“ gespeichert).
sqlmap identified the following injection point(s) with a total of 50 HTTP(s) requests: --- Parameter: id (GET) Type: boolean-based blind Title: AND boolean-based blind - WHERE or HAVING clause Payload: id=2;name=Denis' AND 8150=8150 AND 'lsHq'='lsHq Type: AND/OR time-based blind Title: PostgreSQL > 8.1 AND time-based blind Payload: id=2;name=Denis' AND 9061=(SELECT 9061 FROM PG_SLEEP(5)) AND 'TLxE'='TLxE Type: UNION query Title: Generic UNION query (NULL) - 3 columns Payload: id=2;name=Denis' UNION ALL SELECT NULL,NULL,(CHR(113)|| CHR(112)||CHR(120)||CHR(120)||CHR(113))||(CHR(88)||CHR(109)||CHR(66)||CHR(103)||CHR(114)|| CHR(69)||CHR(83)||CHR(119)||CHR(113)||CHR(98)||CHR(110)||CHR(73)||CHR(90)||CHR(83)|| CHR(90)||CHR(121)||CHR(113)||CHR(102)||CHR(85)||CHR(117)||CHR(107)||CHR(72)|| CHR(78)||CHR(101)||CHR(79)||CHR(90)||CHR(112)||CHR(120)||CHR(74)||CHR(106)|| CHR(114)||CHR(105)||CHR(85)||CHR(84)||CHR(71)||CHR(104)||CHR(71)||CHR(89)||CHR(75)|| CHR(111))||(CHR(113)||CHR(22)||CHR(107)||CHR(122)||CHR(113))-- - --- back-end DBMS: PostgreSQL
Wie das Protokoll zeigt, hat Sqlmap erfolgreich die DBMS-Version (PostgreSQL) identifiziert und den Parameter „ID“ als anfällig für SQL-Injektionen bestimmt. Außerdem hat Sqlmap uns drei Varianten von SQL-Anweisungen vorgeschlagen, die verwendet werden können, um SQL-Injektionen durchzuführen („Payload“-Zeichenfolgen).
DataSunrise Security-Regel-Einstellungen (SQL-Injection-Bereich)
Und jetzt werden wir überprüfen, wie effektiv DataSunrise den anfälligen Webserver (und die zugehörige PostgreSQL-Datenbank) gegen SQL-Injektionen schützen kann.
Wir haben eine „SQL-Injection“-Sicherheitsregel erstellt (lesen Sie das DataSunrise-Benutzerhandbuch für Details) und die während des ersten Tests von Sqlmap erstellten Dateien gelöscht.
Nun führen wir das Sqlmap-Testverfahren erneut durch (wie oben beschrieben) und wenn der Test endet, überprüfen wir das Dienstprogrammprotokoll (beachten Sie, dass Sqlmap keine Protokolldatei erstellen konnte, daher verwenden wir das Befehlszeilenprotokoll).
Dem Protokoll zufolge hat Sqlmap festgestellt, dass alle getesteten Parameter nicht anfällig für SQL-Injektionen sind, einschließlich des „ID“-Parameters, der zuvor als injizierbar markiert war.
Schlussfolgerung
Unser Experiment beweist, dass die DataSunrise-Firewall hochwirksam bei der Verhinderung von SQL-Injektionen ist. Dennoch ist es für den bestmöglichen Schutz vor den komplexesten Bedrohungen notwendig, erweiterte Schutzmaßnahmen zu ergreifen, wie die folgenden:
- Befolgen der branchenüblichen Best Practices zur Entwicklung SQL-Injektions-resistenter Webanwendungen
- Durchführen von simulierten Hackerangriffen auf Ihre Datenbanken und Webanwendungen, um mögliche Schwachstellen aufzudecken (sogenannte „Penetrationstests“)
- Kontinuierliche Datenbankprüfungen zur Erkennung von Datenverletzungen und Datenlecks
- Befolgen der Empfehlungen und Richtlinien der Entwickler zur sicheren Nutzung von Datenbanken und zugehöriger Software.
DataSunrise unterstützt alle wichtigen Datenbanken und Data Warehouses wie Oracle, Exadata, IBM DB2, IBM Netezza, MySQL, MariaDB, Greenplum, Amazon Aurora, Amazon Redshift, Microsoft SQL Server, Azure SQL, Teradata und mehr. Sie können gerne eine kostenlose Testversion herunterladen, wenn Sie diese in Ihrem Unternehmen installieren möchten. Wenn Sie ein Cloud-Nutzer sind und Ihre Datenbank auf Amazon AWS oder Microsoft Azure betreiben, können Sie diese im AWS-Marktplatz oder Azure Marktplatz erhalten.
