Electron Desktop App Development · 课时

安全的 IPC 模式

实施 IPC 最佳实践，包括验证发送方框架、清理输入，以及避免常见的安全隐患

安全的 IPC 模式 是 CoddyKit 上的免费 Electron Desktop App Development 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Electron Desktop App Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Electron Desktop App Development 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Secure IPC Matters

Electron applications combine the power of web technologies with native desktop capabilities. This means different parts of your app (like the web page and the main process) need to communicate.

This communication is called Inter-Process Communication (IPC). If not handled carefully, IPC can become a major security weakness, allowing attackers to compromise your application or the user's system.

Understanding IPC Security Risks

Insecure IPC patterns can lead to severe vulnerabilities:

Remote Code Execution (RCE): An attacker could execute arbitrary code on the user's machine.
Cross-Site Scripting (XSS): Malicious scripts injected into the renderer could steal data or compromise the app's functionality.
Privilege Escalation: A less-privileged renderer process could gain access to more powerful main process capabilities.

Principle: Least Privilege

The principle of least privilege is a core security concept. It means giving each part of your application only the absolute minimum access and permissions it needs to perform its specific task.

Don't expose more main process functionality than necessary to the renderer.
Limit the types of data that can be sent or requested via IPC.
Keep your IPC channels narrowly focused on specific operations.

Principle: Input Validation

Always validate and sanitize any data received from the renderer process before the main process acts on it. Treat all input from the renderer as potentially malicious.

Check data types, formats, and expected content.
Prevent path traversal attacks (e.g., ../../secret.txt) or SQL/command injection flaws.
Use libraries for sanitization where appropriate.

Insecure IPC Example

This example shows an insecure way for the renderer to request a file. It trusts the renderer's input completely, which is dangerous.

Note: This is for demonstration only. Do NOT use such patterns in a real application!

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const fs = require('fs'); // Node.js 'fs' module

let mainWindow;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      // DANGER: contextIsolation should be true
      // DANGER: nodeIntegration should be false
    }
  });
  mainWindow.loadFile('index.html');
}

app.whenReady().then(() => {
  createWindow();

  // INSECURE IPC handler - trusts renderer input directly
  ipcMain.on('read-file-insecure', (event, filePath) => {
    // No validation! Renderer could send 'C:/Windows/System32/drivers/etc/hosts'
    fs.readFile(filePath, 'utf8', (err, data) => {
      if (err) {
        console.error('Insecure read error:', err.message);
        event.sender.send('file-data', `Error: ${err.message}`);
        return;
      }
      event.sender.send('file-data', `Content: ${data.substring(0, 100)}...`);
    });
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

Secure IPC with Validation

To secure the previous example, we must validate the filename from the renderer. This code restricts file access to a specific 'data' folder within the app's user data directory.

It checks input type, resolves the path safely, and prevents accessing files outside the allowed directory.

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const fs = require('fs');

let mainWindow;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true // Use context isolation!
    }
  });
  mainWindow.loadFile('index.html');
}

app.whenReady().then(() => {
  createWindow();

  // SECURE IPC handler - with validation
  ipcMain.on('read-file-secure', (event, filename) => {
    // 1. Validate input type and content
    if (typeof filename !== 'string' || filename.trim() === '' || filename.includes(path.sep)) {
      event.sender.send('file-data', 'Error: Invalid filename provided.');
      return;
    }

    // 2. Define allowed directory (e.g., in app data)
    const allowedDir = path.join(app.getPath('userData'), 'data');
    if (!fs.existsSync(allowedDir)) {
      fs.mkdirSync(allowedDir, { recursive: true });
    }

    // 3. Resolve full path, ensuring it's within allowedDir (path traversal check)
    const fullPath = path.join(allowedDir, filename);
    if (!fullPath.startsWith(allowedDir)) {
      event.sender.send('file-data', 'Error: Access denied. Invalid path.');
      return;
    }

    fs.readFile(fullPath, 'utf8', (err, data) => {
      if (err) {
        console.error('Secure read error:', err.message);
        event.sender.send('file-data', `Error: ${err.message}`);
        return;
      }
      event.sender.send('file-data', `Content: ${data.substring(0, 100)}...`);
    });
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

Context Isolation & Preload Scripts

While covered in more detail in the next lesson, Context Isolation is a fundamental security feature for IPC. It ensures your renderer's JavaScript runs in a separate context, preventing it from directly accessing Node.js APIs or Electron internals.

Use Preload Scripts (run before the renderer's content) to safely expose specific, validated functions to the renderer via the contextBridge module.
This setup prevents malicious scripts (e.g., from an XSS attack) from hijacking your Node.js environment.

Sanitizing Output Data

Just as you validate input, it's good practice to consider sanitizing any data sent from the main process back to the renderer, especially if that data might include user-generated content or come from external sources.

If displaying user-generated content, escape HTML characters to prevent XSS vulnerabilities in the UI.
Ensure that data sent back to the renderer is in an expected and safe format.
This prevents the main process from accidentally introducing vulnerabilities into the UI.

Common IPC Pitfalls

Avoid these common mistakes that can lead to insecure IPC:

Over-exposing the remote module: The remote module (now deprecated) grants the renderer direct access to main process modules. Avoid using it.
Using eval(): Never use eval() with untrusted input, as it can execute arbitrary code.
Disabling security features: Avoid setting nodeIntegration: true or contextIsolation: false in your webPreferences, as these disable critical security protections.

Secure IPC Check

Which of the following is considered a best practice for securing Inter-Process Communication (IPC) in Electron?

Recap: Secure IPC Patterns

You've learned that secure IPC is fundamental for building robust and safe Electron applications:

Apply the principle of least privilege, exposing only necessary functionality.
Always validate and sanitize inputs from the renderer process.
Consider sanitizing outputs before sending data back to the renderer, especially user-generated content.
Avoid common pitfalls like over-exposing the remote module or disabling critical security features like context isolation.

Next, we'll dive deeper into Context Isolation and Preload Scripts, which are essential for implementing these secure patterns effectively.

常见问题解答

「安全的 IPC 模式」课时是免费的吗？

是的 — 「安全的 IPC 模式」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Electron Desktop App Development 课程的其余内容，请升级到 CoddyKit PRO。 Electron Desktop App Development 课程共包含 4 节课。

「安全的 IPC 模式」这节课中我会学到什么？

实施 IPC 最佳实践，包括验证发送方框架、清理输入，以及避免常见的安全隐患你通过在浏览器中直接运行的动手代码来练习 Electron Desktop App Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Electron Desktop App Development 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Electron Desktop App Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「安全的 IPC 模式」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Electron Desktop App Development 课中编写并运行代码吗？

能。每节 Electron Desktop App Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Electron Desktop App Development