Sandlåda för renderer-processen
Aktivera och konfigurera sandlådefunktioner för Era renderer-processer för att begränsa deras åtkomst till systemresurser och förbättra applikationens säkerhet.
Sandlåda för renderer-processen är en gratis lektion i Utveckling av skrivbordsappar med Electron på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Utveckling av skrivbordsappar med Electron, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Utveckling av skrivbordsappar med Electron innehåller totalt 4 lektioner.
Vad är sandboxning?
Föreställ er datorn som ett hus. Vissa gäster (appar) litar ni helt på, medan andra vill ni hålla i ett särskilt rum med begränsad åtkomst.
Sandboxning liknar att placera appens renderingsprocess i ett säkert, isolerat ”rum”. Det begränsar vad den delen av appen kan göra och komma åt i systemet.
Detta är avgörande för säkerheten, särskilt när ni visar otillförlitligt webbinnehåll eller skyddar mot skadliga skript.
Varför sandboxning är viktigt
Electron-appar kombinerar webbinnehåll (HTML, CSS, JS) med inbyggda skrivbordsfunktioner. Utan korrekt isolering kan en sårbarhet i webbinnehållet utnyttjas för att få åtkomst till användarens filsystem eller andra systemresurser.
Sandboxning förhindrar detta genom att isolera renderingsprocessen, vilket gör det mycket svårare för skadlig kod att ”ta sig ut” och skada användarens system.
Chromiums säkerhetslager
Electron använder Chromium, samma motor som driver Google Chrome. En viktig säkerhetsfunktion i Chromium är dess sandbox för renderingsprocessen.
I webbläsare körs webbsidor som standard i en sandboxad renderingsprocess, vilket innebär att de inte kan interagera direkt med operativsystemet. Electron utökar denna robusta säkerhetsmodell till era skrivbordsapplikationer.
Aktivera sandboxning
Det är enkelt att aktivera sandboxning i Electron. Gör det när ni skapar ett nytt BrowserWindow genom att ange alternativet sandbox som true i webPreferences.
Detta är ett avgörande steg för att stärka säkerheten i Electron-applikationen.
const { app, BrowserWindow } = require('electron');
function createWindow () {
const win = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
sandbox: true // Set to true to enable sandboxing
}
});
win.loadFile('index.html'); // Loads your web content
}
app.whenReady().then(createWindow);
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});Begränsningar för renderingsprocessen
När en renderingsprocess är sandboxad omfattas den av betydande begränsningar:
- Den kan inte få direkt åtkomst till Node.js-API:er (t.ex.
require,process,fs). - Den kan inte använda inbyggda moduler.
- Dess åtkomst till systemresurser (som filer) är kraftigt begränsad.
Denna isolering hindrar webbinnehåll från att utföra obehöriga åtgärder på användarens dator.
Demo: Node.js-åtkomst nekas
Vi ska se vad som händer när en sandboxad renderingsprocess försöker få direkt åtkomst till Node.js. Koden nedan skapar ett fönster med aktiverad sandboxning och försöker använda modulen fs.
Kör exemplet och kontrollera utvecklarkonsolen (vanligtvis F12 eller Cmd+Option+I) efter felmeddelandet.
const { app, BrowserWindow } = require('electron');
function createWindow () {
const win = new BrowserWindow({
width: 600,
height: 400,
webPreferences: {
sandbox: true, // Sandboxing enabled
nodeIntegration: false, // Explicitly disabled (default with sandbox)
contextIsolation: true // Explicitly enabled (default with sandbox)
}
});
// Load HTML that tries to use Node.js 'fs' module
win.loadURL(`data:text/html;charset=utf-8,
<!DOCTYPE html>
<html>
<head>
<title>Sandboxed Demo</title>
</head>
<body>
<h1>Sandboxed Renderer Test</h1>
<p id="message">Attempting to access Node.js...</p>
<script>
try {
const fs = require('fs'); // This will fail!
document.getElementById('message').innerText = 'Node.js fs module loaded!';
} catch (error) {
document.getElementById('message').innerText = 'Error: ' + error.message;
console.error('Renderer error:', error);
}
</script>
</body>
</html>
`);
win.webContents.openDevTools(); // Open DevTools to see the error
}
app.whenReady().then(createWindow);
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});Säker interaktion: Preload
Eftersom sandboxade renderingsprocesser inte kan få direkt åtkomst till Node.js, hur utför de systemåtgärder?
Ni använder preload-skript med kontextisolering. Dessa skript körs före webbinnehållet, har åtkomst till Node.js och kan på ett säkert sätt exponera ett begränsat API för den sandboxade renderingsprocessen via contextBridge.
Detta säkerställer att huvudprocessen exakt styr vilken funktionalitet som exponeras.
Sandboxning och kontextisolering
Det är viktigt att notera att när webPreferences.sandbox är true blir både nodeIntegration false och contextIsolation true som standard, oavsett vad ni uttryckligen anger.
Denna kombination ger det starkaste skyddet för era renderingsprocesser.
Bästa praxis
- Aktivera alltid sandboxning: Det är en grundläggande säkerhetsåtgärd.
- Minimera exponerade API:er: Exponera endast nödvändig funktionalitet via preload-skript.
- Validera all indata: Alla data som skickas från en renderingsprocess till huvudprocessen ska valideras.
Dessa metoder skapar en robust och säker Electron-applikation.
Snabbkontroll
Att förstå sandboxning är avgörande för att bygga säkra Electron-applikationer.
Sammanfattning: Skydda er app
I den här lektionen utforskade vi sandboxning i Electron. Vi lärde oss att det är en kritisk säkerhetsfunktion som isolerar renderingsprocesserna och hindrar dem från att få direkt åtkomst till systemresurser eller Node.js-API:er.
Genom att ange webPreferences.sandbox: true aktiverar ni detta kraftfulla skydd och säkerställer en säkrare applikation. Kom ihåg att använda preload-skript med kontextisolering för säker kommunikation mellan den sandboxade renderingsprocessen och huvudprocessen.
Lär dig JavaScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 47
Vanliga frågor
Är lektionen ”Sandlåda för renderer-processen” gratis?
Ja – hela texten till ”Sandlåda för renderer-processen” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Utveckling av skrivbordsappar med Electron, kan Ni uppgradera till CoddyKit PRO. Kursen i Utveckling av skrivbordsappar med Electron innehåller totalt 4 lektioner.
Vad lär jag mig i ”Sandlåda för renderer-processen”?
Aktivera och konfigurera sandlådefunktioner för Era renderer-processer för att begränsa deras åtkomst till systemresurser och förbättra applikationens säkerhet. Ni övar på Utveckling av skrivbordsappar med Electron med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Utveckling av skrivbordsappar med Electron?
Du behöver inga förkunskaper. Utbildningen i Utveckling av skrivbordsappar med Electron på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Sandlåda för renderer-processen”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Utveckling av skrivbordsappar med Electron-lektionen?
Ja. Varje Utveckling av skrivbordsappar med Electron-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Säkra IPC-mönster
- Isolering av kontext och preload-skript
- Sandlåda för renderer-processen
- Skydd mot risker med fjärrinnehåll