┌─────────────────────────────────────────────┐
│         COMPOSANTS BURP SUITE               │
├─────────────────────────────────────────────┤
│                                             │
│  PROXY                                      │
│  └─> Intercepte et modifie le trafic HTTP  │
│                                             │
│  TARGET                                     │
│  └─> Cartographie du site cible            │
│                                             │
│  SPIDER/CRAWLER                             │
│  └─> Découverte automatique de contenu     │
│                                             │
│  SCANNER (Pro)                              │
│  └─> Détection automatique de vulns        │
│                                             │
│  INTRUDER                                   │
│  └─> Attaques automatisées (fuzzing, etc.) │
│                                             │
│  REPEATER                                   │
│  └─> Modification et renvoi de requêtes    │
│                                             │
│  SEQUENCER                                  │
│  └─> Analyse de la qualité des tokens      │
│                                             │
│  DECODER                                    │
│  └─> Encodage/décodage de données          │
│                                             │
│  COMPARER                                   │
│  └─> Comparaison de réponses HTTP          │
│                                             │
│  EXTENSIONS                                 │
│  └─> Plugins additionnels (BApp Store)     │
│                                             │
└─────────────────────────────────────────────┘

1. CONFIGURATION DU PROXY
   └─> Configurer navigateur pour utiliser Burp

2. NAVIGATION ET INTERCEPTION
   └─> Explorer l'application cible

3. CARTOGRAPHIE
   └─> Site map complet dans Target

4. ANALYSE MANUELLE
   └─> Repeater pour tester des payloads

5. ATTAQUES AUTOMATISÉES
   └─> Intruder pour fuzzing/brute force

6. SCAN DE VULNÉRABILITÉS (Pro)
   └─> Scanner automatique

7. EXPLOITATION
   └─> Confirmer et exploiter les vulnérabilités

8. REPORTING
   └─> Générer rapport avec preuves

# Vérifier Java (requis JDK 11+)
java -version

# Installer Java si nécessaire (Ubuntu/Debian)
sudo apt update
sudo apt install openjdk-17-jre

# macOS
brew install openjdk@17

# Windows : télécharger depuis adoptium.net

# Télécharger depuis https://portswigger.net/burp/releases

# Linux
wget https://portswigger.net/burp/releases/download?product=community&type=Linux -O burpsuite_community.sh
chmod +x burpsuite_community.sh
./burpsuite_community.sh

# macOS
# Télécharger le .dmg et installer normalement

# Lancer Burp
java -jar burpsuite_community.jar

# Burp est préinstallé sur Kali
burpsuite

# Ou depuis le menu Applications > Web Application Analysis > burpsuite

# Lancer Burp Suite
java -jar burpsuite_community.jar

# Options de ligne de commande utiles
java -jar -Xmx4g burpsuite_community.jar  # Allouer 4GB de RAM
java -jar burpsuite_community.jar --config-file=myconfig.json

1. Aller dans "Proxy" > "Options"
2. Par défaut, écoute sur 127.0.0.1:8080
3. Vérifier que "Intercept is on" dans l'onglet "Intercept"

Proxy Listeners:
- Add
- Bind to address: 127.0.0.1
- Bind to port: 8080
- Request handling: par défaut

1. Installer FoxyProxy Standard
2. Ajouter un proxy:
   - Title: Burp Suite
   - Type: HTTP
   - Hostname: 127.0.0.1
   - Port: 8080
3. Activer/désactiver rapidement le proxy

# Linux/macOS
google-chrome --proxy-server="127.0.0.1:8080"

# Ou utiliser l'extension SwitchyOmega

1. Démarrer Burp
2. Configurer le proxy du navigateur
3. Naviguer vers http://burpsuite (ou http://127.0.0.1:8080)
4. Cliquer sur "CA Certificate" pour télécharger
5. Sauvegarder cacert.der

1. Paramètres > Vie privée et sécurité
2. Certificats > Afficher les certificats
3. Autorités > Importer
4. Sélectionner cacert.der
5. Cocher "Faire confiance à cette AC pour identifier des sites web"
6. OK

# Convertir en format PEM
openssl x509 -inform DER -in cacert.der -out burp-ca.crt

# Ubuntu/Debian
sudo mkdir -p /usr/local/share/ca-certificates/
sudo cp burp-ca.crt /usr/local/share/ca-certificates/
sudo update-ca-certificates

# Chrome utilise les certificats système

1. Double-cliquer sur cacert.der
2. Ajouter au Trousseau "Connexion"
3. Double-cliquer sur "PortSwigger CA"
4. Développer "Trust"
5. "When using this certificate": "Always Trust"

1. Double-cliquer sur cacert.der
2. Install Certificate
3. Store Location: Current User
4. Place in store: Trusted Root Certification Authorities
5. Finish

1. Naviguer vers https://google.com
2. Le trafic HTTPS devrait apparaître dans Burp
3. Pas d'avertissement SSL dans le navigateur

Proxy > Options > Intercept Client Requests
Décocher "Intercept is on" par défaut si vous voulez browse normalement

# Créer un script de lancement
nano ~/burp.sh

#!/bin/bash
java -jar -Xmx4g /path/to/burpsuite_community.jar

chmod +x ~/burp.sh

Target > Scope
Add: ^https?://target\.example\.com/.*$
Options > Cocher "Spider only in-scope items"

Proxy > Options > Miscellaneous
Décocher des options si problèmes de performance

# Sauvegarder un projet
Project > Save copy
File > Save project as

# Charger configuration
Burp > Project options > Load project options

