<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.
Les extensions de navigateur sont écrites en JavaScript et chargées par le navigateur en arrière-plan. Elles ont leur [DOM](https://www.w3schools.com/js/js_htmldom.asp) mais peuvent interagir avec les DOM d'autres sites. Cela signifie qu'elles peuvent compromettre la confidentialité, l'intégrité et la disponibilité d'autres sites (CIA).
Chaque script de contenu a un accès direct au DOM d'une **seule page web** et est donc exposé à une **entrée potentiellement malveillante**. Cependant, le script de contenu ne contient aucune autorisation autre que la capacité d'envoyer des messages au cœur de l'extension.
Le cœur de l'extension contient la plupart des privilèges/d'accès de l'extension, mais il ne peut interagir avec le contenu web que via [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) et des scripts de contenu. De plus, le cœur de l'extension n'a pas un accès direct à la machine hôte.
L'extension permet un binaire natif qui peut **accéder à la machine hôte avec les pleins privilèges de l'utilisateur**. Le binaire natif interagit avec le cœur de l'extension via l'interface de programmation d'application de plugin Netscape standard ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilisée par Flash et d'autres plugins de navigateur.
Pour obtenir les pleins privilèges de l'utilisateur, un attaquant doit convaincre l'extension de transmettre une entrée malveillante du script de contenu au cœur de l'extension et du cœur de l'extension au binaire natif.
Chaque composant de l'extension est séparé des autres par des **limites protectrices solides**. Chaque composant s'exécute dans un **processus de système d'exploitation séparé**. Les scripts de contenu et les cœurs d'extension s'exécutent dans des **processus sandbox** inaccessibles à la plupart des services du système d'exploitation.
De plus, les scripts de contenu sont séparés de leurs pages web associées en **s'exécutant dans un tas JavaScript séparé**. Le script de contenu et la page web ont **accès au même DOM sous-jacent**, mais les deux **n'échangent jamais de pointeurs JavaScript**, empêchant la fuite de fonctionnalités JavaScript.
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.
Les scripts de contenu sont **chargés** chaque fois que l'utilisateur **accède à une page correspondante**, dans notre cas toute page correspondant à l'expression **`https://example.com/*`** et ne correspondant pas à l'expression régulière **`*://*/*/business*`**. Ils s'exécutent **comme les scripts de la page elle-même** et ont un accès arbitraire au [Modèle d'Objet de Document (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) de la page.
Voici un exemple de script de contenu qui ajoutera un bouton d'explication à la page lorsque [l'API de stockage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) est utilisée pour récupérer la valeur `message` du stockage de l'extension.
Un message est envoyé aux pages d'extension par le script de contenu lorsque ce bouton est cliqué, en utilisant l'API [**runtime.sendMessage()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Cela est dû à la limitation du script de contenu dans l'accès direct aux API, le `storage` étant l'une des rares exceptions. Pour les fonctionnalités au-delà de ces exceptions, des messages sont envoyés aux pages d'extension avec lesquelles les scripts de contenu peuvent communiquer.
Selon le navigateur, les capacités du script de contenu peuvent varier légèrement. Pour les navigateurs basés sur Chromium, la liste des capacités est disponible dans la documentation des [développeurs Chrome](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), et pour Firefox, le [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sert de source principale.\
Il est également à noter que les scripts de contenu ont la capacité de communiquer avec les scripts d'arrière-plan, leur permettant d'effectuer des actions et de transmettre des réponses.
Pour visualiser et déboguer les scripts de contenu dans Chrome, le menu des outils de développement Chrome peut être accédé depuis Options > Autres outils > Outils de développement OU en appuyant sur Ctrl + Maj + I.
Une fois les outils de développement affichés, l'onglet **Source** doit être cliqué, suivi de l'onglet **Scripts de contenu**. Cela permet d'observer l'exécution des scripts de contenu en cours à partir de diverses extensions et de définir des points d'arrêt pour suivre le flux d'exécution.
Notez que les **Scripts de contenu ne sont pas obligatoires** car il est également possible de **injecter dynamiquement** des scripts et de les **injecter de manière programmatique** dans les pages web via **`tabs.executeScript`**. Cela offre en fait un contrôle plus **granulaire**.
Pour l'injection programmatique d'un script de contenu, l'extension doit avoir les [permissions d'hôte](https://developer.chrome.com/docs/extensions/reference/permissions) pour la page dans laquelle les scripts doivent être injectés. Ces autorisations peuvent être sécurisées soit en les **demandant** dans le manifeste de l'extension, soit de manière temporaire via [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
* **`document_end`** : Immédiatement après la fin de la construction du DOM, mais avant le chargement de sous-ressources telles que les images et les cadres.
Les messages envoyés par les scripts de contenu sont reçus par la **page d'arrière-plan**, qui joue un rôle central dans la coordination des composants de l'extension. Notamment, la page d'arrière-plan persiste tout au long de la durée de vie de l'extension, fonctionnant discrètement sans interaction directe de l'utilisateur. Elle possède son propre Modèle d'Objet de Document (DOM), permettant des interactions complexes et une gestion de l'état.
**Points Clés**:
- **Rôle de la Page d'Arrière-plan:** Agit comme le centre névralgique de l'extension, assurant la communication et la coordination entre les différentes parties de l'extension.
- **Persistance:** C'est une entité toujours présente, invisible pour l'utilisateur mais essentielle au fonctionnement de l'extension.
- **Génération Automatique:** Si elle n'est pas explicitement définie, le navigateur créera automatiquement une page d'arrière-plan. Cette page générée automatiquement inclura tous les scripts d'arrière-plan spécifiés dans le manifeste de l'extension, garantissant le bon fonctionnement des tâches d'arrière-plan de l'extension.
La commodité offerte par le navigateur en générant automatiquement une page d'arrière-plan (lorsqu'elle n'est pas explicitement déclarée) garantit que tous les scripts d'arrière-plan nécessaires sont intégrés et opérationnels, simplifiant le processus de configuration de l'extension.
Il utilise l'[API runtime.onMessage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) pour écouter les messages. Lorsqu'un message `"explain"` est reçu, il utilise l'[API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) pour ouvrir une page dans un nouvel onglet.
Pour déboguer le script arrière-plan, vous pouvez accéder aux **détails de l'extension et inspecter le service worker**, cela ouvrira les outils de développement avec le script arrière-plan :
* **Pages d'options** : Cette page s'affiche en haut de l'extension lorsqu'elle est cliquée. Dans le manifest précédent, j'ai pu accéder à cette page via `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` ou en cliquant sur :
Notez que ces pages ne sont pas persistantes comme les pages d'arrière-plan car elles chargent dynamiquement du contenu en cas de nécessité. Malgré cela, elles partagent certaines capacités avec la page d'arrière-plan :
- **Communication avec les scripts de contenu :** Similaire à la page d'arrière-plan, ces pages peuvent recevoir des messages des scripts de contenu, facilitant l'interaction au sein de l'extension.
- **Accès aux API spécifiques à l'extension :** Ces pages bénéficient d'un accès complet aux API spécifiques à l'extension, sous réserve des autorisations définies pour l'extension.
**`permissions`** et **`host_permissions`** sont des entrées du `manifest.json` qui indiqueront **quelles autorisations** les extensions de navigateur possèdent (stockage, localisation...) et dans **quelles pages web**.
Comme les extensions de navigateur peuvent être si **privilégiées**, une extension malveillante ou compromise pourrait permettre à l'attaquant **différents moyens de voler des informations sensibles et d'espionner l'utilisateur**.
pour qu'une page web puisse accéder à une page d'une extension de navigateur, une page `.html` par exemple, cette page doit être mentionnée dans le champ **`web_accessible_resources`** du `manifest.json`.\
Le fait de permettre le chargement de ces pages uniquement par l'extension et non par des URL aléatoires pourrait prévenir les attaques de ClickJacking.
Selon la [**documentation**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propriété de manifeste `"externally_connectable"` déclare **quelles extensions et quelles pages web peuvent se connecter** à votre extension via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) et [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
* Si la clé **`externally_connectable`** n'est **pas** déclarée dans le manifeste de votre extension ou si elle est déclarée comme **`"ids": ["*"]`**, **toutes les extensions peuvent se connecter, mais aucune page web ne peut se connecter**.
* Si des **IDs spécifiques sont spécifiés**, comme dans `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **seules ces applications** peuvent se connecter.
Si une page web vulnérable aux attaques XSS ou à la prise de contrôle est indiquée dans **`externally_connectable`**, un attaquant pourra envoyer des messages directement au script arrière-plan, contournant complètement le Content Script et sa CSP.
Les environnements dans lesquels les **scripts de contenu** opèrent et où les pages hôtes existent sont **séparés** les uns des autres, assurant une **isolation**. Malgré cette isolation, les deux ont la capacité d'interagir avec le **Modèle d'Objet de Document (DOM)** de la page, une ressource partagée. Pour que la page hôte puisse communiquer avec le **script de contenu**, ou indirectement avec l'extension via le script de contenu, il est nécessaire d'utiliser le **DOM** accessible par les deux parties comme canal de communication.
- **`event.isTrusted`** : Cela est vrai uniquement si l'événement a été déclenché par une action de l'utilisateur.
- Le script de contenu peut s'attendre à un message uniquement si l'utilisateur effectue une action.
- **Domaine d'origine** : peut s'attendre à un message uniquement à partir d'une liste blanche de domaines.
- Si une expression régulière est utilisée, soyez très prudent.
- **Source** : `received_message.source !== window` peut être utilisé pour vérifier si le message provient de **la même fenêtre** où le script de contenu écoute.
Les vérifications précédentes, même si elles sont effectuées, pourraient être vulnérables, donc vérifiez sur la page suivante les **bypass potentiels de Post Message** :
Ce n'est pas "exactement" un moyen de communication, mais le **web et le script de contenu auront accès au DOM web**. Donc, si le **script de contenu** lit des informations à partir de celui-ci, **faisant confiance au DOM web**, le web pourrait **modifier ces données** (car le web ne devrait pas être digne de confiance, ou parce que le web est vulnérable aux XSS) et **compromettre le script de contenu**.
Si une extension de navigateur stocke des **informations sensibles dans sa mémoire**, celles-ci pourraient être **extraites** (surtout sur les machines Windows) et **recherchées** pour ces informations.
Par conséquent, la mémoire de l'extension de navigateur **ne devrait pas être considérée comme sécurisée** et les **informations sensibles** telles que les identifiants ou les phrases mnémoniques **ne devraient pas être stockées**.
Un script de contenu peut utiliser les fonctions [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **ou** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) pour envoyer un message **sérialisable en JSON** une seule fois.
Pour gérer la **réponse**, utilisez la **Promise** retournée. Cependant, pour des raisons de compatibilité ascendante, vous pouvez toujours passer un **callback** en dernier argument.
Envoyer une requête depuis l'**extension** (généralement un **script d'arrière-plan**). Un script de contenu peut utiliser les fonctions, à condition de spécifier l'onglet auquel l'envoyer. Exemple de comment envoyer un message au script de contenu dans l'onglet sélectionné :
Sur le **côté récepteur**, vous devez configurer un [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **écouteur d'événements** pour gérer le message. Cela ressemble de la même manière depuis un script de contenu ou une page d'extension.
Dans l'exemple mis en évidence, **`sendResponse()`** a été exécuté de manière synchrone. Pour modifier le gestionnaire d'événements `onMessage` pour une exécution asynchrone de `sendResponse()`, il est impératif d'incorporer `return true;`.
Une considération importante est que dans les scénarios où plusieurs pages sont configurées pour recevoir des événements `onMessage`, **la première page à exécuter `sendResponse()`** pour un événement spécifique sera la seule capable de délivrer efficacement la réponse. Toutes les réponses ultérieures au même événement ne seront pas prises en compte.
Lors de la création de nouvelles extensions, la préférence devrait être donnée aux promesses plutôt qu'aux rappels. En ce qui concerne l'utilisation des rappels, la fonction `sendResponse()` est considérée comme valide uniquement si elle est exécutée directement dans le contexte synchrone, ou si le gestionnaire d'événements indique une opération asynchrone en retournant `true`. Si aucun des gestionnaires ne retourne `true` ou si la fonction `sendResponse()` est supprimée de la mémoire (collecte des déchets), le rappel associé à la fonction `sendMessage()` sera déclenché par défaut.
Le code source d'une extension Chrome peut être obtenu par divers moyens. Ci-dessous se trouvent des explications détaillées et des instructions pour chaque option.
### Télécharger l'extension au format ZIP via la ligne de commande
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 :
Une autre méthode pratique consiste à utiliser Chrome Extension Source Viewer, qui est un projet open-source. Il peut être installé depuis le [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). Le code source du visualiseur est disponible dans son [dépôt GitHub](https://github.com/Rob--W/crxviewer).
Bien que les extensions de navigateur aient une **surface d'attaque limitée**, certaines d'entre elles pourraient contenir des **vulnérabilités** ou des **améliorations potentielles de renforcement**. Voici les plus courantes :
* [ ]**Limitez** autant que possible les **`permissions`** demandées
* [ ]**Limitez** autant que possible les **`host_permissions`**
* [ ] Utilisez une **`content_security_policy`** **forte**
* [ ]**Limitez** autant que possible les **`externally_connectable`**, s'il n'est pas nécessaire et possible, ne le laissez pas par défaut, spécifiez **`{}`**
* [ ] Si une **URL vulnérable aux attaques XSS ou à la prise de contrôle** est mentionnée ici, un attaquant pourra **envoyer des messages directement aux scripts d'arrière-plan**. Une faille très puissante.
* [ ]**Limitez** autant que possible les **`web_accessible_resources`**, même vide si possible.
* [ ] Si **`web_accessible_resources`** n'est pas vide, vérifiez le [**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 par la communication.
* [ ] Si le **Script de contenu accède aux détails du DOM**, vérifiez qu'ils n'introduisent pas de XSS s'ils sont **modifiés** par le web
* [ ] Mettez l'accent particulièrement si cette communication est également impliquée dans la **communication Script de contenu -> Script d'arrière-plan**
* **Analyse d'empreinte digitale** : Détection des [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) et génération automatique de JavaScript de fingerprinting 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. Elles sont potentiellement vulnérables au clickjacking en fonction de l'objectif des pages.
* **Visionneur d'avertissement(s) de permission** : qui affiche une liste de tous les avertissements de permission Chrome qui s'afficheront 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).
* **Point(s) d'entrée** : montre où l'extension prend en compte les entrées utilisateur/externes. Cela est utile pour comprendre la surface d'une extension et rechercher des points potentiels pour envoyer des données malveillantes à l'extension.
* Les scanners de Fonction(s) dangereuse(s) et de Point(s) d'entrée ont les éléments suivants pour leurs alertes générées :
* Extrait de code pertinent et ligne ayant causé l'alerte.
* Si la ligne vulnérable est dans un fichier JavaScript, les chemins de toutes les pages où elle est incluse ainsi que le statut de [web\_accessible\_resource](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) de ces pages.
* **Analyseur de stratégie de sécurité du contenu (CSP) et vérificateur de contournement** : Cela mettra en évidence les faiblesses de la CSP de votre extension et illuminera également les éventuelles façons de contourner votre CSP en raison des CDN autorisés, 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.
* Mise en cache automatique des résultats d'analyse, lancer une analyse d'extension prendra beaucoup de temps la première fois que vous l'exécutez. Cependant, la deuxième fois, en supposant que l'extension n'ait pas été mise à jour, sera presque instantanée en raison de la mise en cache des résultats.
* URLs de rapport liables, permettant de facilement partager un rapport d'extension généré par tarnish.
Le projet Neto est un package Python 3 conçu pour analyser et dévoiler les fonctionnalités cachées des plugins et extensions de navigateur pour des navigateurs bien connus tels que Firefox et Chrome. Il automatise le processus de décompression des fichiers empaquetés pour extraire ces fonctionnalités des ressources pertinentes dans une extension comme `manifest.json`, les dossiers de localisation ou les fichiers source Javascript et HTML.
<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* **Rejoignez** 💬 le groupe Discord](https://discord.gg/hRep4RUj7f) ou le [groupe Telegram](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
