Betreten Sie das Reich der Webanwendungssicherheit mit den OWASP Top 10 als Ihrem Leitfaden. Diese wichtige Ressource ist für Entwickler und Sicherheitsexperten unverzichtbar und bietet einen detaillierten Überblick über die dringendsten Sicherheitsbedrohungen für Webanwendungen. In diesem Artikel erfahren Sie, warum die OWASP Top 10 so wichtig sind und wie Sie die Softwareentwicklungspraktiken in Ihrem Unternehmen verbessern und sicherer machen können. Lassen Sie uns in die OWASP Top 10 eintauchen und geben Sie Hackern nicht die niedrig hängenden Früchte 🚀.
Was ist die OWASP Top 10?
Die OWASP Top 10 ist ein grundlegendes Dokument für alle, die sich mit der Sicherheit von Webanwendungen beschäftigen. Die vom Open Web Application Security Project (OWASP) erstellte Liste zeigt die zehn kritischsten Sicherheitsrisiken für Webanwendungen auf, die von Sicherheitsexperten aus aller Welt ermittelt wurden. Die regelmäßig aktualisierte OWASP Top 10 spiegelt die aktuelle Bedrohungslage wider und bietet einen umfassenden Überblick über die häufigsten und gefährlichsten Schwachstellen.
Die OWASP Top 10 ist als Leitfaden zur Sensibilisierung gedacht und soll Entwickler, Sicherheitsexperten und Unternehmen über diese Hauptrisiken aufklären und ihnen Best Practices zur Abschwächung dieser Risiken bieten. Diese Schwachstellen sind für Angreifer oft die niedrig hängenden Früchte, d. h. sie sind die einfachsten Ziele, da sie häufig in Webanwendungen auftreten. Durch die Übernahme der OWASP Top 10 können Unternehmen wichtige Schritte zur Verbesserung ihrer Sicherheitslage unternehmen und sicherstellen, dass ihre Anwendungen besser vor Cyber-Bedrohungen geschützt sind. Dieses Dokument dient als Ausgangspunkt für die Förderung einer Sicherheitskultur innerhalb von Software-Entwicklungsteams und fördert die Entwicklung sicherer und widerstandsfähigerer Webanwendungen.
Inhalt der OWASP Top 10
A01:2021 - Broken Access Control
Erläuterung
Eine unzureichende Zugriffskontrolle liegt vor, wenn eine Anwendung Sicherheitsmaßnahmen nicht ordnungsgemäß durchsetzt, so dass unbefugte Benutzer auf Ressourcen zugreifen oder diese manipulieren können, wozu sie nicht in der Lage sein sollten. Diese Schwachstelle ist kritisch, da sie zu erheblichen Sicherheitsverletzungen führen kann, einschließlich Datendiebstahl, unbefugten Handlungen und der Preisgabe vertraulicher Informationen. Schwachstellen in der Zugriffskontrolle treten häufig auf, wenn Anwendungen die Benutzerrechte nicht korrekt validieren und so Lücken hinterlassen, durch die Angreifer unbeabsichtigten Zugriff erlangen können.
So kann eine Anwendung beispielsweise nicht richtig prüfen, ob ein Benutzer je nach seiner Rolle berechtigt ist, bestimmte Daten anzuzeigen oder zu ändern. Anstatt Zugriffskontrollen für sensible Aktionen zu erzwingen, verlässt sich die Anwendung möglicherweise auf clientseitige Prüfungen oder stellt Funktionen direkt über URLs zur Verfügung, so dass unbefugte Benutzer die vorgesehenen Sicherheitsmaßnahmen umgehen können. Dies kann auch vorkommen, wenn die Zugriffskontrollen in verschiedenen Teilen einer Anwendung inkonsistent sind oder gänzlich fehlen.
Beispiel
Stellen Sie sich eine Webanwendung vor, bei der Benutzer auf ihre Profilinformationen unter /user/profile/123 zugreifen können. Wenn die Anwendung nicht überprüft, ob der Benutzer, der die Profildaten anfordert, tatsächlich der Eigentümer ist, könnte ein Angreifer dies ausnutzen, indem er die URL in /user/profile/124 ändert, um das Profil einer anderen Person anzuzeigen.
# Flask example without proper access control
@app.route('/user/profile/<user_id>')
def user_profile(user_id):
user = users.get(user_id)
if user:
return jsonify(user)
return "User not found", 404
In diesem anfälligen Beispiel wird nicht überprüft, ob der Benutzer, der die Daten anfordert, zum Zugriff auf sie berechtigt ist.
Maßnahme
# Flask example with proper access control
@app.route('/user/profile/<user_id>')
def user_profile(user_id):
logged_in_user_id = session.get('user_id')
if logged_in_user_id != user_id:
return "Forbidden", 403
user = users.get(user_id)
if user:
return jsonify(user)
return "User not found", 404
Bei dieser sicheren Implementierung prüft die Anwendung, ob die ID des angemeldeten Benutzers mit der angeforderten Profil-ID übereinstimmt. Wenn sie nicht übereinstimmen, gibt die Anwendung eine “Verboten”-Antwort zurück und verhindert so den unbefugten Zugriff.
A02:2021 - Cryptographic Failures
Erläuterung
Kryptografische Fehler treten auf, wenn Anwendungen Verschlüsselung oder kryptografische Techniken falsch oder unzureichend einsetzen. Ordnungsgemäße kryptografische Verfahren sind für den Schutz sensibler Daten, einschließlich Passwörtern, persönlichen Informationen und Finanzdaten, unerlässlich. Fehler in diesem Bereich können zur Preisgabe vertraulicher Daten, zu Datenschutzverletzungen oder zur unbefugten Datenmanipulation führen.
Zu den häufigsten Problemen gehören die Verwendung veralteter oder schwacher kryptografischer Algorithmen, die unsachgemäße Implementierung von Verschlüsselungsmethoden und das Versäumnis, sichere Schlüsselverwaltungspraktiken anzuwenden. Wenn eine Anwendung beispielsweise schwache Verschlüsselungsalgorithmen wie DES (Data Encryption Standard) verwendet oder ihre eigenen Verschlüsselungsroutinen ohne angemessene Sicherheitsüberprüfung implementiert, kann sie leicht gefährdet werden. Auch die unsachgemäße Verwaltung von Verschlüsselungsschlüsseln, z. B. die Wiederverwendung von Schlüsseln oder deren unsichere Speicherung, kann zu erheblichen Sicherheitslücken führen.
Beispiel
Nehmen wir eine Anwendung, die Benutzerpasswörter speichert. Wenn die Kennwörter mit einem veralteten oder schwachen Hash-Algorithmus wie MD5 gehasht werden, ist die Anwendung anfällig für Angriffe, bei denen ein Angreifer vorberechnete Tabellen (Rainbow-Tabellen) verwenden kann, um die Hash-Werte zu knacken und die tatsächlichen Kennwörter preiszugeben.
# Python example using weak MD5 hashing
import hashlib
def hash_password(password):
return hashlib.md5(password.encode()).hexdigest()
# Example usage
hashed_password = hash_password("user_password")
In diesem anfälligen Beispiel wird der MD5-Hash-Algorithmus verwendet, der aufgrund seiner Anfälligkeit für Kollisionsangriffe und vorberechnete Hash-Angriffe als unsicher gilt.
Maßnahme
# Python example using strong bcrypt hashing
import bcrypt
def hash_password(password):
return bcrypt.hashpw(password.encode(), bcrypt.gensalt())
# Example usage
hashed_password = hash_password("user_password")
In dieser sicheren Implementierung wird die bcrypt-Bibliothek verwendet, die so konzipiert ist, dass sie gegen Brute-Force-Angriffe resistent ist und integrierte Mechanismen zum Salting und Streching der Passwort-Hashes enthält. Dadurch wird sichergestellt, dass gehashte Kennwörter deutlich schwerer zu knacken sind, selbst wenn die gehashten Werte offengelegt werden.
A03:2021 - Injection
Erläuterung
Injektionsschwachstellen treten auf, wenn eine Anwendung Benutzereingaben unsachgemäß verarbeitet, so dass Angreifer bösartigen Code oder Befehle in den Abfrage- oder Ausführungskontext einer Anwendung einschleusen können. Dies kann zu schwerwiegenden Sicherheitsproblemen wie unbefugtem Datenzugriff, Datenverlust oder sogar zur vollständigen Kompromittierung des Systems führen. Injektionsangriffe sind unter anderem in Form von SQL-Injektion, XSS, Befehlsinjektion und XML-Injektion zu beobachten.
Eine SQL-Injektion liegt beispielsweise vor, wenn eine Anwendung es zulässt, dass Benutzereingaben SQL-Abfragen ohne ordnungsgemäße Validierung oder Escaping direkt manipulieren. Dadurch können Angreifer beliebige SQL-Befehle ausführen, Datenbankeinträge abrufen, ändern oder löschen oder sogar den gesamten Datenbankserver kompromittieren. Die Risiken einer Injektion werden durch die Validierung und Bereinigung von Benutzereingaben, die Verwendung von parametrisierten Abfragen und vorbereiteten Anweisungen verringert, um sicherzustellen, dass Benutzerdaten das beabsichtigte Verhalten von Befehlen nicht verändern können.
Beispiel
Stellen Sie sich eine Webanwendung vor, in der ein Benutzer durch die Eingabe eines Schlüsselworts nach Objekten suchen kann. Wenn die Anwendung die Benutzereingabe direkt in eine SQL-Abfrage einbezieht, ohne sie ordnungsgemäß zu bereinigen, kann sie für SQL-Injection anfällig sein.
# Python example using SQLite with direct user input in SQL query
import sqlite3
def search_items(keyword):
conn = sqlite3.connect('database.db')
cursor = conn.cursor()
query = f"SELECT * FROM items WHERE name LIKE '{keyword}'"
cursor.execute(query)
results = cursor.fetchall()
conn.close()
return results
# Example usage
items = search_items("item_name' OR '1'='1")
In diesem anfälligen Beispiel könnte ein Angreifer etwas wie “item_name” OR ‘1’=’1″ eingeben, um die SQL-Abfrage zu manipulieren und so möglicherweise die Authentifizierung zu umgehen oder alle Datensätze aus der Datenbank abzurufen.
Maßnahme
# Python example using SQLite with parameterized query
import sqlite3
def search_items(keyword):
conn = sqlite3.connect('database.db')
cursor = conn.cursor()
query = "SELECT * FROM items WHERE name LIKE ?"
cursor.execute(query, (f"%{keyword}%",))
results = cursor.fetchall()
conn.close()
return results
# Example usage
items = search_items("item_name")
Bei dieser sicheren Implementierung verwendet die SQL-Abfrage eine parametrisierte Abfrage mit Platzhaltern (?) und bezieht die Benutzereingaben über Parameter sicher ein. Dieser Ansatz verhindert die Ausführung unbeabsichtigter SQL-Befehle und schützt vor Injektionsangriffen, indem er sicherstellt, dass Benutzereingaben als Daten und nicht als ausführbarer Code behandelt werden.
A04:2021 - Insecure Design
Erläuterung
Der Begriff “unsicheres Design” bezieht sich auf Sicherheitsmängel, die durch schlechte oder unzureichende Designentscheidungen in einer Anwendung entstehen. Diese Schwachstellen sind oft die Folge davon, dass Sicherheitsaspekte nicht in den ursprünglichen Entwurf und die Architektur der Software einbezogen wurden. Im Gegensatz zu Implementierungsfehlern, die während der Kodierung auftreten, sind unsichere Designprobleme in der Art und Weise, wie eine Anwendung konzipiert und geplant wird, inhärent.
Zu den häufigen Problemen im Zusammenhang mit unsicherem Design gehören fehlende Eingabevalidierung, unzureichende Zugriffskontrollen, schlechte Datenverarbeitungspraktiken und die Nichtberücksichtigung bekannter Sicherheitsmuster und bewährter Verfahren. Der Umgang mit unsicherem Design erfordert einen umfassenden Ansatz, der die Modellierung von Bedrohungen, sichere Designprinzipien und die frühzeitige Integration von Sicherheitsmaßnahmen in den Entwicklungslebenszyklus umfasst. Dieser proaktive Ansatz trägt dazu bei, dass die Sicherheit von Anfang an in die Architektur und den Entwurf einer Anwendung integriert wird.
Beispiel
Stellen Sie sich eine Webanwendung vor, die es Benutzern ermöglicht, Feedback und Bewertungen abzugeben, aber keine angemessene Validierung oder Bereinigung von Eingabedaten vorsieht. Wenn das Design das Potenzial bösartiger Eingaben nicht berücksichtigt, könnten Angreifer diese Schwachstelle ausnutzen, um Angriffe wie Cross-Site-Scripting (XSS) oder SQL-Injection durchzuführen.
Stellen Sie sich eine Anwendung vor, in der Benutzer Kommentare direkt in ein Forum schreiben können, aber das Design enthält keine Mechanismen zur Validierung oder Bereinigung der Eingabedaten.
<!-- HTML form allowing users to submit comments -->
<form action="/submit_comment" method="POST">
<textarea name="comment"></textarea>
<button type="submit">Submit</button>
</form>
Bei diesem unsicheren Design lässt die Anwendung beliebige Eingaben zu, ohne sie zu validieren oder zu escapen, was zu XSS-Angriffen führen kann, bei denen ein Angreifer bösartige Skripte einspeisen kann.
Maßnahme
Um dem entgegenzuwirken, sollte der Entwurf Mechanismen zur Validierung und Bereinigung von Eingaben enthalten, die sicherstellen, dass alle von den Benutzern übermittelten Daten ordnungsgemäß verarbeitet und gefiltert werden.
# Python Flask example with input sanitization
from flask import Flask, request, render_template_string
from html import escape
app = Flask(__name__)
@app.route('/submit_comment', methods=['POST'])
def submit_comment():
comment = request.form['comment']
sanitized_comment = escape(comment) # Escapes HTML to prevent XSS
# Save the sanitized_comment to the database or display it
return "Comment submitted successfully"
if __name__ == '__main__':
app.run()
In diesem sicheren Design verwendet die Anwendung die Escape-Funktion, um die Eingabe vor der Verarbeitung zu bereinigen. Dadurch werden XSS-Angriffe verhindert, indem potenziell gefährliche Zeichen in ihre HTML-kodierten Entsprechungen umgewandelt werden, wodurch sichergestellt wird, dass Benutzereingaben nicht als Code ausgeführt werden können. Die Einbeziehung dieser Praktiken in die Entwurfsphase trägt dazu bei, die mit einer unsicheren Eingabeverarbeitung verbundenen Risiken zu verringern.
A05:2021 - Security Misconfiguration
Erläuterung
Von einer Sicherheitsfehlkonfiguration spricht man, wenn eine Anwendung oder ihre Umgebung nicht sicher konfiguriert ist, so dass sie anfällig für Angriffe ist. Diese Art von Schwachstelle ist weit verbreitet und kann durch unsachgemäße Konfigurationseinstellungen, Standardkonfigurationen, unvollständige Konfigurationen oder das Versäumnis, Software zu aktualisieren und zu patchen, entstehen. Falsche Sicherheitskonfigurationen können sensible Daten preisgeben, unbefugten Zugriff ermöglichen oder Angreifern erlauben, Schwachstellen im System auszunutzen.
Gängige Beispiele sind die Beibehaltung von Standard-Anmeldeinformationen, die Freigabe unnötiger Dienste, das Versäumnis, Dateiberechtigungen einzuschränken, oder die Nichtanwendung von Sicherheits-Patches. Die Behebung von Sicherheitsfehlkonfigurationen erfordert eine gründliche Überprüfung und Härtung der Konfigurationseinstellungen der Anwendung sowie regelmäßige Aktualisierungen und Überwachung, um sicherzustellen, dass bewährte Sicherheitsverfahren beibehalten werden.
Beispiel
Stellen Sie sich einen Webserver vor, der so konfiguriert ist, dass er das Auflisten von Verzeichnissen zulässt, wodurch der Inhalt von Verzeichnissen für Benutzer, die darauf zugreifen, sichtbar wird. Wenn in diesen Verzeichnissen sensible Dateien oder Konfigurationsdateien gespeichert sind, können Angreifer auf sie zugreifen.
Stellen Sie sich einen Webserver vor, der so konfiguriert ist, dass er das Auflisten von Verzeichnissen zulässt, wodurch der Inhalt von Verzeichnissen für Benutzer, die darauf zugreifen, offengelegt werden kann. Wenn sensible Dateien oder Konfigurationsdateien in diesen Verzeichnissen gespeichert sind, können Angreifer auf sie zugreifen.
In einer Apache-Server-Konfigurationsdatei (httpd.conf) könnte das Verzeichnis-Listing wie folgt aktiviert sein:
<Directory "/var/www/html">
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
Wenn Options Indexes aktiviert ist, kann jedes Verzeichnis innerhalb von /var/www/html aufgelistet werden, was möglicherweise sensible Dateien offenlegt.
Maßnahme
Um dies zu gewährleisten, sollte der Verzeichniseintrag deaktiviert werden:
<Directory "/var/www/html">
Options -Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
In dieser sicheren Konfiguration deaktiviert die Direktive Options -Indexes die Auflistung von Verzeichnissen, wodurch sichergestellt wird, dass Benutzer den Inhalt von Verzeichnissen nicht einsehen können. Dies trägt dazu bei, dass sensible Dateien nicht über den Webserver offengelegt werden können. Darüber hinaus sollten auch andere Sicherheitspraktiken wie die Aktualisierung von Software, das Entfernen ungenutzter Dienste und die Sicherung von Dateiberechtigungen Teil eines umfassenden Ansatzes zur Vermeidung von Sicherheitsfehlkonfigurationen sein.
A06:2021 - Vulnerable and Outdated Components
Erläuterung
Anfällige und veraltete Komponenten beziehen sich auf die Verwendung von Softwarebibliotheken, Frameworks und anderen Komponenten in einer Anwendung, die bekannte Sicherheitslücken aufweisen oder nicht mehr unterstützt werden. Diese Komponenten können erhebliche Risiken mit sich bringen, wenn sie nicht mit den neuesten Sicherheitspatches und -updates auf dem neuesten Stand gehalten werden. Wenn Anwendungen auf veraltete oder anfällige Komponenten angewiesen sind, erben sie die Sicherheitsschwächen dieser Komponenten und sind damit potenziell für Angriffe anfällig.
Zu den häufigsten Problemen gehören die Verwendung veralteter Versionen von Bibliotheken mit bekannten Schwachstellen, das Versäumnis, veraltete Frameworks zu aktualisieren, oder die Verwendung von Komponenten, die nicht mehr gepflegt werden. Zur ordnungsgemäßen Verwaltung von Software-Abhängigkeiten gehören die regelmäßige Aktualisierung von Komponenten, die Anwendung von Sicherheits-Patches und der Ersatz veralteter oder nicht mehr unterstützter Bibliotheken durch sichere Alternativen.
Beispiel
Stellen Sie sich eine Webanwendung vor, die eine veraltete Version einer beliebten JavaScript-Bibliothek, wie jQuery, verwendet. Wenn die verwendete Version bekannte Sicherheitsschwachstellen aufweist, könnten Angreifer diese Schwachstellen ausnutzen, um die Anwendung zu kompromittieren.
Angenommen, die Anwendung enthält die folgende jQuery-Bibliotheksversion, die veraltet ist und bekannte Sicherheitslücken enthält:
<!-- Including an outdated version of jQuery -->
<script src="https://code.jquery.com/jquery-1.12.4.min.js"></script>
Die Version 1.12.4 von jQuery weist mehrere Schwachstellen auf, die von Angreifern ausgenutzt werden können.
Maßnahme
Um dies zu beheben, sollten Sie auf eine neuere und unterstützte Version der Bibliothek aktualisieren:
<!-- Including an updated and secure version of jQuery -->
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
Version 3.6.0 enthält die neuesten Sicherheitspatches und Verbesserungen, die das Risiko von Sicherheitslücken verringern. Darüber hinaus sind die regelmäßige Überwachung auf neue Versionen, das Abonnieren von Sicherheitshinweisen und der Einsatz von Tools zur Verwaltung und Aktualisierung von Abhängigkeiten wichtige Praktiken zur Aufrechterhaltung der Sicherheit der in Ihrer Anwendung verwendeten Komponenten.
A07:2021 - Identification and Authentication Failures
Erläuterung
Identifizierungs- und Authentifizierungsfehler treten auf, wenn eine Anwendung die Identität der Benutzer nicht ordnungsgemäß überprüft oder die Benutzeranmeldeinformationen nicht sicher behandelt. Diese Fehler können zu unberechtigtem Zugriff führen, bei dem sich Angreifer als Benutzer ausgeben oder die Kontrolle über Konten ohne gültige Anmeldedaten erlangen können. Zu den häufigsten Problemen gehören schwache Kennwortrichtlinien, unsachgemäße Sitzungsverwaltung, unsichere Kennwortspeicherung und mangelhafte Authentifizierungsmechanismen.
Eine ordnungsgemäße Identifizierung und Authentifizierung ist entscheidend, um sicherzustellen, dass nur autorisierte Benutzer auf sensible Ressourcen zugreifen und privilegierte Aktionen durchführen können. Dies beinhaltet die Implementierung starker Passwortrichtlinien, die Verwendung sicherer Passwort-Hashing-Algorithmen, die Gewährleistung einer robusten Sitzungsverwaltung und die Verwendung von Multi-Faktor-Authentifizierung (MFA) zur Verbesserung der Sicherheit.
Beispiel
Stellen Sie sich eine Webanwendung vor, die einen einfachen Authentifizierungsmechanismus mit schwachen Kennwortrichtlinien und unsachgemäßer Sitzungsverwaltung verwendet. Wenn die Anwendung beispielsweise Passwörter im Klartext speichert und vorhersehbare Sitzungskennungen verwendet, wird sie anfällig für verschiedene Angriffe.
# Python example of insecure password storage and session management
import hashlib
import random
import string
def hash_password(password):
return hashlib.md5(password.encode()).hexdigest() # Weak hashing algorithm
def generate_session_id():
return ''.join(random.choices(string.ascii_letters + string.digits, k=8)) # Predictable session IDs
# Example usage
stored_password_hash = hash_password("user_password")
session_id = generate_session_id()
In diesem anfälligen Beispiel wird MD5 zum Hashing von Kennwörtern verwendet, was aufgrund seiner Anfälligkeit für Kollisionen und vorberechnete Hash-Angriffe unsicher ist. Außerdem werden Sitzungs-IDs nach vorhersehbaren Mustern generiert, was sie anfällig für Session Fixation oder Brute-Force-Angriffe macht.
Maßnahme
# Python example of secure password storage and session management
import bcrypt
import secrets
def hash_password(password):
return bcrypt.hashpw(password.encode(), bcrypt.gensalt()) # Strong hashing algorithm
def generate_session_id():
return secrets.token_urlsafe(16) # Cryptographically secure session IDs
# Example usage
stored_password_hash = hash_password("user_password")
session_id = generate_session_id()
In dieser sicheren Implementierung wird bcrypt zum Hashing von Passwörtern verwendet, was einen robusten Schutz gegen Brute-Force- und Rainbow-Table-Angriffe bietet. Die secrets-Bibliothek wird verwendet, um kryptografisch sichere Sitzungs-IDs zu erzeugen und so die Sicherheit der Sitzungsverwaltung zu verbessern. Diese Verfahren tragen dazu bei, dass die Authentifizierungsmechanismen robust und widerstandsfähig gegen gängige Angriffe sind.
A08:2021 - Software and Data Integrity Failures
Erläuterung
Software- und Datenintegritätsfehler treten auf, wenn Anwendungen oder Systeme nicht in der Lage sind, die Integrität ihrer Software und Daten vor unbefugten Änderungen zu schützen. Diese Fehler können zu veränderter oder beschädigter Software und Daten führen, was die Funktionalität, Sicherheit und Zuverlässigkeit einer Anwendung beeinträchtigen kann. Die Integrität von Software und Daten ist von entscheidender Bedeutung für die Aufrechterhaltung des Vertrauens und die Gewährleistung, dass Systeme wie beabsichtigt funktionieren, ohne von böswilligen Akteuren gestört zu werden.
Zu den häufigsten Problemen gehören die unsachgemäße Validierung von Software-Updates, der unzureichende Schutz kritischer Daten und unzureichende Prüfmechanismen für die Datenintegrität. Wenn eine Anwendung beispielsweise Updates zulässt, ohne deren Authentizität oder Integrität zu überprüfen, könnten Angreifer bösartigen Code in Software-Updates einschleusen oder Anwendungsdaten manipulieren. Zur Sicherstellung der Software- und Datenintegrität müssen robuste Validierungs-, Verschlüsselungs- und Überprüfungsmechanismen zum Schutz vor nicht autorisierten Änderungen implementiert werden.
Beispiel
Nehmen wir eine Webanwendung, die Updates von einem Server herunterlädt. Wenn die Anwendung die Integrität des heruntergeladenen Updates nicht überprüft, könnte ein Angreifer ein bösartiges Update ersetzen und die Anwendung kompromittieren.
# Python example of insecure update process
import requests
def download_update(url):
response = requests.get(url)
with open('update.zip', 'wb') as f:
f.write(response.content)
# No integrity check is performed
# Example usage
download_update('http://example.com/latest_update.zip')
In diesem anfälligen Beispiel lädt die Anwendung eine Aktualisierungsdatei herunter, ohne ihre Authentizität oder Integrität zu überprüfen, was sie anfällig für Angriffe macht, bei denen ein Angreifer die Aktualisierung durch eine bösartige Version ersetzen könnte.
Maßnahme
# Python example of secure update process with integrity check
import requests
import hashlib
def verify_file_integrity(file_path, expected_hash):
sha256_hash = hashlib.sha256()
with open(file_path, 'rb') as f:
for chunk in iter(lambda: f.read(4096), b""):
sha256_hash.update(chunk)
return sha256_hash.hexdigest() == expected_hash
def download_update(url, expected_hash):
response = requests.get(url)
with open('update.zip', 'wb') as f:
f.write(response.content)
if not verify_file_integrity('update.zip', expected_hash):
raise ValueError("File integrity check failed")
# Example usage
expected_hash = 'abcdef1234567890...' # Precomputed SHA-256 hash of the expected update file
download_update('http://example.com/latest_update.zip', expected_hash)
Bei dieser sicheren Implementierung prüft die Anwendung nach dem Herunterladen der Aktualisierungsdatei deren Integrität, indem sie ihren Hash mit einem vorberechneten SHA-256-Hash vergleicht. Dadurch wird sichergestellt, dass die Datei während des Herunterladens nicht manipuliert wurde, was vor potenziell bösartigen Updates schützt. Durch die Integration solcher Überprüfungsmechanismen können Anwendungen die Integrität sowohl von Software-Updates als auch von Daten schützen.
A09:2021 - Security Logging and Monitoring Failures
Erläuterung
Fehler bei der Sicherheitsprotokollierung und -überwachung treten auf, wenn eine Anwendung oder ein System nicht über angemessene Mechanismen zur Protokollierung sicherheitsrelevanter Ereignisse und zur Überwachung verdächtiger Aktivitäten verfügt. Eine wirksame Protokollierung und Überwachung ist unerlässlich, um Sicherheitsvorfälle zu erkennen und darauf zu reagieren, die Art von Angriffen zu verstehen und wertvolle forensische Informationen zu erhalten. Ohne eine ordnungsgemäße Protokollierung und Überwachung kann es Unternehmen nicht gelingen, Sicherheitsverletzungen zu erkennen, kompromittierte Systeme zu identifizieren oder zu verstehen, wie ein Angriff abgelaufen ist.
Zu den häufigsten Problemen gehören die unzureichende Protokollierung kritischer Ereignisse wie Authentifizierungsversuche, fehlgeschlagene Anmeldungen oder Änderungen an sensiblen Daten sowie das Fehlen von Überwachungstools oder Warnmeldungen bei verdächtigem Verhalten. Wenn die Protokolle nicht ordnungsgemäß geschützt sind, könnten Angreifer sie zudem manipulieren oder löschen, um ihre Spuren zu verwischen. Um diese Mängel zu beheben, müssen umfassende Protokollierungspraktiken eingeführt, die Protokolle geschützt und regelmäßig überprüft sowie wirksame Überwachungs- und Warnsysteme eingerichtet werden.
Beispiel
Nehmen wir eine Webanwendung, die fehlgeschlagene Anmeldeversuche nicht protokolliert. Wenn ein Angreifer versucht, Benutzerpasswörter durch Brute-Force-Angriffe zu erraten, gibt es keine Aufzeichnungen über diese Versuche, was die Erkennung und Reaktion auf den Angriff erschwert.
# Python example without logging failed login attempts
def authenticate_user(username, password):
user = get_user_from_database(username)
if user and user.verify_password(password):
return "Authentication successful"
return "Authentication failed"
# Example usage
result = authenticate_user("admin", "password123")
In diesem Beispiel werden fehlgeschlagene Anmeldeversuche nicht protokolliert, so dass keine Aufzeichnungen über potenziell bösartige Aktivitäten vorliegen.
Maßnahme
# Python example with logging of failed login attempts
import logging
# Configure logging
logging.basicConfig(filename='auth.log', level=logging.INFO)
def authenticate_user(username, password):
user = get_user_from_database(username)
if user and user.verify_password(password):
logging.info(f"User {username} authenticated successfully")
return "Authentication successful"
logging.warning(f"Failed login attempt for user {username}")
return "Authentication failed"
# Example usage
result = authenticate_user("admin", "password123")
Bei dieser sicheren Implementierung werden fehlgeschlagene Anmeldeversuche mit einer Warnstufe in einer auth.log-Datei protokolliert. Dies ermöglicht die Überwachung der Authentifizierungsaktivitäten und hilft dabei, potenzielle Sicherheitsvorfälle zu erkennen und darauf zu reagieren. Durch eine detaillierte und umsetzbare Protokollierung und die Einführung von Überwachungspraktiken können Unternehmen ihre Systeme besser schützen und effektiv auf Sicherheitsbedrohungen reagieren.
A10:2021 - Server-Side Request Forgery (SSRF)
Erläuterung
Server-Side Request Forgery (SSRF) ist eine Schwachstelle, die auftritt, wenn ein Angreifer in der Lage ist, von der Server-Seite einer Anwendung aus Anfragen an interne oder externe Ressourcen zu stellen, auf die die Anwendung nicht zugreifen soll. Dies kann zu unbefugtem Zugriff auf interne Systeme, zur Preisgabe sensibler Daten oder zur Interaktion mit Ressourcen führen, die eigentlich eingeschränkt sein sollten. SSRF-Schwachstellen entstehen häufig durch die unsachgemäße Behandlung von benutzergesteuerten Eingaben, wenn Anfragen im Namen des Servers gestellt werden.
Häufige Szenarien, in denen SSRF ausgenutzt werden kann, sind z. B., wenn eine Anwendung es Benutzern erlaubt, URLs oder Endpunkte für den Abruf von Daten anzugeben, diese Anfragen aber nicht validiert oder beschränkt. Angreifer können SSRF nutzen, um auf interne Dienste wie Datenbanken, Metadatendienste oder lokale Endpunkte zuzugreifen, die nach außen nicht zugänglich sind, was zu Datenlecks oder weiteren Angriffen innerhalb des internen Netzwerks führen kann.
Beispiel
Nehmen wir eine Webanwendung, die es Benutzern ermöglicht, Bilder von einer von ihnen angegebenen URL abzurufen. Wenn die Anwendung diese URLs nicht ordnungsgemäß validiert oder einschränkt, könnte ein Angreifer dies ausnutzen, um interne Anfragen zu stellen.
# Python example of a vulnerable SSRF implementation
import requests
def fetch_image(url):
response = requests.get(url)
if response.status_code == 200:
with open('image.jpg', 'wb') as f:
f.write(response.content)
else:
print("Failed to fetch image")
# Example usage
fetch_image("http://internal-service.local/secret-data")
In diesem Beispiel ruft die Anwendung ein Bild von einer vom Benutzer angegebenen URL ab, ohne die URL zu validieren oder einzuschränken. Ein Angreifer könnte eine interne URL angeben, auf die der Server der Anwendung zugreifen kann, wodurch möglicherweise sensible Daten von internen Diensten durchsickern.
Maßnahme
# Python example of a secure SSRF implementation with URL validation
import requests
from urllib.parse import urlparse
ALLOWED_DOMAINS = ['example.com']
def is_allowed_url(url):
parsed_url = urlparse(url)
return parsed_url.hostname in ALLOWED_DOMAINS
def fetch_image(url):
if not is_allowed_url(url):
raise ValueError("URL is not allowed")
response = requests.get(url)
if response.status_code == 200:
with open('image.jpg', 'wb') as f:
f.write(response.content)
else:
print("Failed to fetch image")
# Example usage
fetch_image("https://example.com/some-image.jpg")
In dieser sicheren Implementierung prüft die Funktion is_allowed_url, ob die Domäne der angegebenen URL in einer zulässigen Liste enthalten ist, bevor die Anfrage gestellt wird. Dadurch wird verhindert, dass der Server Anfragen an interne oder nicht autorisierte Endpunkte stellt, wodurch das Risiko von SSRF-Angriffen gemindert wird. Durch die Implementierung strenger Validierungs- und Zugriffskontrollen für benutzergesteuerte URLs können Sie die Wahrscheinlichkeit von SSRF-Schwachstellen verringern und interne Ressourcen vor unberechtigtem Zugriff schützen.
Zusammenfassung
Das Verständnis der OWASP Top 10 ist eine wichtige Grundlage für die Entwicklung sicherer Systeme. Durch die Kenntnis dieser Top-Schwachstellen kann jeder, der diesen Artikel liest, Schritte unternehmen, um das Risiko eines erfolgreichen Angriffs zu verringern. Die OWASP Top 10 stellt jedoch nur einen Bruchteil der potenziellen Schwachstellen dar; sie garantiert keinen vollständigen Schutz vor Angriffen. Absolute Sicherheit ist unerreichbar, aber die Minimierung des Risikos ist unerlässlich. Tools wie Penetrationstests sind wertvoll, um Schwachstellen und Anfälligkeiten in Systemen zu identifizieren, und auch die Teilnahme an Bug Bounty-Programmen kann eine nützliche Ergänzung sein. Jedes Unternehmen muss entscheiden, wie es seine Systeme proaktiv sichern will. Sicherheitsrisiken zu ignorieren und nichts zu tun, ist keine Option. Ein erfolgreicher Angriff ist nur eine Frage der Zeit.
Weiterführende Links
- https://cyberphinix.de/de/blog/hacken-lernen-fur-anfanger/
- https://cyberphinix.de/de/blog/sql-injektion-verstehen-ausnutzen-und-vorbeugen/
- https://cyberphinix.de/de/blog/xss-cross-site-scripting-angriff-ist-die-beste-verteidigung/
- https://cyberphinix.de/de/blog/cybersecurity-%e2%89%a0-informationssicherheit-%e2%89%a0-it-sicherheit/
- https://cyberphinix.de/de/blog/cve-ein-leitfaden-fuer-haeufige-schwachstellen-und-gefaehrdungen/
- https://cyberphinix.de/de/blog/zero-day-exploit-erklaerung-und-vorbeugung/
- https://cyberphinix.de/de/blog/effektive-it-sicherheitsdienstleistungen-die-rolle-des-penetration-testing/
- https://cyberphinix.de/de/blog/open-redirects-ein-einfallstor-fur-cyberkriminelle/
- https://cyberphinix.de/de/blog/https-wirklich-sicher-finde-es-heraus/
- https://cyberphinix.de/de/blog/top-8-bug-bounty-plattformen/
- https://cyberphinix.de/de/blog/brute-force-verstehen-gefahren-erkennen-und-abwehren/
- https://cyberphinix.de/de/blog/schritt-fuer-schritt-anleitung-xsstrike-tutorial/
- https://cyberphinix.de/de/blog/das-ultimative-nmap-cheat-sheet/
