Electron Desktop App Development · Leçon

Modèles IPC sécurisés

Mettez en œuvre les bonnes pratiques IPC, notamment la validation des cadres de l’émetteur, l’assainissement des entrées et l’évitement des failles de sécurité courantes.

Modèles IPC sécurisés est une leçon Electron Desktop App Development gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Electron Desktop App Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Electron Desktop App Development comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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.

Questions Fréquemment Posées

La leçon « Modèles IPC sécurisés » est-elle gratuite ?

Oui — le texte complet de « Modèles IPC sécurisés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Electron Desktop App Development, passe à CoddyKit PRO. Le cours Electron Desktop App Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèles IPC sécurisés » ?

Mettez en œuvre les bonnes pratiques IPC, notamment la validation des cadres de l’émetteur, l’assainissement des entrées et l’évitement des failles de sécurité courantes. Tu pratiques Electron Desktop App Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Electron Desktop App Development ?

Aucune expérience préalable n'est requise. Electron Desktop App Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Modèles IPC sécurisés » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Electron Desktop App Development ?

Oui. Chaque leçon Electron Desktop App Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Electron Desktop App Development