Sicherheitslücken in Webanwendungen gibt es viele, aber einige fallen erst auf, wenn sie aktiv ausgenutzt werden. Open Redirects sind genau so ein Fall. Diese Schwachstelle wird häufig unterschätzt, kann aber massive Auswirkungen haben. In diesem Artikel erkläre ich dir, was Open Redirects sind, wie sie in echten Szenarien ausgenutzt werden und wie du deine Webanwendungen davor schützen kannst.
Was ist ein Open Redirect?
Ein Open Redirect tritt auf, wenn eine Anwendung es erlaubt, Benutzer auf eine externe URL weiterzuleiten, ohne dabei zu prüfen, ob die Ziel-URL vertrauenswürdig ist. Oft passiert das, weil die Ziel-URL als Parameter in der Anfrage übergeben wird.
Beispiel:
<a href="https://example.com/redirect?url=https://evilpage.com">Click Here</a>Falls die Anwendung die URL nicht validiert, wird der Nutzer auf eine bösartige Seite umgeleitet. Diese Technik wird oft für Phishing-Angriffe oder Session-Hijacking genutzt.
Praktische Angriffsszenarien
1. Phishing mit legitimen Domains
Ein Angreifer kann eine seriös wirkende URL verwenden, um das Opfer auf eine betrügerische Seite umzuleiten. Beispiel:
https://trusted-bank.com/login?redirect=https://hacker-site.com/fake-loginHier denkt der Nutzer, dass er sich bei seiner Bank anmeldet, landet aber auf einer gefälschten Login-Seite.
2. Open Redirect als Teil einer XSS-Kette
Falls eine Webseite anfällig für Open Redirects ist, kann ein Angreifer dies in Kombination mit Cross-Site Scripting (XSS) nutzen, um schädliche Skripte auszuführen.
3. Malware-Downloads
Open Redirects können Nutzer unbemerkt auf eine Seite führen, die automatisch Malware herunterlädt oder Exploits enthält.
4. Open Redirect und OAuth-Bypassing
Einige Webanwendungen setzen Open Redirects in Authentifizierungsprozessen ein. Beispielsweise könnte eine OAuth-Implementierung folgende Umleitung enthalten:
https://example.com/oauth?redirect=https://website.com/dashboardWenn Angreifer die Umleitungs-URL manipulieren können, könnte dies dazu führen, dass Benutzer nach der Authentifizierung auf eine gefälschte Seite umgeleitet werden, wo ihre Sitzungsinformationen abgegriffen werden.
5. Kombination mit CSRF (Cross-Site Request Forgery)
In Kombination mit CSRF-Angriffen kann ein Open Redirect dazu genutzt werden, Benutzer unbemerkt auf eine bösartige Seite zu lenken, während sie gleichzeitig eine schädliche Aktion auf einer anderen Seite ausführen.
Wie kann man sich vor Open Redirects schützen?
1. Whitelisting von Weiterleitungszielen
Erlaube nur bekannte, vertrauenswürdige Domains als Weiterleitungsziele. Beispiel in PHP:
$allowed_hosts = ['example.com', 'mytrusteddomain.com'];
$parsed_url = parse_url($_GET['url']);
if (!in_array($parsed_url['host'], $allowed_hosts)) {
die("Ungültige Weiterleitung");
}
header("Location: " . $_GET['url']);2. Verwenden von relativen URLs
Falls eine interne Weiterleitung erforderlich ist, sollte nur eine relative URL verwendet werden:
header("Location: /dashboard");3. Nutzerwarnungen
Falls eine externe Weiterleitung unvermeidbar ist, sollte der Nutzer gewarnt werden:
echo "You are getting forwarded to: " . htmlspecialchars($_GET['url']);4. Absicherung in verschiedenen Programmiersprachen
Java
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.List;
public class OpenRedirectProtection {
private static final List<String> ALLOWED_DOMAINS = Arrays.asList("example.com", "trusted.com");
public static boolean isValidRedirect(String url) {
try {
URI uri = new URI(url);
return ALLOWED_DOMAINS.contains(uri.getHost());
} catch (URISyntaxException e) {
return false;
}
}
public static void main(String[] args) {
String userUrl = "https://example.com/dashboard";
if (isValidRedirect(userUrl)) {
System.out.println("Weiterleitung erlaubt");
} else {
System.out.println("Ungültige Weiterleitung blockiert");
}
}
}JavaScript
const allowedDomains = ['example.com', 'trusted.com'];
function isValidRedirect(url) {
try {
const parsedUrl = new URL(url);
return allowedDomains.includes(parsedUrl.hostname);
} catch (e) {
return false;
}
}
const userRedirect = 'https://malicious-site.com';
if (isValidRedirect(userRedirect)) {
window.location.href = userRedirect;
} else {
alert('Ungültige Weiterleitung blockiert');
}PHP
function isValidRedirect($url) {
$allowed_hosts = ['example.com', 'trusted.com'];
$parsed_url = parse_url($url);
return isset($parsed_url['host']) && in_array($parsed_url['host'], $allowed_hosts);
}
$user_url = $_GET['url'] ?? '';
if (isValidRedirect($user_url)) {
header("Location: $user_url");
exit;
} else {
die("Ungültige Weiterleitung blockiert");
}
Welche Tools helfen, Open Redirects zu erkennen?
Es gibt verschiedene Tools, die dabei helfen können, Schwachstellen wie Open Redirects in einer Webanwendung zu finden:
1. Burp Suite
Burp Suite ist ein leistungsstarkes Tool für Sicherheitstests. Es kann HTTP-Anfragen abfangen und manipulieren, um Schwachstellen wie Open Redirects zu entdecken.
2. OWASP ZAP
OWASP Zed Attack Proxy (ZAP) ist ein Open-Source-Sicherheitsscanner, der automatisch auf Open Redirects testet und sie in Berichten dokumentiert.
3. Google Dorks
Mit gezielten Suchanfragen (Google Dorks) kann überprüft werden, ob verdächtige Weiterleitungen öffentlich indexiert sind.
Beispiel:
site:example.com inurl:redirect=4. Nikto
Nikto ist ein Web-Scanner, der bekannte Sicherheitslücken, einschließlich unsicherer Weiterleitungen, erkennen kann.
5. Manual Testing mit DevTools
Oft lassen sich Open Redirects auch durch manuelles Testen in den Entwicklertools des Browsers erkennen, indem Weiterleitungs-URLs manipuliert und die Reaktionen der Anwendung überprüft werden.
Fazit
Open Redirects sind eine unterschätzte, aber gefährliche Schwachstelle. Durch Whitelisting, relative URLs, Nutzerwarnungen, Logging und Monitoring kannst du deine Anwendung effektiv absichern. Falls du Entwickler bist, prüfe deine Anwendung mit den genannten Tools auf diese Schwachstelle, bevor es ein Angreifer tut!
