How to Check an Electron App's Security Settings (IPC)
To check an Electron app's security settings, look at three things: the webPreferences of each BrowserWindow (contextIsolation should be true, nodeIntegration false, sandbox true), the API its preload script exposes through contextBridge (a short list of named functions, not raw ipcRenderer), and the ipcMain handlers that receive those calls. If the app isn't open source, you can still read this code by extracting its app.asar archive. These checks show how well the app contains a bug in its interface code. They don't show whether it sends your data anywhere; for that, you need to watch its network traffic.
How Electron's IPC works
Every Electron app has a main process, which runs Node.js with full access to files, the network and the operating system, and one or more renderer processes, which display the interface as a web page. The renderer can't touch the system directly. It asks the main process to do things over inter-process communication (IPC).
A preload script sits between them. It runs before the page loads and decides which main-process features the page can call. The shape of that bridge, plus three window settings, decides how much damage a malicious page or a bug in the interface code could do.
The three settings to check
| Setting | Secure value | Default since | What it protects against |
|---|---|---|---|
nodeIntegration | false | Electron 5 | Page scripts calling Node.js directly, for example to read files or start programs |
contextIsolation | true | Electron 12 | Page scripts tampering with the preload script's objects to reach privileged APIs |
sandbox | true | Electron 20 | A compromised renderer, or the preload, having full Node.js access |
Electron's security checklist lists all three as recommendations, along with validating the sender of every IPC message, not exposing Electron APIs such as IPC directly to web content, defining a Content Security Policy, and not passing untrusted content to shell.openExternal. Because these are the defaults in current Electron, the thing to look for is an app that turns them off.
How to check an installed Electron app
You need Node.js installed for step 4.
- Find the install folder. Open Task Manager, right-click the app's process, and select Open file location.
- Confirm it's Electron. Look for a
resourcesfolder containingapp.asar(or anappfolder). That archive holds the app's JavaScript. - Copy
app.asarto a working folder. Work on the copy, not the installed file. - Extract it. In a terminal in that folder, run:
npx @electron/asar extract app.asar app-source
- Find the window settings. Search the extracted files for
webPreferences,contextIsolation,nodeIntegrationandsandbox. Bundled code may be minified, but these property names usually survive. - Find the preload bridge. Search for
exposeInMainWorldand read what it exposes. - List the IPC handlers. Search for
ipcMain.handleandipcMain.on. Each match is a channel the interface can call.
To list the archive's contents without extracting, use npx @electron/asar list app.asar.
What a good preload looks like
A narrow bridge exposes a few named functions, each wired to one channel:
const { contextBridge, ipcRenderer } = require('electron');
contextBridge.exposeInMainWorld('api', {
pinItem: (id) => ipcRenderer.invoke('item:pin', id),
deleteItem: (id) => ipcRenderer.invoke('item:delete', id),
});
A risky bridge hands the page the whole IPC system:
const { contextBridge, ipcRenderer } = require('electron');
// Avoid: the page can now call any channel the main process listens on
contextBridge.exposeInMainWorld('ipcRenderer', ipcRenderer);
Electron's security guide warns against exactly this, because exposing raw IPC gives the page access to every channel the main process has registered.
Red flags
nodeIntegration: true,contextIsolation: falseorsandbox: falseon a window that shows web contentwebSecurity: falseipcRendererexposed directly, or a preload that passes any channel name through- Handlers that take a file path, URL or command from the page and use it without checking it
shell.openExternalcalled on text that came from copied content or a web page- Windows that load remote websites rather than the app's own files
None of these proves the app is malicious. Each one widens what a bug in the interface code could do, and is worth asking about on the project's issue tracker.
What this check can't tell you
Window settings and IPC handlers describe how the app is built, not what it does with your data. They won't show:
- Network traffic. Whether the app phones home. How to check whether a desktop app has telemetry covers capturing its connections.
- Storage. What it saves to disk and whether that's encrypted.
- Future versions. An update can change any of this. Recheck after major releases.
For clipboard managers specifically, whether other apps can read everything you copy explains why any desktop app can read the clipboard, Electron or not.
Example: Edge Drop
Edge Drop 0.4.0 is an Electron 45 app with public source, so there's no archive to extract:
- Window settings: the shelf window is created in
electron/main/window.tswithcontextIsolation: true,nodeIntegration: falseandsandbox: true. - Preload bridge:
electron/preload/exposes the app's API to the page aswindow.edge. The allowed channels are defined as typed maps inshared/ipc.ts. - Content Security Policy: the page may only connect to itself (
connect-src 'self' ws:) and load images from local sources. - Links: web links open in your default browser, not inside the app.
The source is under the Apache License 2.0; the licence comparison explains what that allows. To compare Electron with the main alternative for small desktop utilities, see Electron or Tauri for a clipboard overlay.
FAQ
Is it legal to extract an app's app.asar?
Reading an app's files on your own PC to understand what it does is generally fine, but check the app's licence before you copy, modify or redistribute any of its code.
Does contextIsolation make an Electron app safe?
It closes one important gap, but it's one of several layers. A preload that exposes too much, or IPC handlers that trust their input, can undo it.
How do I know which Electron version an app uses?
For open-source apps, check package.json. For others, the version is often recorded in the extracted files, and newer Electron versions include the security defaults listed above.
Related reading
- How to Check If a Windows App Has Telemetry
- Electron vs Tauri for Overlay Apps: Drag-Out, Focus, Memory
- Should You Use a Beta Desktop App? A Checklist for Windows
- How to Audit Whether a Clipboard App Talks to the Network
Sources
- Security (Electron documentation) — the security checklist, default versions, IPC sender validation and the warning against exposing raw IPC.
- Context Isolation (Electron documentation) — what context isolation separates.
- Process Sandboxing (Electron documentation) — what the sandbox removes from renderers and preloads.
- Process Model (Electron documentation) — main, renderer and preload processes.
- contextBridge (Electron documentation) — exposing APIs from a preload script.
- @electron/asar (GitHub) — the
extractandlistcommands. - Edge Drop repository (GitHub) — window settings, preload and IPC definitions.
Deepender Yadav created Edge Drop and builds and tests it, from the edge-hover shelf to each release. A B.Tech Computer Science Engineering student, Deepender writes the Edge Drop guides, comparisons and developer posts, and checks product details against the app's source code.
GitHub · LinkedInCopy. Stack. Drop.
Transform your clipboard into an interactive edge shelf. Stack, pin, and drag assets into any app with zero friction.
Download for Windows Get from Microsoft Store
How to Install Guide · First 10 Minutes Guide · Drag & Drop Guide · Edge Drop vs Win+V · Support
Free · Lightweight · Privacy First