diff --git a/book.toml b/book.toml index 55f8eeb4f..3d588387c 100644 --- a/book.toml +++ b/book.toml @@ -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"] diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 37f549101..fedfdef99 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -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('(.*?)', 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('(.*?)', 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']}") diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md index 1494a8bef..7daf56267 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md @@ -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. diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md index 0a7e2b024..c54de491c 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md @@ -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 diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md index c5c81c365..632cc7f08 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md @@ -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 :
@@ -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 -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. diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md index bd27532bd..d835cb1a4 100644 --- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md +++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md @@ -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() diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index 95939b13c..6f2957a12 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -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 ``` @@ -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 +### Poisoning du cache avec traversée de chemin pour voler la clé API -[**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 diff --git a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md index cc8b0648a..0231612a8 100644 --- a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md +++ b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md @@ -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 diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md index 4418ef5bb..d163d3bc3 100644 --- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md +++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md @@ -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}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 1b7340cf1..495e7f1a2 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -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 @@ -243,7 +243,7 @@ ng-init="c.init()" ``` -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 @@ -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 ``` @@ -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, #x ?search=#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'"> ``` -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 ` 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 : `
` 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 `. Toutes les données jusqu'à ce qu'une balise fermante `` 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 ` ← Injected lines @@ -90,13 +90,13 @@ Vous pouvez modifier le chemin d'un formulaire et insérer de nouvelles valeurs `` 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