Desktopapplicaties ontwikkelen met Electron · Les

Beveiligde IPC-patronen

Implementeer best practices voor IPC, waaronder het valideren van afzenderframes, het opschonen van invoer en het vermijden van veelvoorkomende beveiligingsvalkuilen.

Les 1 van 411 stappen

Beveiligde IPC-patronen is een gratis Desktopapplicaties ontwikkelen met Electron-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Desktopapplicaties ontwikkelen met Electron. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Desktopapplicaties ontwikkelen met Electron bevat in totaal 4 lessen.

Waarom veilige IPC belangrijk is

Electron-applicaties combineren de kracht van webtechnologieën met systeemeigen mogelijkheden van desktops. Dit betekent dat verschillende onderdelen van uw app (zoals de webpagina en het hoofdproces) met elkaar moeten communiceren.

Deze communicatie heet interprocescommunicatie (IPC). Als IPC niet zorgvuldig wordt afgehandeld, kan het een grote beveiligingszwakte worden, waardoor aanvallers uw applicatie of het systeem van de gebruiker kunnen compromitteren.

Beveiligingsrisico's van IPC begrijpen

Onveilige IPC-patronen kunnen leiden tot ernstige kwetsbaarheden:

Uitvoering van externe code (RCE): Een aanvaller kan willekeurige code uitvoeren op de computer van de gebruiker.
Cross-site scripting (XSS): Schadelijke scripts die in het rendererproces zijn geïnjecteerd, kunnen gegevens stelen of de werking van de app compromitteren.
Privilegeverhoging: Een rendererproces met minder rechten kan toegang krijgen tot krachtigere mogelijkheden van het hoofdproces.

Principe: minimale rechten

Het principe van minimale rechten is een belangrijk beveiligingsconcept. Het betekent dat elk onderdeel van uw applicatie alleen de strikt minimaal benodigde toegang en machtigingen krijgt om zijn specifieke taak uit te voeren.

Stel niet meer functionaliteit van het hoofdproces beschikbaar aan het rendererproces dan nodig is.
Beperk de soorten gegevens die via IPC kunnen worden verzonden of opgevraagd.
Houd uw IPC-kanalen strikt gericht op specifieke bewerkingen.

Principe: invoer valideren

Valideer en zuiver gegevens die u van het rendererproces ontvangt altijd voordat het hoofdproces ermee aan de slag gaat. Beschouw alle invoer van het rendererproces als mogelijk schadelijk.

Controleer gegevenstypen, indelingen en verwachte inhoud.
Voorkom aanvallen via padtraversal (bijvoorbeeld ../../secret.txt) en fouten door SQL- of commando-injectie.
Gebruik waar passend bibliotheken voor het zuiveren van gegevens.

Onveilig IPC-voorbeeld

Dit voorbeeld laat een onveilige manier zien waarop het rendererproces om een bestand kan vragen. Het vertrouwt de invoer van het rendererproces volledig, wat gevaarlijk is.

Let op: Dit is alleen bedoeld ter demonstratie. Gebruik dergelijke patronen NIET in een echte applicatie!

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();
});

Veilige IPC met validatie

Om het vorige voorbeeld te beveiligen, moeten we filename uit het rendererproces valideren. Deze code beperkt bestandstoegang tot een specifieke map 'data' binnen de map met gebruikersgegevens van de app.

De code controleert het invoertype, lost het pad veilig op en voorkomt toegang tot bestanden buiten de toegestane map.

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();
});

Contextisolatie en preloadscripts

Hoewel dit in meer detail in de volgende les wordt behandeld, is contextisolatie een fundamentele beveiligingsfunctie voor IPC. Deze zorgt ervoor dat de JavaScript-code van uw rendererproces in een afzonderlijke context wordt uitgevoerd, zodat deze niet rechtstreeks toegang heeft tot Node.js-API's of interne onderdelen van Electron.

