From 7662377be9e8937f9b6ed2a69bcdfce97420eb00 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 29 Sep 2025 22:11:19 +0000 Subject: [PATCH] Translated ['src/network-services-pentesting/pentesting-web/electron-des --- .../electron-desktop-apps/README.md | 229 ++++++++++-------- 1 file changed, 127 insertions(+), 102 deletions(-) diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md index 835d71c8c..ab0e304f1 100644 --- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md +++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md @@ -6,21 +6,21 @@ Electron combine un backend local (avec **NodeJS**) et un frontend (**Chromium**), bien qu'il lui manque certains mécanismes de sécurité des navigateurs modernes. -Généralement, vous pouvez trouver le code de l'application Electron à l'intérieur d'une application `.asar`. Pour obtenir le code, vous devez l'extraire : +D'habitude, vous pouvez trouver le code de l'application Electron à l'intérieur d'une application `.asar`. Pour obtenir le code, vous devez l'extraire : ```bash npx asar extract app.asar destfolder #Extract everything npx asar extract-file app.asar main.js #Extract just a file ``` -Dans le code source d'une application Electron, dans `packet.json`, vous pouvez trouver le fichier `main.js` où sont définies les configurations de sécurité. +Dans le code source d'une application Electron, à l'intérieur de `packet.json`, vous pouvez trouver spécifié le fichier `main.js` où les configurations de sécurité sont définies. ```json { "name": "standard-notes", "main": "./app/index.js", ``` -Electron possède 2 types de processus : +Electron a 2 types de processus : -- Main Process (dispose d'un accès complet à NodeJS) -- Renderer Process (devrait avoir un accès restreint à NodeJS pour des raisons de sécurité) +- Main Process (a un accès complet à NodeJS) +- Renderer Process (devrait avoir un accès NodeJS restreint pour des raisons de sécurité) ![](<../../../images/image (182).png>) @@ -32,18 +32,18 @@ let win = new BrowserWindow() //Open Renderer Process win.loadURL(`file://path/to/index.html`) ``` -Les paramètres du **processus de rendu** peuvent être **configurés** dans le **processus principal** du fichier main.js. Certaines configurations empêcheront l'application Electron d'obtenir une RCE ou d'autres vulnérabilités si les **paramètres sont correctement configurés**. +Les paramètres du **processus de rendu** peuvent être **configurés** dans le **processus principal** à l'intérieur du fichier main.js. Certaines des configurations permettront d'**empêcher l'application Electron d'obtenir un RCE** ou d'autres vulnérabilités si les **paramètres sont correctement configurés**. -L'application Electron **pourrait accéder à l'appareil** via les API Node bien qu'elle puisse être configurée pour l'en empêcher : +L'application electron **pourrait accéder à l'appareil** via les Node apis bien qu'il soit possible de la configurer pour l'en empêcher : -- **`nodeIntegration`** - est `off` par défaut. Si activé, permet d'accéder aux fonctionnalités de Node depuis le processus de rendu. +- **`nodeIntegration`** - est `off` par défaut. Si `on`, permet d'accéder aux fonctionnalités de Node depuis le processus de rendu. - **`contextIsolation`** - est `on` par défaut. Si `off`, les processus principal et de rendu ne sont pas isolés. - **`preload`** - vide par défaut. - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - est `off` par défaut. Il restreindra les actions que NodeJS peut effectuer. -- Intégration Node dans les Workers -- **`nodeIntegrationInSubframes`**- est `off` par défaut. -- Si **`nodeIntegration`** est **enabled**, cela permettrait l'utilisation des **Node.js APIs** dans les pages web **chargées dans des iframes** au sein d'une application Electron. -- Si **`nodeIntegration`** est **disabled**, alors les preloads seront chargés dans l'iframe +- Node Integration in Workers +- **`nodeIntegrationInSubframes`** - est `off` par défaut. +- Si **`nodeIntegration`** est **enabled**, cela permettrait l'utilisation des **Node.js APIs** dans des pages web **chargées dans des iframes** au sein d'une application Electron. +- Si **`nodeIntegration`** est **disabled**, alors les preloads se chargeront dans l'iframe Exemple de configuration: ```javascript @@ -103,8 +103,7 @@ Modifiez la configuration start-main et ajoutez l'utilisation d'un proxy tel que ``` ## Electron Local Code Injection -Si vous pouvez exécuter localement une Electron App, il est possible de la faire exécuter du code javascript arbitraire. Voyez comment dans : - +Si vous pouvez exécuter localement une Electron App, il est possible de lui faire exécuter du code javascript arbitraire. Regardez comment dans : {{#ref}} ../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md @@ -112,7 +111,7 @@ Si vous pouvez exécuter localement une Electron App, il est possible de la fair ## RCE: XSS + nodeIntegration -Si la **nodeIntegration** est réglée sur **on**, le JavaScript d'une page web peut utiliser les fonctionnalités de Node.js facilement simplement en appelant `require()`. Par exemple, la façon d'exécuter l'application calc sur Windows est : +Si la **nodeIntegration** est réglée sur **on**, le JavaScript d'une page web peut utiliser facilement les fonctionnalités de Node.js simplement en appelant `require()`. Par exemple, la façon d'exécuter l'application calc sur Windows est : ```html ``` -> [!NOTE] > **Si `contextIsolation` est activé, cela ne fonctionnera pas** +> [!NOTE] > **Si `contextIsolation` est activé, ceci ne fonctionnera pas** ## RCE: XSS + contextIsolation -Le _**contextIsolation**_ introduit les **contextes séparés entre les scripts de la page web et le code interne JavaScript d'Electron** afin que l'exécution JavaScript de chaque code n'affecte pas l'autre. C'est une fonctionnalité nécessaire pour éliminer la possibilité de RCE. +Le _**contextIsolation**_ introduit des **contextes séparés entre les scripts de la page web et le code interne JavaScript d'Electron** afin que l'exécution JavaScript de chaque code n'affecte pas l'autre. C'est une fonctionnalité nécessaire pour éliminer la possibilité de RCE. Si les contextes ne sont pas isolés, un attaquant peut : -1. Exécuter **du JavaScript arbitraire dans le renderer** (XSS ou navigation vers des sites externes) -2. **Écraser la méthode intégrée** utilisée dans le preload ou le code interne d'Electron pour prendre le contrôle +1. Exécuter **arbitrary JavaScript in renderer** (XSS ou navigation vers des sites externes) +2. **Écraser la méthode built-in** qui est utilisée dans preload ou le code interne d'Electron pour prendre le contrôle d'une fonction 3. **Déclencher** l'utilisation de la **fonction écrasée** 4. RCE? -There are 2 places where built-int methods can be overwritten: In preload code or in Electron internal code: +Il y a 2 endroits où les méthodes intégrées peuvent être écrasées : dans le code preload ou dans le code interne d'Electron : {{#ref}} @@ -179,9 +178,9 @@ electron-contextisolation-rce-via-electron-internal-code.md electron-contextisolation-rce-via-ipc.md {{#endref}} -### Bypass click event +### Contourner l'événement de click -S'il y a des restrictions appliquées lorsque vous cliquez sur un lien, vous pourrez peut-être les contourner **en effectuant un clic du milieu** au lieu d'un clic gauche classique +S'il y a des restrictions appliquées lorsque vous cliquez sur un lien, vous pouvez peut-être les contourner **en effectuant un clic du milieu** au lieu d'un clic gauche classique. ```javascript window.addEventListener('click', (e) => { ``` @@ -189,24 +188,24 @@ window.addEventListener('click', (e) => { Pour plus d'informations sur ces exemples, consultez [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) et [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) -Lors du déploiement d'une application desktop Electron, s'assurer des bons paramètres pour `nodeIntegration` et `contextIsolation` est crucial. Il est établi que **client-side remote code execution (RCE)** ciblant les preload scripts ou le native code d'Electron depuis le main process est efficacement empêché lorsque ces paramètres sont en place. +Lors du déploiement d'une application de bureau Electron, s'assurer des paramètres corrects pour `nodeIntegration` et `contextIsolation` est crucial. Il est établi que **client-side remote code execution (RCE)** ciblant les preload scripts ou le native code d'Electron depuis le main process est effectivement empêché lorsque ces paramètres sont en place. -Lorsque l'utilisateur interagit avec des liens ou ouvre de nouvelles fenêtres, des event listeners spécifiques sont déclenchés, qui sont cruciaux pour la sécurité et le fonctionnement de l'application : +Lorsqu'un utilisateur interagit avec des liens ou ouvre de nouvelles fenêtres, des event listeners spécifiques sont déclenchés, qui sont cruciaux pour la sécurité et le fonctionnement de l'application : ```javascript webContents.on("new-window", function (event, url, disposition, options) {} webContents.on("will-navigate", function (event, url) {} ``` -Ces gestionnaires d'événements sont **surchargés par l'application de bureau** pour implémenter sa propre **logique métier**. L'application évalue si un lien navigué doit être ouvert en interne ou dans un navigateur web externe. Cette décision est généralement prise via une fonction, `openInternally`. Si cette fonction retourne `false`, cela indique que le lien doit être ouvert en externe, en utilisant la fonction `shell.openExternal`. +These listeners are **overridden by the desktop application** to implement its own **business logic**. The application evaluates whether a navigated link should be opened internally or in an external web browser. This decision is typically made through a function, `openInternally`. If this function returns `false`, it indicates that the link should be opened externally, utilizing the `shell.openExternal` function. -**Here is a simplified pseudocode:** +**Voici un pseudocode simplifié :** ![https://miro.medium.com/max/1400/1*iqX26DMEr9RF7nMC1ANMAA.png](<../../../images/image (261).png>) ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>) -Les bonnes pratiques de sécurité Electron JS déconseillent d'accepter du contenu non fiable avec la fonction `openExternal`, car cela pourrait mener à du RCE via différents protocoles. Les systèmes d'exploitation prennent en charge divers protocoles susceptibles de déclencher du RCE. Pour des exemples détaillés et des explications supplémentaires sur ce sujet, on peut se référer à [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), qui inclut des exemples de protocoles Windows capables d'exploiter cette vulnérabilité. +Les bonnes pratiques de sécurité d'Electron JS déconseillent d'accepter du contenu non fiable avec la fonction `openExternal`, car cela pourrait mener à une RCE via divers protocoles. Les systèmes d'exploitation prennent en charge différents protocoles pouvant déclencher une RCE. Pour des exemples détaillés et des explications supplémentaires sur ce sujet, on peut consulter [cette ressource](https://positive.security/blog/url-open-rce#windows-10-19042), qui inclut des exemples de protocoles Windows capables d'exploiter cette vulnérabilité. -Dans macos, la fonction `openExternal` peut être exploitée pour exécuter des commandes arbitraires comme dans `shell.openExternal('file:///System/Applications/Calculator.app')`. +Sur macos, la fonction `openExternal` peut être exploitée pour exécuter des commandes arbitraires, par exemple `shell.openExternal('file:///System/Applications/Calculator.app')`. **Exemples d'exploits de protocoles Windows incluent :** ```html @@ -228,17 +227,17 @@ window.open( ) ``` -## RCE: webviewTag + vulnerable preload IPC + shell.openExternal +## RCE: webviewTag + IPC preload vulnérable + shell.openExternal -Cette vulnérabilité est décrite dans **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**. +Cette vulnérabilité se trouve dans **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**. -La **webviewTag** est une **fonctionnalité dépréciée** qui permet l'utilisation de **NodeJS** dans le **renderer process**, qui devrait être désactivée car elle permet de charger un script dans le preload context comme: +Le **webviewTag** est une **fonctionnalité obsolète** qui permet l'utilisation de **NodeJS** dans le **processus de rendu**, elle devrait être désactivée car elle permet de charger un script dans le contexte preload comme : ```xml ``` -Ainsi, un attaquant qui parvient à charger une page arbitraire pourrait utiliser cette balise pour **charger un script de préchargement arbitraire**. +Par conséquent, un attaquant qui parvient à charger une page arbitraire pourrait utiliser cette balise pour **charger un preload script arbitraire**. -Ce script de préchargement a ensuite été abusé pour appeler un **service IPC vulnérable (`skype-new-window`)** qui appelait **`shell.openExternal`** pour obtenir une RCE: +Ce preload script a ensuite été détourné pour appeler un **service IPC vulnérable (`skype-new-window`)** qui appelait **`shell.openExternal`** afin d'obtenir RCE : ```javascript (async() => { const { ipcRenderer } = require("electron"); @@ -249,13 +248,13 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do }, 5000); })(); ``` -## Lecture de fichiers internes : XSS + contextIsolation +## Lecture des fichiers internes : XSS + contextIsolation -**La désactivation de `contextIsolation` permet d'utiliser des balises ``**, similaires à `