← Back to Blog

Developers & Code | Published Jul 14, 2026 | Updated Nov 21, 2026 | 6 min read

How to Check an Electron App's Security Settings (IPC)

By Deepender Yadav

How to Check an Electron App's Security Settings (IPC) — Edge Drop Guide

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

SettingSecure valueDefault sinceWhat it protects against
nodeIntegrationfalseElectron 5Page scripts calling Node.js directly, for example to read files or start programs
contextIsolationtrueElectron 12Page scripts tampering with the preload script's objects to reach privileged APIs
sandboxtrueElectron 20A 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.

  1. Find the install folder. Open Task Manager, right-click the app's process, and select Open file location.
  2. Confirm it's Electron. Look for a resources folder containing app.asar (or an app folder). That archive holds the app's JavaScript.
  3. Copy app.asar to a working folder. Work on the copy, not the installed file.
  4. Extract it. In a terminal in that folder, run:
npx @electron/asar extract app.asar app-source
  1. Find the window settings. Search the extracted files for webPreferences, contextIsolation, nodeIntegration and sandbox. Bundled code may be minified, but these property names usually survive.
  2. Find the preload bridge. Search for exposeInMainWorld and read what it exposes.
  3. List the IPC handlers. Search for ipcMain.handle and ipcMain.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: false or sandbox: false on a window that shows web content
  • webSecurity: false
  • ipcRenderer exposed 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.openExternal called 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.ts with contextIsolation: true, nodeIntegration: false and sandbox: true.
  • Preload bridge: electron/preload/ exposes the app's API to the page as window.edge. The allowed channels are defined as typed maps in shared/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

Sources

Deepender Yadav
Written by Deepender Yadav · Creator & Developer

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 · LinkedIn

Copy. 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
Find us on CodeHype