Gebruik preloadscripts (die vóór de inhoud van het rendererproces worden uitgevoerd) om via de module contextBridge veilig specifieke, gevalideerde functies beschikbaar te maken voor het rendererproces.
Deze opzet voorkomt dat schadelijke scripts (bijvoorbeeld door een XSS-aanval) uw Node.js-omgeving overnemen.

Uitvoergegevens zuiveren

Net zoals u invoer valideert, is het verstandig om gegevens die vanuit het hoofdproces terug naar het rendererproces worden gestuurd te zuiveren, vooral als deze gegevens door de gebruiker zijn gegenereerd of afkomstig zijn van externe bronnen.

Als u door gebruikers gegenereerde inhoud weergeeft, escapet u HTML-tekens om XSS-kwetsbaarheden in de gebruikersinterface te voorkomen.
Zorg ervoor dat gegevens die naar het rendererproces worden teruggestuurd de verwachte en veilige indeling hebben.
Zo voorkomt u dat het hoofdproces per ongeluk kwetsbaarheden in de gebruikersinterface introduceert.

Veelvoorkomende valkuilen bij IPC

Vermijd deze veelvoorkomende fouten die tot onveilige IPC kunnen leiden:

De module remote te veel blootstellen: De module remote (nu verouderd) geeft het rendererproces rechtstreeks toegang tot modules van het hoofdproces. Gebruik deze module niet.
eval() gebruiken: Gebruik eval() nooit met niet-vertrouwde invoer, omdat hiermee willekeurige code kan worden uitgevoerd.
Beveiligingsfuncties uitschakelen: Vermijd het instellen van nodeIntegration: true of contextIsolation: false in uw webPreferences, omdat hiermee essentiële beveiligingen worden uitgeschakeld.

Controle van veilige IPC

Welke van de volgende opties geldt als een best practice voor het beveiligen van Inter-Process Communication (IPC) in Electron?

Beantwoord dit in de interactieve les

Samenvatting: patronen voor veilige IPC

U hebt geleerd dat veilige IPC essentieel is voor het bouwen van robuuste en veilige Electron-toepassingen:

Pas het principe van minimale bevoegdheden toe en stel alleen noodzakelijke functionaliteit beschikbaar.
Valideer en zuiver invoer uit het rendererproces altijd.
Overweeg uitvoer te zuiveren voordat u gegevens terugstuurt naar het rendererproces, vooral bij inhoud die door gebruikers is gemaakt.
Vermijd veelvoorkomende valkuilen, zoals het te veel blootstellen van de module remote of het uitschakelen van essentiële beveiligingsfuncties zoals contextisolatie.

Vervolgens gaan we dieper in op Context Isolation en Preload Scripts. Deze zijn essentieel om deze veilige patronen effectief te implementeren.

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 47

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Beveiligde IPC-patronen” gratis?

Ja — de volledige tekst van “Beveiligde IPC-patronen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Desktopapplicaties ontwikkelen met Electron wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Desktopapplicaties ontwikkelen met Electron bevat in totaal 4 lessen.

Wat leer ik in “Beveiligde IPC-patronen”?

Implementeer best practices voor IPC, waaronder het valideren van afzenderframes, het opschonen van invoer en het vermijden van veelvoorkomende beveiligingsvalkuilen. Je oefent met Desktopapplicaties ontwikkelen met Electron door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Desktopapplicaties ontwikkelen met Electron te beginnen?

Ervaring vooraf is niet nodig. Desktopapplicaties ontwikkelen met Electron op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Beveiligde IPC-patronen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Desktopapplicaties ontwikkelen met Electron?

Ja. Elke les over Desktopapplicaties ontwikkelen met Electron bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Beveiligde IPC-patronen
Contextisolatie en preloadscripts
Het rendererproces sandboxen
Bescherming tegen risico's van externe inhoud

← Terug naar Desktopapplicaties ontwikkelen met Electron