0Pricing
Electron Desktop App Development · Pelajaran

Pola IPC yang Aman

Terapkan praktik terbaik IPC, termasuk memvalidasi bingkai pengirim, membersihkan input, dan menghindari celah keamanan umum.

Pola IPC yang Aman adalah pelajaran Electron Desktop App Development gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Electron Desktop App Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Electron Desktop App Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola IPC yang Aman” gratis?

Ya — teks lengkap “Pola IPC yang Aman” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Electron Desktop App Development, upgrade ke CoddyKit PRO. Kursus Electron Desktop App Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pola IPC yang Aman”?

Terapkan praktik terbaik IPC, termasuk memvalidasi bingkai pengirim, membersihkan input, dan menghindari celah keamanan umum. Kamu berlatih Electron Desktop App Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Electron Desktop App Development?

Tidak diperlukan pengalaman sebelumnya. Electron Desktop App Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Pola IPC yang Aman” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Electron Desktop App Development ini?

Ya. Setiap pelajaran Electron Desktop App Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pola IPC yang Aman
  2. Isolasi Konteks & Skrip Pramuat
  3. Sandbox Proses Perender
  4. Memperkuat Perlindungan dari Risiko Konten Jarak Jauh
← Kembali ke Electron Desktop App Development