From 16796b4e4058f2cad02cb1555aa243d8050daba8 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 7 Jan 2025 18:15:31 +0000 Subject: [PATCH] Translated ['src/network-services-pentesting/pentesting-web/electron-des --- .gitignore | 1 + hacktricks-preprocessor.py | 53 ++++--- .../electron-desktop-apps/README.md | 135 +++++++++++++++--- 3 files changed, 150 insertions(+), 39 deletions(-) diff --git a/.gitignore b/.gitignore index 365859fbc..77edd91a0 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,4 @@ scripts/* book book/* hacktricks-preprocessor.log +hacktricks-preprocessor-error.log diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 969d5333e..af5949449 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -7,7 +7,14 @@ from os import path from urllib.request import urlopen, Request logger = logging.getLogger(__name__) -logging.basicConfig(filename='hacktricks-preprocessor.log', filemode='w', encoding='utf-8', level=logging.DEBUG) +logger.setLevel(logging.DEBUG) +handler = logging.FileHandler(filename='hacktricks-preprocessor.log', mode='w', encoding='utf-8') +handler.setLevel(logging.DEBUG) +logger.addHandler(handler) + +handler2 = logging.FileHandler(filename='hacktricks-preprocessor-error.log', mode='w', encoding='utf-8') +handler2.setLevel(logging.ERROR) +logger.addHandler(handler2) def findtitle(search ,obj, key, path=(),): @@ -27,7 +34,7 @@ def findtitle(search ,obj, key, path=(),): def ref(matchobj): - logger.debug(f'Match: {matchobj.groups(0)[0].strip()}') + logger.debug(f'Ref match: {matchobj.groups(0)[0].strip()}') href = matchobj.groups(0)[0].strip() title = href if href.startswith("http://") or href.startswith("https://"): @@ -45,19 +52,29 @@ def ref(matchobj): try: if href.endswith("/"): href = href+"README.md" # Fix if ref points to a folder - chapter, _path = findtitle(href, book, "source_path") - logger.debug(f'Recursive title search result: {chapter["name"]}') - title = chapter['name'] + if "#" in href: + chapter, _path = findtitle(href.split("#")[0], book, "source_path") + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + chapter, _path = findtitle(href, book, "source_path") + logger.debug(f'Recursive title search result: {chapter["name"]}') + title = chapter['name'] except Exception as e: try: dir = path.dirname(current_chapter['source_path']) logger.debug(f'Error getting chapter title: {href} trying with relative path {path.normpath(path.join(dir,href))}') - chapter, _path = findtitle(path.normpath(path.join(dir,href)), book, "source_path") - logger.debug(f'Recursive title search result: {chapter["name"]}') - title = chapter['name'] + if "#" in href: + chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") + title = chapter["name"] + logger.debug(f'Recursive title search result: {chapter["name"]}') except Exception as e: - logger.debug(f'Error getting chapter title: {path.normpath(path.join(dir,href))}') - print(f'Error getting chapter title: {path.normpath(path.join(dir,href))}') + logger.debug(e) + logger.error(f'Error getting chapter title: {path.normpath(path.join(dir,href))}') sys.exit(1) @@ -69,6 +86,7 @@ def ref(matchobj): return result + def files(matchobj): logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}') href = matchobj.groups(0)[0].strip() @@ -76,19 +94,19 @@ def files(matchobj): try: for root, dirs, files in os.walk(os.getcwd()+'/src/files'): + logger.debug(root) + logger.debug(files) if href in files: title = href logger.debug(f'File search result: {os.path.join(root, href)}') except Exception as e: logger.debug(e) - logger.debug(f'Error searching file: {href}') - print(f'Error searching file: {href}') + logger.error(f'Error searching file: {href}') sys.exit(1) if title=="": - logger.debug(f'Error searching file: {href}') - print(f'Error searching file: {href}') + logger.error(f'Error searching file: {href}') sys.exit(1) template = f"""{title}""" @@ -97,6 +115,7 @@ def files(matchobj): return result + def add_read_time(content): regex = r'(<\/style>\n# .*(?=\n))' new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content) @@ -126,15 +145,15 @@ 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']}") current_chapter = chapter - regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}' + # regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}' + regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n#]*(?:#(.*))?)(?:\n)?{{[\s]*#endref[\s]*}}' new_content = re.sub(regex, ref, chapter['content']) regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}' - new_content = re.sub(regex, files, chapter['content']) + new_content = re.sub(regex, files, new_content) new_content = add_read_time(new_content) chapter['content'] = new_content 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 4fb579f75..7f1db03e9 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 @@ -2,16 +2,16 @@ {{#include ../../../banners/hacktricks-training.md}} -## Inleiding +## Introduction Electron kombineer 'n plaaslike backend (met **NodeJS**) en 'n frontend (**Chromium**), alhoewel dit sommige van die sekuriteitsmeganismes van moderne blaaiers mis. -Gewoonlik sal jy die electron-appkode binne 'n `.asar` toepassing vind, om die kode te verkry moet jy dit onttrek: +Gewoonlik kan jy die electron app kode binne 'n `.asar` toepassing vind, om die kode te verkry moet jy dit onttrek: ```bash npx asar extract app.asar destfolder #Extract everything npx asar extract-file app.asar main.js #Extract just a file ``` -In die bronkode van 'n Electron-app, binne `packet.json`, kan jy die `main.js`-lêer vind waar sekuriteitskonfigurasies gestel word. +In die bronkode van 'n Electron-app, binne `packet.json`, kan jy die `main.js`-lêer vind waar sekuriteitskonfigurasies ingestel is. ```json { "name": "standard-notes", @@ -20,11 +20,11 @@ In die bronkode van 'n Electron-app, binne `packet.json`, kan jy die `main.js`-l Electron het 2 prosestipes: - Hoofproses (het volledige toegang tot NodeJS) -- Renderer-proses (moet beperkte toegang tot NodeJS hê om veiligheidsredes) +- Rendererproses (moet beperkte toegang tot NodeJS hê om veiligheidsredes) ![](<../../../images/image (182).png>) -'n **renderer-proses** sal 'n blaaiervenster wees wat 'n lêer laai: +'n **rendererproses** sal 'n blaaiervenster wees wat 'n lêer laai: ```javascript const { BrowserWindow } = require("electron") let win = new BrowserWindow() @@ -32,18 +32,18 @@ let win = new BrowserWindow() //Open Renderer Process win.loadURL(`file://path/to/index.html`) ``` -Instellings van die **renderer proses** kan **gekonfigureer** word in die **hoof proses** binne die main.js-lêer. Sommige van die konfigurasies sal **voorkom dat die Electron-toepassing RCE kry** of ander kwesbaarhede as die **instellings korrek geconfigureer is**. +Instellings van die **renderer-proses** kan **gekonfigureer** word in die **hoofproses** binne die main.js-lêer. Sommige van die konfigurasies sal **voorkom dat die Electron-toepassing RCE kry** of ander kwesbaarhede as die **instellings korrek geconfigureer is**. -Die electron-toepassing **kan toegang tot die toestel verkry** via Node apis alhoewel dit geconfigureer kan word om dit te voorkom: +Die electron-toepassing **kan toegang tot die toestel verkry** via Node-apis alhoewel dit geconfigureer kan word om dit te voorkom: -- **`nodeIntegration`** - is `af` per standaard. As aan, laat dit toe om toegang te verkry tot node kenmerke vanaf die renderer proses. -- **`contextIsolation`** - is `aan` per standaard. As af, is hoof- en renderer prosesse nie geïsoleer nie. +- **`nodeIntegration`** - is `af` per standaard. As aan, laat dit toe om toegang te verkry tot node-funksies vanaf die renderer-proses. +- **`contextIsolation`** - is `aan` per standaard. As af, is hoof- en renderer-prosesse nie geïsoleer nie. - **`preload`** - leeg per standaard. - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is af per standaard. Dit sal die aksies wat NodeJS kan uitvoer beperk. - Node Integrasie in Werkers - **`nodeIntegrationInSubframes`** - is `af` per standaard. -- As **`nodeIntegration`** ge **aktiveer** is, sal dit die gebruik van **Node.js APIs** in webblaaie wat in **iframes** binne 'n Electron-toepassing gelaai word, toelaat. -- As **`nodeIntegration`** ge **deaktiveer** is, sal preloads in die iframe gelaai word. +- As **`nodeIntegration`** **geaktiveer** is, sal dit die gebruik van **Node.js APIs** in webbladsye wat in **iframes** binne 'n Electron-toepassing **gelaai** word, toelaat. +- As **`nodeIntegration`** **gedeaktiveer** is, sal preloads in die iframe gelaai word. Voorbeeld van konfigurasie: ```javascript @@ -95,9 +95,9 @@ onerror="alert(require('child_process').execSync('ls -l').toString());" /> src="x" onerror="alert(require('child_process').execSync('uname -a').toString());" /> ``` -### Vang verkeer +### Capture traffic -Wysig die start-hoof konfigurasie en voeg die gebruik van 'n proxy soos by: +Wysig die start-main konfigurasie en voeg die gebruik van 'n proxy soos by: ```javascript "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors", ``` @@ -177,7 +177,7 @@ electron-contextisolation-rce-via-ipc.md ### Bypass klik gebeurtenis -As daar beperkings toegepas word wanneer jy op 'n skakel klik, mag jy in staat wees om dit te omseil **deur 'n middelklik** in plaas van 'n gewone linkerklik te doen +As daar beperkings toegepas word wanneer jy op 'n skakel klik, mag jy in staat wees om dit te omseil **deur 'n middelklik** in plaas van 'n gewone linkerklik ```javascript window.addEventListener('click', (e) => { ``` @@ -200,9 +200,11 @@ Hierdie luisteraars word **oorheers deur die lessenaartoepassing** om sy eie **b ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>) -Electron JS sekuriteitsbeste praktyke raai teen die aanvaarding van onbetroubare inhoud met die `openExternal` funksie, aangesien dit kan lei tot RCE deur verskeie protokolle. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan ontketen. Vir gedetailleerde voorbeelde en verdere verduideliking oor hierdie onderwerp, kan 'n mens na [hierdie hulpbron](https://positive.security/blog/url-open-rce#windows-10-19042) verwys, wat Windows protokolvoorbeelde insluit wat in staat is om hierdie kwesbaarheid te benut. +Electron JS sekuriteitsbeste praktyke raai teen die aanvaarding van onbetroubare inhoud met die `openExternal` funksie, aangesien dit kan lei tot RCE deur verskeie protokolle. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan ontketen. Vir gedetailleerde voorbeelde en verdere verduideliking oor hierdie onderwerp, kan 'n mens na [hierdie hulpbron](https://positive.security/blog/url-open-rce#windows-10-19042) verwys, wat Windows-protokolvoorbeelde insluit wat in staat is om hierdie kwesbaarheid te benut. -**Voorbeelde van Windows protokolontploffings sluit in:** +In macos kan die `openExternal` funksie benut word om arbitrêre opdragte uit te voer soos in `shell.openExternal('file:///System/Applications/Calculator.app')`. + +**Voorbeelde van Windows-protokolontploffings sluit in:** ```html ``` -## **Gereedskap** +## Remote module -- [**Electronegativity**](https://github.com/doyensec/electronegativity) is 'n hulpmiddel om miskonfigurasies en sekuriteitsanti-patrone in Electron-gebaseerde toepassings te identifiseer. +Die Electron Remote module laat **renderer prosesse toegang tot hoof proses API's** toe, wat kommunikasie binne 'n Electron-toepassing vergemaklik. Dit stel egter beduidende sekuriteitsrisiko's in. Dit vergroot die toepassing se aanvaloppervlak, wat dit meer kwesbaar maak vir kwesbaarhede soos cross-site scripting (XSS) aanvalle. + +> [!TIP] +> Alhoewel die **remote** module 'n paar API's van hoof na renderer prosesse blootstel, is dit nie reguit om RCE te verkry net deur die komponente te misbruik nie. Die komponente mag egter sensitiewe inligting blootstel. + +> [!WARNING] +> Baie toepassings wat steeds die remote module gebruik, doen dit op 'n manier wat **NodeIntegration geaktiveer moet wees** in die renderer proses, wat 'n **groot sekuriteitsrisiko** is. + +Sedert Electron 14 mag die `remote` module van Electron in verskeie stappe geaktiveer word, maar weens sekuriteits- en prestasieredene is dit **aanbeveel om dit nie te gebruik nie**. + +Om dit te aktiveer, moet dit eers **in die hoof proses geaktiveer word**: +```javascript +const remoteMain = require('@electron/remote/main') +remoteMain.initialize() +[...] +function createMainWindow() { +mainWindow = new BrowserWindow({ +[...] +}) +remoteMain.enable(mainWindow.webContents) +``` +Dan kan die renderer-proses voorwerpe van die module invoer soos: +```javascript +import { dialog, getCurrentWindow } from '@electron/remote' +``` +Die **[blog pos](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** dui 'n paar interessante **funksies** aan wat deur die objek **`app`** van die afstandmodule blootgestel word: + +- **`app.relaunch([options])`** +- **Herbegin** die toepassing deur die huidige instansie te **verlaat** en 'n nuwe een te **begin**. Nuttig vir **toepassing opdaterings** of beduidende **toestand veranderinge**. +- **`app.setAppLogsPath([path])`** +- **Definieer** of **skep** 'n gids vir die stoor van **toepassing logs**. Die logs kan **herwin** of **gewysig** word met behulp van **`app.getPath()`** of **`app.setPath(pathName, newPath)`**. +- **`app.setAsDefaultProtocolClient(protocol[, path, args])`** +- **Registreer** die huidige uitvoerbare as die **standaardhandler** vir 'n spesifieke **protokol**. Jy kan 'n **aangepaste pad** en **argumente** verskaf indien nodig. +- **`app.setUserTasks(tasks)`** +- **Voeg** take by die **Take kategorie** in die **Jump List** (op Windows). Elke taak kan beheer hoe die toepassing **begin** of watter **argumente** oorgedra word. +- **`app.importCertificate(options, callback)`** +- **Importeer** 'n **PKCS#12 sertifikaat** in die stelsel se **sertifikaatwinkel** (slegs Linux). 'n **callback** kan gebruik word om die resultaat te hanteer. +- **`app.moveToApplicationsFolder([options])`** +- **Verskuif** die toepassing na die **Toepassingsgids** (op macOS). Help om 'n **standaard installasie** vir Mac-gebruikers te verseker. +- **`app.setJumpList(categories)`** +- **Stel** of **verwyder** 'n **aangepaste Jump List** op **Windows**. Jy kan **kategorieë** spesifiseer om te organiseer hoe take aan die gebruiker verskyn. +- **`app.setLoginItemSettings(settings)`** +- **Konfigureer** watter **uitvoerbare** by **aanmelding** begin saam met hul **opsies** (slegs macOS en Windows). +```javascript +Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"}); +Native.app.exit() +``` +## systemPreferences module + +Die **primêre API** vir die toegang tot stelselsvoorkeure en **uitstoot van stelselsgebeurtenisse** in Electron. Metodes soos **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, en **setUserDefault** is almal **deel van** hierdie module. + +**Voorbeeld gebruik:** +```javascript +const { systemPreferences } = require('electron'); + +// Subscribe to a specific notification +systemPreferences.subscribeNotification('MyCustomNotification', (event, userInfo) => { +console.log('Received custom notification:', userInfo); +}); + +// Get a user default key from macOS +const recentPlaces = systemPreferences.getUserDefault('NSNavRecentPlaces', 'array'); +console.log('Recent Places:', recentPlaces); +``` +### **subscribeNotification / subscribeWorkspaceNotification** + +* **Luister** na **natuurlike macOS kennisgewings** met behulp van NSDistributedNotificationCenter. +* Voor **macOS Catalina** kon jy **alle** verspreide kennisgewings afluister deur **nil** aan CFNotificationCenterAddObserver te gee. +* Na **Catalina / Big Sur** kan gesandboxde toepassings steeds **subskribere** op **baie gebeurtenisse** (byvoorbeeld, **skerm vergrendeling/ontgrendeling**, **volume monteer**, **netwerkaktiwiteit**, ens.) deur kennisgewings **per naam** te registreer. + +### **getUserDefault / setUserDefault** + +* **Interfases** met **NSUserDefaults**, wat **toepassing** of **globale** voorkeure op macOS stoor. + +* **getUserDefault** kan **sensitiewe** inligting terugkry, soos **onlangs lêer plekke** of **gebruiker se geografiese ligging**. + +* **setUserDefault** kan **wysig** hierdie voorkeure, wat moontlik 'n toepassing se **konfigurasie** kan beïnvloed. + +* In **ou Electron weergawes** (voor v8.3.0), was slegs die **standaard suite** van NSUserDefaults **toeganklik**. + +## Shell.showItemInFolder + +Hierdie funksie wys die gegewe lêer in 'n lêerbestuurder, wat **die lêer outomaties kan uitvoer**. + +Vir meer inligting, kyk na [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html) + +## **Tools** + +- [**Electronegativity**](https://github.com/doyensec/electronegativity) is 'n hulpmiddel om misconfigurasies en sekuriteits anti-patrone in Electron-gebaseerde toepassings te identifiseer. - [**Electrolint**](https://github.com/ksdmitrieva/electrolint) is 'n oopbron VS Code-inprop vir Electron-toepassings wat Electronegativity gebruik. -- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) om kwesbare derdeparty-biblioteke te kontroleer. +- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) om te kyk vir kwesbare derdeparty biblioteke. - [**Electro.ng**](https://electro.ng/): Jy moet dit koop. -## Laboratoriums +## Labs In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) kan jy 'n laboratorium vind om kwesbare Electron-toepassings te benut. @@ -309,5 +399,6 @@ npm start - [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) - Meer navorsing en skrywe oor Electron-sekuriteit in [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking) - [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81) +- [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html) {{#include ../../../banners/hacktricks-training.md}}