┌────────────────────────────────────────────────┐
│  Dashboard | Target | Proxy | Intruder | ...  │  ← Onglets principaux
├────────────────────────────────────────────────┤
│                                                │
│  ┌─────────────────┐  ┌───────────────────┐   │
│  │   Site Map      │  │   HTTP History    │   │
│  │                 │  │                   │   │
│  │  Target tree    │  │   Request/Response│   │
│  │  view           │  │   panels          │   │
│  └─────────────────┘  └───────────────────┘   │
│                                                │
└────────────────────────────────────────────────┘

- Vue d'ensemble du projet
- Tâches de scan en cours
- Statistiques des vulnérabilités trouvées
- Graphiques et métriques

- Site map (arborescence du site)
- Scope definition (périmètre de test)
- Issue activity (vulnérabilités trouvées)

- Intercept (interception des requêtes)
- HTTP history (historique complet)
- WebSockets history
- Options (configuration du proxy)

- Positions (définir les points d'injection)
- Payloads (listes de valeurs à tester)
- Options (configuration de l'attaque)
- Results (résultats des attaques)

- Envoi manuel de requêtes
- Modification à la volée
- Comparaison de réponses

- Analyse de tokens de session
- Tests statistiques de randomness

- Encodage/décodage de données
- Multiples formats supportés

- Comparaison de 2+ requêtes/réponses
- Diff visuel

- Gestion des extensions
- BApp Store
- APIs

Ctrl/Cmd + Shift + I    : Toggle intercept on/off
Ctrl/Cmd + R            : Envoyer au Repeater
Ctrl/Cmd + I            : Envoyer à l'Intruder
Ctrl/Cmd + Shift + B    : Envoyer au Spider (Pro)
Ctrl/Cmd + Shift + A    : Envoyer au Scanner (Pro)

Dans Repeater:
Ctrl/Cmd + Space        : Envoyer la requête
Ctrl/Cmd + U            : URL-encoder la sélection

Recherche:
Ctrl/Cmd + F            : Rechercher

Click droit sur un item:
- Spider this branch
- Scan this branch (Pro)
- Add to scope
- Delete from site map
- Compare site maps

User options > Display
- Font size
- Character sets
- HTTP message display
- Theme (Light/Dark dans versions récentes)

Proxy > HTTP history > Filter
- Show only in-scope items
- Hide items without responses
- Filter by MIME type
- Filter by status code
- Filter by search term

Click droit dans HTTP history ou Site map > Search
- Regular expressions
- Case sensitive
- Negative search

Indicateur en haut à droite:
- Orange: Intercept is ON
- Gray: Intercept is OFF

Cliquer pour toggle rapidement

1. Proxy > Intercept
2. "Intercept is on" (bouton orange)
3. Naviguer dans le navigateur
4. Les requêtes apparaissent dans Burp

Forward         : Envoyer la requête sans modification
Drop            : Abandonner la requête
Action          : Menu avec options avancées
  - Send to Repeater
  - Send to Intruder
  - Do intercept > Response to this request

Requête interceptée:
GET /api/user/profile HTTP/1.1
Host: example.com
Cookie: session=abc123
User-Agent: Mozilla/5.0

Modification:
GET /api/user/profile?id=2 HTTP/1.1
Host: example.com
Cookie: session=abc123
User-Agent: Burp/1.0

Forward

1. Intercepter une requête
2. Action > Do intercept > Response to this request
3. Forward la requête
4. La réponse apparaît pour modification

Réponse originale:
HTTP/1.1 200 OK
Content-Type: text/html

<script>var isAdmin = false;</script>

Modification:
HTTP/1.1 200 OK
Content-Type: text/html

<script>var isAdmin = true;</script>

Proxy > Options > Intercept Client Requests

Exemples de règles:
- And URL Is in target scope
- And Protocol Is https
- And Method Is POST
- And File extension Is in [php, asp, jsp]
- And Request Was intercepted

Intercept Server Responses:
- Intercept responses based on request rules
- Or Content-Type header Contains text/html

Proxy > HTTP history

Colonnes affichées:
- # : Numéro de requête
- Host : Domaine
- Method : GET, POST, etc.
- URL : Chemin
- Params : Présence de paramètres
- Edited : Modifié manuellement
- Status : Code HTTP
- Length : Taille réponse
- MIME type : Type de contenu
- Extension : Extension du fichier
- Title : Titre de la page
- Comment : Annotation
- TLS : Oui/Non

Filter bar en haut:
- Filter by search term
- Show only: in-scope, parameterized, edited, etc.
- Filter by MIME type: HTML, Script, CSS, etc.
- Filter by status code: 2xx, 3xx, 4xx, 5xx

Click droit sur une requête:
- Add comment
- Highlight (couleurs)

Proxy > WebSockets history

Intercepter WebSocket messages:
Proxy > Options > Intercept WebSocket Messages
- Client to server
- Server to client

Proxy > Options > Match and Replace

Exemples:
Type: Request header
Match: User-Agent: .*
Replace: User-Agent: Burp Suite Scanner
Regex: Yes

Type: Request header
Match: ^Cookie:.*
Replace: (vide pour supprimer)

Type: Response body
Match: <title>(.*)</title>
Replace: <title>HACKED</title>
Regex: Yes

Proxy > Options > TLS

Options:
- Use custom protocols and ciphers
- Disable Java SSL session resume
- Negotiate TLS 1.3

Proxy > Options > Hostname Resolution

Rediriger un domaine vers une IP spécifique:
Host: example.com
IP: 192.168.1.100

Proxy > Options > Miscellaneous

Network timeout: 120 seconds (défaut)

1. Désactiver JavaScript dans le navigateur
2. Ou intercepter la requête avec Burp
3. Modifier les valeurs après validation côté client

Exemple:
<input type="hidden" name="price" value="100">

Intercepter POST:
price=100&quantity=1

Modifier:
price=1&quantity=1

Forward

Requête normale:
GET /api/document/123 HTTP/1.1

Intercepter et modifier:
GET /api/document/124 HTTP/1.1
GET /api/document/125 HTTP/1.1

Observer si accès non autorisé

1. Se connecter avec User A
2. Copier le cookie de session
3. Ouvrir un autre navigateur
4. Intercepter une requête
5. Remplacer le cookie par celui de User A
6. Vérifier si la session est valide

Target > Site Map

Vue arborescente:
└── https://example.com
    ├── /
    ├── /login
    ├── /api
    │   ├── /users
    │   └── /products
    ├── /admin
    └── /static
        ├── /js
        └── /css

Noir  : Non visité/découvert automatiquement
Gris  : Pas de réponse ou erreur
Vert  : 2xx Success
Orange: 3xx Redirect
Rouge : 4xx Client Error / 5xx Server Error

Click droit pour highlight ou add comment

Filter bar:
- Show only in-scope items
- Show only requested items
- Hide not found (404)
- Hide empty folders

Target > Scope

Include in scope:
Protocol: https
Host: example.com
File: ^/.*

Regex examples:
^https?://example\.com/.*$
^https?://.*\.example\.com/.*$
^https?://example\.com/(api|admin)/.*$

Suite options > Scope
Cocher:
- Use advanced scope control
- Spider only in-scope items
- Only show in-scope items in Proxy history

Avantages:
- Focus sur la cible
- Éviter les domaines tiers (CDN, analytics)
- Réduire le bruit

Click droit dans Proxy history ou Site map:
- Add to scope

Ou dans un item intercepté:
Action > Add to scope

Target > Issue activity

Liste des vulnérabilités trouvées:
- Severity: High, Medium, Low, Info
- Issue type: SQL Injection, XSS, etc.
- Path: URL affectée
- Status: New, Fixed, False positive

Click sur une issue pour voir:
- Description détaillée
- Remediation advice
- Request/Response proofs
- References

Zones à privilégier:
- /admin, /manager, /console
- /api, /v1, /graphql
- Paramètres dans URLs
- Forms (POST requests)
- Upload functionality
- Authentication endpoints

Click droit sur un domaine:
- Save selected items
  - Select all URLs
  - Format: XML, text

Utile pour:
- Documentation
- Reporting
- Import dans autres outils

Target > Site map > Click droit sur host
- Compare site maps

Comparer:
- Before/after authentication
- Different users
- Different configurations

Identifies:
- New endpoints
- Removed endpoints
- Changed responses

Manuelle (via navigation):
+ Découvre les fonctionnalités complexes
+ Respecte la logique applicative
- Peut manquer des endpoints cachés

Automatique (Spider):
+ Découvre rapidement
+ Trouve endpoints non liés
- Peut manquer logique complexe (AJAX, etc.)

Recommandation: Combiner les deux

Click droit sur un item dans Target ou Proxy:
- Spider this host
- Spider from here

Target > Site map > Click droit > Spider this branch

Spider options:
- Crawl optimization
- Application login
- Spider engine
- Request headers
- Form submission

- Pas de JavaScript rendering
- Peut manquer du contenu dynamique
- Pas de scanning automatique post-crawl

Dashboard > New scan > Crawl

Configuration:
1. Scan type: Crawl only
2. URLs to scan: https://example.com
3. Crawl optimization: Normal/Fast/Thorough
4. Application login: Optional
5. Start scan

Scan configuration:
- Crawl strategy: Most complete/Fastest
- Maximum link depth: 10 (default)
- JavaScript analysis: Yes
- Handle errors: Continue
- Maximum crawl duration: 60 minutes

Méthode 1: Record login sequence
1. Dashboard > New scan
2. Application login: Record login sequence
3. Naviguer et se connecter
4. Burp enregistre les étapes
5. Use this sequence for crawling

Méthode 2: Use session handling
1. Project options > Sessions
2. Session handling rules
3. Add rule: Use cookies from Burp's cookie jar

Spider/Crawler options:
- Don't submit forms
- Prompt for guidance (manuel)
- Automatically submit (avec valeurs par défaut)
- Intelligent form filling (Pro)

Target > Site map > Click droit > Engagement tools > Discover content

Configuration:
- Use smart brute force
- Wordlists location
- File extensions: php, asp, aspx, jsp, txt, bak
- Directories: admin, backup, old, test

Basé sur:
- Wordlists intégrées
- Réponses observées (intelligent)

Burp menu > Project options > Misc > Embedded browser path

Ajouter wordlists custom:
- /usr/share/wordlists/dirb/common.txt
- /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt
- SecLists (https://github.com/danielmiessler/SecLists)

Après crawl, analyser le Site Map:

1. Identifier endpoints intéressants
2. Paramètres dans URLs
3. Forms avec input
4. File uploads
5. API endpoints
6. Admin panels

Filtrer:
- Parameterized requests
- Scripts (*.js)
- Dynamic pages

Problème: Spider/Crawler rate du contenu AJAX

Solutions:
1. Utiliser Burp Pro avec JS analysis
2. Naviguer manuellement l'application
3. Utiliser extensions:
   - JS Link Finder
   - GAP (Google Analytics Parser)

Spider options:
- Throttle requests
- Maximum concurrent requests: 5
- Delay between requests: 500ms

Spider options:
- Randomize User-Agent
- Throttle heavily
- Use session handling pour garder cookies valides

Dashboard > New scan > Crawl and audit

Workflow:
1. Crawl le site (découverte)
2. Audit automatique de chaque endpoint
3. Report des vulnérabilités

Dans Site map ou Proxy history:
Click droit > Scan > Audit selected items

Plus ciblé et rapide

Dashboard > New scan
Select: Scan all items in scope

Audit complet du périmètre défini

Scan configuration:

Scan speed:
- Fast
- Normal
- Thorough
- Custom

Issues to detect:
- All issues
- Critical and high severity only
- Custom selection:
  ☑ SQL Injection
  ☑ XSS
  ☑ Command Injection
  ☑ Path Traversal
  ☐ SSL issues
  ...

- SQL Injection (Error-based, Boolean-based, Time-based)
- Command Injection (OS command injection)
- LDAP Injection
- XML Injection
- XPath Injection
- Code Injection

- Reflected XSS
- Stored XSS
- DOM-based XSS
- XSS in script contexts
- XSS in HTML attributes

- Password submitted in clear text
- Weak password policy
- Credentials submitted over HTTP
- Session fixation

- IDOR (Insecure Direct Object References)
- Missing authorization
- Privilege escalation
- Path traversal

- Missing security headers
- Information disclosure
- Directory listing
- Backup files disclosed
- Version disclosure

- XXE injection
- XML parsing errors

- SSRF via URL parameter
- SSRF via HTTP header

- Insecure deserialization
- Java deserialization

Dashboard > Issue activity

Colonnes:
- Severity: Critical, High, Medium, Low, Info
- Issue type
- Path
- Status

Actions:
- Set severity (ajuster)
- Mark as false positive
- Report issue
- Request/Response: voir les preuves

Filter:
- By severity
- By confidence (Certain, Firm, Tentative)
- By type
- New issues only

Cliquer sur une issue pour voir:
- Description complète
- Proof of concept request/response
- Remediation advice
- References (OWASP, CWE)
- Vulnerability classifications

Activé par défaut, analyse les réponses sans envoyer de requêtes additionnelles.

Détecte:
- Missing security headers
- Information disclosure
- Insecure cookies
- Vulnerable JavaScript libraries

Dashboard > Live passive crawl from Proxy (always running)

Envoie des payloads pour tester les vulnérabilités.

Détecte:
- SQL Injection
- XSS
- Command Injection
- Etc.

Attention: Plus bruyant, peut être détecté

- URL parameters
- Body parameters
- Cookies
- HTTP headers
- File uploads
- JSON/XML values

Configuration:
Scan > Scan configuration > Insertion points
- URL path components
- URL parameter values
- Body parameter values
- Cookies
- HTTP headers
- REST-style URL parameters

Dashboard > Issues > Select issues
Click droit > Report selected issues

Formats:
- HTML (recommandé pour présentation)
- XML (pour import dans autres outils)

Sections du rapport:
- Executive summary
- Vulnerability types summary
- Detailed findings avec preuves
- Remediation guidance

Pour sites larges:
1. Définir un scope précis
2. Utiliser "Fast" scan speed initialement
3. Scan ciblé sur endpoints critiques
4. Scheduled scans (Pro feature)

Throttling:
Scan configuration > Resource pool
- Maximum concurrent requests: 10
- Delay between requests: 0ms (ou plus si rate limiting)

1. Envoyer une requête à Intruder (Ctrl+I)
2. Target: Vérifier host et port
3. Positions: Définir les points d'injection
4. Payloads: Choisir les valeurs à injecter
5. Options: Configurer l'attaque
6. Start attack
7. Analyser les résultats

Un seul ensemble de payloads, testé sur chaque position une par une.

Exemple:
Position: username=§test§&password=§pass§
Payloads: admin, user, guest

Requêtes:
1. username=admin&password=pass
2. username=user&password=pass
3. username=guest&password=pass
4. username=test&password=admin
5. username=test&password=user
6. username=test&password=guest

Utilité: Tester un paramètre à la fois

Un seul ensemble de payloads, appliqué à toutes les positions simultanément.

Exemple:
Position: username=§test§&password=§pass§
Payloads: admin, user, guest

Requêtes:
1. username=admin&password=admin
2. username=user&password=user
3. username=guest&password=guest

Utilité: Tester la même valeur partout

Plusieurs ensembles de payloads, itération parallèle.

Exemple:
Position: username=§test§&password=§pass§
Payload set 1: admin, user, guest
Payload set 2: admin123, user123, guest123

Requêtes:
1. username=admin&password=admin123
2. username=user&password=user123
3. username=guest&password=guest123

Utilité: Combos username/password connus

Plusieurs ensembles de payloads, toutes les combinaisons (produit cartésien).

Exemple:
Position: username=§test§&password=§pass§
Payload set 1: admin, user
Payload set 2: pass123, admin123

Requêtes:
1. username=admin&password=pass123
2. username=admin&password=admin123
3. username=user&password=pass123
4. username=user&password=admin123

Utilité: Brute force exhaustif (lent!)

Intruder > Positions

Boutons:
- Add §: Marquer position
- Clear §: Effacer positions
- Auto §: Détection auto

Sélectionner la valeur à remplacer, puis cliquer Add §

Exemple:
GET /user?id=§123§ HTTP/1.1
Cookie: session=§abc123§

Intruder > Payloads

Payload set: 1 (si multiples positions)
Payload type: [sélectionner type]

Liste simple de valeurs.

Add: Ajouter manuellement
Load: Charger depuis fichier
Paste: Coller depuis clipboard

Exemple:
admin
user
guest
test
root

Lire depuis fichier ligne par ligne (économise RAM).

Configuration:
Select file: /path/to/wordlist.txt

Séquence numérique.

Configuration:
Type: Sequential
From: 1
To: 1000
Step: 1
Format: Decimal

Utilité: IDOR testing, brute force IDs

Format: dd/MM/yyyy
From: 01/01/2020
To: 31/12/2023

Utilité: Tester dates de naissance, etc.

Générer toutes les combinaisons.

Character set: abcdefghijklmnopqrstuvwxyz
Min length: 4
Max length: 6

Attention: Très gourmand!
Exemple: 4 caractères = 26^4 = 456,976 requêtes

N'envoie rien, utilisé pour répéter une requête.

Generate: 100 payloads

Utilité: Race conditions, load testing

Substituer des caractères.

Base string: password
Substitutions:
a -> @
e -> 3
o -> 0

Résultats:
password
p@ssword
p@ssw0rd
passw0rd
...

Générer des usernames basés sur noms.

Input: John Smith
Output:
john.smith
jsmith
smithj
john_smith
...

Combiner plusieurs listes avec séparateurs.

Position 1: [admin, user, guest]
Separator: _
Position 2: [2020, 2021, 2022]

Output:
admin_2020
admin_2021
user_2020
...

Intruder > Payloads > Payload Processing

Add rule:
- Add prefix
- Add suffix
- Match/Replace
- Substring
- Reverse
- Base64 encode
- URL encode
- Hash (MD5, SHA1, SHA256)

Exemple:
Payload: admin
Add prefix: user_
Hash: MD5
Final: MD5(user_admin) = ...

Intruder > Payloads > Payload Encoding

URL-encode these characters:
☑ & = ; : + ? / # @ ! $ ' ( ) * , [ ] { } | \ " < > %

Utile pour:
- Éviter de casser la requête
- Tester l'encodage

Intruder > Options

Request Engine:
- Number of threads: 5 (Community) / illimité (Pro)
- Delay between requests: 0ms
- Throttle: pour éviter rate limiting

Request Handling:
- Follow redirections: Always/Never/On-site only
- Process cookies in redirections

Extraire des chaînes des réponses.

Intruder > Options > Grep - Match

Add:
- Success
- Invalid
- Error
- Welcome

Résultats montreront une colonne par pattern avec ✓ si trouvé

Extraire des valeurs spécifiques.

Example: Extraire CSRF token

Intruder > Options > Grep - Extract
Add
Fetch response
Select in response: <input name="csrf" value="abc123">
OK

Chaque résultat affichera la valeur extraite

Rechercher les payloads dans les réponses.

Utile pour:
- XSS: voir si payload reflété
- SQL Injection: voir si payload dans erreur

Options > Redirections

Never: Ne pas suivre
Always: Suivre toutes
On-site only: Suivre seulement même domaine

Utile pour:
- Tester redirections open
- Éviter de sortir du scope

Results table columns:
- Request: Numéro
- Position: Position testée (si multiple)
- Payload: Valeur injectée
- Status: Code HTTP
- Error: Erreur réseau
- Timeout: Timeout
- Length: Taille de la réponse
- Comment: Annotation

Trier par colonne pour identifier anomalies

Indices de succès:
- Different status code (200 vs 401)
- Different length
- Presence of "Success" string
- Absence of "Invalid" string
- Redirection

Filtrer:
Click sur column header > Show only matching items

POST /login HTTP/1.1
Content-Type: application/x-www-form-urlencoded

username=§admin§&password=§password§

Positions: Cluster bomb
Payload 1: usernames.txt
Payload 2: passwords.txt

Grep - Match: "Welcome", "Invalid credentials"

Résultats:
Trier par "Welcome" ✓ pour trouver combos valides

Community Edition:
- Limité à 1 thread (lent)

Contournement (éthique uniquement!):
- Utiliser Turbo Intruder extension
- Multiples instances de Burp

Professional:
- Threads illimités
- Resource pools pour contrôler la charge

GET /api/user?id=§1§&format=§json§

Payload 1: Numbers 1-1000
Payload 2: json, xml, html, pdf

Identifier formats supportés et IDOR

POST /search HTTP/1.1

query=§test§

Payloads: SQL injection wordlist
' OR '1'='1
' OR 1=1--
admin'--
...

Grep - Match: SQL error keywords

GET /api/token?code=§ABCD§

Payload: Brute forcer
Character set: ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
Length: 4

Grep - Match: "valid", "invalid"

Repeater tab:
┌────────────────────────────────────────┐
│  Request                               │
│  ┌──────────────────────────────────┐ │
│  │ GET /api/user?id=1 HTTP/1.1      │ │
│  │ Host: example.com                 │ │
│  │ Cookie: session=abc123            │ │
│  └──────────────────────────────────┘ │
│                                        │
│  [Send] [Cancel]                       │
│                                        │
│  Response                              │
│  ┌──────────────────────────────────┐ │
│  │ HTTP/1.1 200 OK                   │ │
│  │ Content-Type: application/json    │ │
│  │                                    │ │
│  │ {"id":1,"name":"John"}            │ │
│  └──────────────────────────────────┘ │
└────────────────────────────────────────┘

Depuis Proxy ou Site map:
Click droit > Send to Repeater
Ou: Ctrl/Cmd + R

La requête apparaît dans un nouvel onglet Repeater

1. Modifier la requête dans le panel Request
2. Cliquer "Send" ou Ctrl/Cmd + Space
3. Observer la réponse dans le panel Response

Original:
GET /api/user?id=1 HTTP/1.1

Modifications successives:
GET /api/user?id=2 HTTP/1.1
GET /api/user?id=3 HTTP/1.1
GET /api/user?id=1' OR '1'='1 HTTP/1.1

Response tabs:
- Raw: Réponse brute
- Headers: Headers uniquement
- Hex: Vue hexadécimale
- HTML: Rendu HTML (si applicable)
- Render: Rendu complet avec CSS/JS

Pour JSON:
- Pretty: JSON formaté et coloré

Click droit dans Request panel:
- Change request method: GET ↔ POST
- Change body encoding
- URL-encode as you type
- Save item
- Copy URL
- Copy as curl command

Utile pour tester si l'application accepte les deux méthodes.

GET /delete?id=123
→
POST /delete
id=123

Activé en bas ou à droite du Repeater.

Request inspector:
- Query parameters (éditable)
- Body parameters (éditable)
- Cookies (éditable)
- Headers (éditable)
- Attributes

Plus intuitif pour éditer que le raw text

Ctrl/Cmd + Space : Send request
Ctrl/Cmd + U     : URL-encode selection
Ctrl/Cmd + Shift + U : URL-decode selection
Ctrl/Cmd + R     : Rename tab
Ctrl/Cmd + W     : Close tab

Selection + Click droit:
- Convert selection:
  - URL > URL-encode
  - HTML > HTML-encode
  - Base64 > Base64-encode
  - Hex

Envoyer plusieurs requêtes avec variations:
1. Send request A
2. Modifier
3. Send request B

Click droit dans Response > Send to Comparer
Répéter pour request B
Comparer > Words ou Bytes

Utilité:
- Identifier différences subtiles
- Blind SQL injection (time-based)
- A/B testing comportements

Si la réponse est 301/302:

Options (en bas):
☑ Follow redirections

Burp suivra automatiquement et affichera la réponse finale

Click droit dans Request panel:
Request in browser > In current browser session

Burp génère une URL unique:
http://127.0.0.1:8080/burp/...

Coller dans le navigateur pour voir le rendu
Utile pour tester XSS ou voir le rendu HTML

Requête:
GET /product?id=1 HTTP/1.1

Tests successifs:
id=1'           → Erreur SQL?
id=1' OR '1'='1 → Bypass?
id=1 AND 1=1    → Réponse normale?
id=1 AND 1=2    → Réponse différente?
id=1' UNION SELECT NULL-- → Union-based?

Requête:
POST /comment HTTP/1.1

comment=<script>alert(1)</script>

Variations:
comment=<img src=x onerror=alert(1)>
comment=<svg onload=alert(1)>
comment='"><script>alert(1)</script>

Vérifier si dans Response:
- Payload reflété tel quel
- Payload encodé
- Payload filtré

GET /api/document/123 HTTP/1.1

Tests:
/api/document/124
/api/document/125
...
/api/document/1

Observer:
- 200 OK: Accès non autorisé (IDOR!)
- 403 Forbidden: Contrôle OK
- 404 Not Found: Document inexistant

POST /admin HTTP/1.1
Cookie: session=abc123

Supprimer/modifier cookie:
Cookie: session=
Cookie: (supprimer la ligne)

Ajouter headers:
X-Forwarded-For: 127.0.0.1
X-Original-URL: /admin
X-Rewrite-URL: /admin

Requête:
POST /coupon HTTP/1.1

code=DISCOUNT10

Ouvrir plusieurs tabs Repeater (Ctrl+R plusieurs fois)
Dans chaque tab, même requête
Envoyer simultanément (Send Send Send rapide)

Observer si le coupon peut être utilisé plusieurs fois

1. Identifier la requête qui génère des tokens
2. Envoyer au Sequencer
3. Configurer quel token analyser
4. Collecter des échantillons (minimum 100, recommandé 20000+)
5. Analyser les résultats

Depuis Proxy history:
Click droit sur requête de login > Send to Sequencer

Sequencer > Token Location Within Response

Options:
- Cookie: session
- Custom location (regex)
- Form field

Start live capture

Requête:
POST /login HTTP/1.1

username=user&password=pass

Réponse:
HTTP/1.1 200 OK
Set-Cookie: session=abc123xyz

Token à analyser: abc123xyz

Sequencer > Live capture

Actions:
[Start capture]

Burp envoie automatiquement la requête plusieurs fois et collecte les tokens.

Tokens captured: 0 / 20000
[Pause] [Resume] [Stop] [Analyze now]

Minimum 100 pour analyse basique
Recommandé 10000+ pour analyse fiable

Si tokens déjà collectés:

Sequencer > Manual load

Coller les tokens (un par ligne):
token1
token2
token3
...

[Analyze]

Sequencer > Character-level analysis

Résultats:
- Overall result: Quality estimate (Good/Medium/Poor)
- Effective entropy: Bits d'entropie
- Reliability: Confidence level

Character position analysis:
Position 1: High entropy
Position 2: High entropy
Position 3: Low entropy ← Problème!
...

Bit-level analysis: Distribution des bits

Effective Entropy:
- 128+ bits: Excellent
- 64-128 bits: Bon
- 32-64 bits: Moyen (potentiellement bruteforceable)
- < 32 bits: Faible (vulnérable)

FIPS Tests:
Tests statistiques standards pour randomness
Passed: Bon
Failed: Patterns détectés (mauvais signe)

Token: 8f3d7b2a1c4e9f5d6a8b7c3e1f4d9a2b

Analysis:
- Effective entropy: 128 bits
- Character-level: Uniform distribution
- FIPS tests: All passed

Conclusion: Fort, non prédictible

Token: 1001, 1002, 1003, 1004...

Analysis:
- Effective entropy: 10 bits
- Sequential pattern detected
- FIPS tests: Failed

Conclusion: Très faible, prédictible, bruteforceable

Tokens:
20240315120000_abc
20240315120001_def
20240315120002_ghi

Analysis:
- First part: Timestamp (predictable)
- Effective entropy: ~24 bits (only random part)

Conclusion: Réduisible, potentiellement attaquable

Application: Site e-commerce

1. Capturer 10000 tokens de session
2. Analyser avec Sequencer
3. Si entropie < 64 bits:
   - Tenter brute force
   - Tenter prediction

4. Si pattern temporel:
   - Générer tokens valides futurs
   - Session hijacking

Application: Fonction "Forgot Password"

1. Demander 1000 reset tokens
2. Analyser séquence
3. Si faible entropie:
   - Prédire token d'un autre utilisateur
   - Réinitialiser son mot de passe (Account Takeover)

1. Collecter CSRF tokens
2. Vérifier si:
   - Prédictibles
   - Réutilisables
   - Manquants

3. Si prévisible: Générer token valide pour CSRF attack

Decoder tab:
┌────────────────────────────────────┐
│  Input:                            │
│  ┌──────────────────────────────┐ │
│  │  data to encode/decode       │ │
│  └──────────────────────────────┘ │
│                                    │
│  [Encode as...] [Decode as...]     │
│  [Hash]                            │
│                                    │
│  Output:                           │
│  ┌──────────────────────────────┐ │
│  │  result                       │ │
│  └──────────────────────────────┘ │
└────────────────────────────────────┘

Depuis n'importe où dans Burp:
1. Sélectionner du texte
2. Click droit > Send to Decoder
Ou: Ctrl/Cmd + Shift + D

Input:  hello world
Encode: hello%20world

Input:  <script>alert(1)</script>
Encode: %3Cscript%3Ealert%281%29%3C%2Fscript%3E

Input:  <script>alert(1)</script>
Encode: &lt;script&gt;alert(1)&lt;/script&gt;

Input:  "test"
Encode: &quot;test&quot;

Input:  admin:password
Encode: YWRtaW46cGFzc3dvcmQ=

Input:  {"user":"admin"}
Encode: eyJ1c2VyIjoiYWRtaW4ifQ==

Input:  hello
Encode: 68656c6c6f

Input:  ABC
Encode: 414243

Similar to ASCII Hex but with spaces
Input:  hello
Encode: 68 65 6c 6c 6f

Input:  ABC
Encode: 101 102 103

Input:  A
Encode: 01000001

Compress data with GZIP algorithm
Utilisé pour body HTTP compressé

Decoder > Hash

Disponibles:
- MD5
- SHA-1
- SHA-224
- SHA-256
- SHA-384
- SHA-512

Input:  password
MD5:    5f4dcc3b5aa765d61d8327deb882cf99
SHA256: 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8

Exemple: Double URL encoding

Input: <script>alert(1)</script>

Encode as URL: %3Cscript%3Ealert%281%29%3C%2Fscript%3E
Encode as URL: %253Cscript%253Ealert%25281%2529%253C%252Fscript%253E

Chaque opération crée une nouvelle section dans Decoder

Click "Smart decode" button

Burp tente automatiquement de décoder:
- Détecte le format (Base64, URL, Hex, etc.)
- Applique les décodages successifs
- Affiche les résultats intermédiaires

Exemple:
Input: JTNDc2NyaXB0JTNFYWxlcnQoMSklM0MlMkZzY3JpcHQlM0U=

Smart decode:
1. Base64 decode: %3Cscript%3Ealert(1)%3C%2Fscript%3E
2. URL decode: <script>alert(1)</script>

JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Structure: header.payload.signature

Decoder:
Part 1 (header): eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Decode as Base64: {"alg":"HS256","typ":"JWT"}

Part 2 (payload): eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ
Decode as Base64: {"sub":"1234567890","name":"John Doe","iat":1516239022}

Pour XSS dans context URL-encoded:

1. Input: <img src=x onerror=alert(1)>
2. Encode as URL: %3Cimg+src%3Dx+onerror%3Dalert%281%29%3E
3. Copier le résultat
4. Utiliser dans Repeater/Intruder

Cookie: user=YWRtaW4%3D

1. URL decode: YWRtaW4=
2. Base64 decode: admin

Maintenant tester:
1. Input: admin
2. Modify: root
3. Base64 encode: cm9vdA==
4. URL encode: cm9vdA%3D%3D
5. Tester avec Cookie: user=cm9vdA%3D%3D

Pour tester si l'application utilise MD5:

Input: password123
Hash > MD5: 482c811da5d5b4bc6d497ffa98491e38

Rechercher ce hash dans les requêtes/responses
Si présent: MD5 utilisé (faible pour mots de passe!)

Depuis Proxy, Repeater, Intruder:
Click droit > Send to Comparer

Minimum 2 items requis pour comparer

Compare words (tokens séparés par espaces)

Affichage:
- Mots identiques: non mis en évidence
- Mots différents: surlignés
- Mots ajoutés: vert
- Mots supprimés: rouge

Compare byte par byte

Affichage:
- Bytes identiques: non mis en évidence
- Bytes différents: surlignés

Plus précis mais moins lisible

┌────────────────────────────────────────┐
│  Item 1              Item 2            │
├────────────────────────────────────────┤
│  HTTP/1.1 200 OK    HTTP/1.1 200 OK    │
│  Content-Length: 50 Content-Length: 52 │ ← Différence
│                                        │
│  {"id":1,"admin":   {"id":1,"admin":   │
│   false}             true}             │ ← Différence
└────────────────────────────────────────┘

Test: id=1 AND 1=1 vs id=1 AND 1=2

Réponse 1: Contenu normal
Réponse 2: Contenu vide ou différent

Comparer:
- Si différence significative: Vulnérable
- Si identique: Pas de SQL injection (ou time-based)

Requête User:
GET /dashboard HTTP/1.1
Cookie: session=user_token

Requête Admin:
GET /dashboard HTTP/1.1
Cookie: session=admin_token

Comparer les réponses:
- Identifier fonctionnalités admin
- Tester avec user token pour voir si accessible (Privilege Escalation)

Tester si un paramètre change le comportement:

Request 1: GET /api?debug=false
Request 2: GET /api?debug=true

Comparer:
- Rechercher info leaks dans debug=true
- Stack traces
- Informations sensibles

Request 1: GET /api/user/123
Response: {"id":123,"name":"Alice","email":"alice@example.com"}

Request 2: GET /api/user/124
Response: {"id":124,"name":"Bob","email":"bob@example.com"}

Comparer:
- Structure identique: Bon
- Bob accessible sans autorisation: IDOR!

Option: Sync views

Quand activé:
- Scroller dans Item 1 scrolle automatiquement Item 2
- Plus facile de comparer des réponses longues

Extender > BApp Store

Catégories:
- Active Scan
- Passive Scan
- Traffic Analysis
- Beautifiers
- Logging
- Testing Methodologies
- Cryptography
- Decode

Extender > BApp Store > [Extension name] > Install

Ou manuellement:
Extender > Extensions > Add
Extension type: Java, Python, Ruby
Extension file: .jar, .py, .rb

But: Tester les failles d'autorisation automatiquement

Installation: BApp Store > Autorize > Install

Configuration:
1. Se connecter avec user à faibles privilèges
2. Autorize > Cookies > Add cookie de cette session
3. Naviguer avec un user privilégié
4. Autorize teste automatiquement si low-priv user peut accéder

Résultats:
- Rouge: Accès non autorisé détecté (vulnérabilité!)
- Vert: Accès refusé (bon)

But: Attaques très rapides (contourner limite Community)

Installation: BApp Store > Turbo Intruder > Install

Usage:
Click droit sur requête > Extensions > Turbo Intruder
Scripter l'attaque en Python

Exemple:
def queueRequests(target, wordlists):
    for word in open('/path/to/wordlist.txt'):
        engine.queue(target.req, word.rstrip())

But: Extraire URLs/endpoints depuis fichiers JavaScript

Installation: BApp Store > JS Link Finder > Install

Usage:
- Automatique sur fichiers .js scannés
- Target > Site map > voir endpoints découverts

But: Logging avancé avec export

Installation: BApp Store > Logger++ > Install

Features:
- Filtres avancés
- Export CSV, JSON
- Regex matching
- Color coding

But: Décoder, modifier, attaquer JWT tokens

Installation: BApp Store > JSON Web Tokens > Install

Usage:
Intercepter requête avec JWT:
Authorization: Bearer eyJ...

Extension affiche:
- Header décodé
- Payload décodé
- Signature

Actions:
- Modifier payload
- Changer algorithme (alg: none)
- Test key confusion attacks

But: Identifier bibliothèques JavaScript vulnérables

Installation: BApp Store > Retire.js > Install

Scan automatique:
- Détecte jQuery 1.8.0 (vulnérable XSS)
- Détecte Angular 1.5.0 (vulnérable)
- Etc.

But: Tester upload de fichiers

Installation: BApp Store > Upload Scanner > Install

Tests:
- Bypass extension filters
- Exécution code serveur
- XSS via upload
- XXE via SVG, XML

But: Découvrir paramètres cachés

Installation: BApp Store > Param Miner > Install

Usage:
Click droit > Extensions > Param Miner > Guess params

Teste des milliers de noms de paramètres communs:
- debug, admin, test, dev, etc.

But: SQLi scanner avancé

Installation: Manuelle (GitHub)

Features:
- Error-based SQLi
- Boolean-based blind
- Time-based blind
- Union-based

Configuration:
Extender > Options > Python Environment
Jython standalone JAR: /path/to/jython-standalone.jar

Télécharger Jython:
https://www.jython.org/download.html

// BurpExtender.java
package burp;

import java.io.PrintWriter;

public class BurpExtender implements IBurpExtender {
    @Override
    public void registerExtenderCallbacks(IBurpExtenderCallbacks callbacks) {
        callbacks.setExtensionName("Hello World");
        PrintWriter stdout = new PrintWriter(callbacks.getStdout(), true);
        stdout.println("Hello from Burp Extension!");
    }
}

// Compiler et charger le .jar dans Extender > Extensions > Add

# extension.py
from burp import IBurpExtender

class BurpExtender(IBurpExtender):
    def registerExtenderCallbacks(self, callbacks):
        callbacks.setExtensionName("Hello Python")
        print("Hello from Python extension!")
        return

# Charger directement le .py dans Extender > Extensions > Add

- JSON Web Tokens
- WSDL Wizard
- Swagger Parser
- GraphQL Raider

- Autorize
- AuthMatrix
- Session Timeout Test

- SQLiPy
- Hackvertor
- Upload Scanner

- JS Link Finder
- Param Miner
- Content Type Converter

- Logger++
- Report To Elastic
- Flow

Project options > Sessions > Session Handling Rules

Add rule:
Name: Maintain session
Scope: Include all URLs in scope

Rule Actions:
- Use cookies from Burp's cookie jar
- Run macro (pour re-authentification automatique)

Scénario: Re-login automatique quand session expire

1. Project options > Sessions > Macros > Add
2. Select requests:
   - GET /login (pour CSRF token)
   - POST /login (authentification)
3. Macro editor:
   - Extraire CSRF token
   - Utiliser dans POST
4. Session handling rule: Run macro if session invalid

Burp menu > Burp Collaborator client

Generate payload: xyz123.burpcollaborator.net

Utiliser ce payload dans tests:
- SSRF: http://xyz123.burpcollaborator.net
- XXE: <!ENTITY xxe SYSTEM "http://xyz123.burpcollaborator.net">
- DNS: nslookup xyz123.burpcollaborator.net

Poll now: Vérifier si interactions détectées

Résultats:
- HTTP request reçu: SSRF confirmé!
- DNS lookup reçu: XXE confirmé!