メニュー
Systematic security audit of Electron IPC handlers covering path validation, process lifecycle, environment leakage, network security, and authentication gaps
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/jasonkneen/codesurf --skill electron-ipc-security-auditコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SOC 職業分類に基づく
SKILL.md を表示中
| name | electron-ipc-security-audit |
| description | Systematic security audit of Electron IPC handlers covering path validation, process lifecycle, environment leakage, network security, and authentication gaps |
| source | auto-skill |
| extracted_at | 2026-06-22T14:40:44.079Z |
Systematic approach to finding and fixing security vulnerabilities in Electron main process IPC handlers.
Problem: IPC handlers accept user-controlled paths without validation, enabling directory traversal or access to sensitive locations.
Detection:
ipcMain.handle calls that accept path/directory parametersvalidateFsPath or equivalent validation is called before using the pathshell.openExternal with file:// URLs that bypass path validationExample Fix:
ipcMain.handle('terminal:create', async (event, tileId: string, workspaceDir: string) => {
{ validateFsPath } = ()
{
workspaceDir = (workspaceDir)
} (err) {
{ : }
}
})
Problem: Broadcast helpers iterate windows without checking if they're destroyed, causing crashes when windows close during async operations.
Detection:
BrowserWindow.getAllWindows() followed by .send() callsisDestroyed() or webContents.isDestroyed() guardsExample Fix:
function broadcastMessageChange(payload: any): void {
for (const win of BrowserWindow.getAllWindows()) {
if (win.isDestroyed() || win.webContents.isDestroyed()) continue
win.webContents.send('collab:messageChanged', payload)
}
}
Problem: PTY/agent spawns inherit entire process.env, leaking API keys and tokens to child processes.
Detection:
spawn or exec calls with ...process.envenv: { ...process.env, EXTRA_VAR: value }Fix Pattern:
const SPAWN_ENV_ALLOWLIST = new Set([
'PATH', 'HOME', 'SHELL', 'USER', 'TERM', 'TMPDIR',
// Platform-specific essentials
...(process.platform === 'win32' ? ['SystemRoot', 'COMSPEC'] : []),
])
const SPAWN_ENV_DENYLIST_RE = /(_API_KEY|_SECRET|_TOKEN|_PASSWORD)$/i
export function buildSafeSpawnEnv(extra = {}): Record<string, string> {
const env: Record<string, string> = {}
for (const [key, value] of Object.entries(process.env)) {
if (SPAWN_ENV_ALLOWLIST.has(key) && !SPAWN_ENV_DENYLIST_RE.test(key)) {
env[key] = value
}
}
return { ...env, ...extra }
}
Problem: URL validation checks hostname strings but doesn't resolve DNS, allowing attacker domains that resolve to private IPs (127.0.0.1, 169.254.169.254).
Detection:
assertSafeStreamUrl or similardns.lookup or dns.resolve is called before connectingFix Pattern:
import { promises as dnsPromises } from 'dns'
// After URL validation, before HTTP request:
const lookup = await dnsPromises.lookup(url.hostname, { family: 0 })
const resolvedAddress = lookup.address
// Re-validate the resolved IP
assertSafeStreamUrl(`${url.protocol}//${resolvedAddress}:${url.port}${url.pathname}`)
// Use resolved IP for connection, preserve Host header
const options = {
hostname: resolvedAddress,
headers: { 'Host': url.host }
}
Problem: Loopback-bound HTTP servers lack authentication, allowing any local process to use them.
Detection:
http.createServer or http.Server in main processFix Pattern:
import { randomUUID } from 'crypto'
let proxyToken: string | null = null
function createProxyServer(port: number, token: string): http.Server {
return http.createServer(async (req, res) => {
// Health check doesn't need auth
if (req.method === 'GET' && req.url === '/health') {
res.writeHead(200)
res.end(JSON.stringify({ status: 'ok' }))
return
}
// Require Bearer token for all other requests
const authHeader = req.headers.authorization
if (!authHeader || authHeader !== `Bearer ${token}`) {
res.writeHead(401)
res.end(JSON.stringify({ error: 'Missing or invalid bearer token' }))
return
}
// ... handle request
})
}
async function startProxyServer(port: number) {
proxyToken = randomUUID()
const server = createProxyServer(port, proxyToken)
// ... start server
}
Problem: SSE/NDJSON parsers emit done events on both protocol signals (message_stop, [DONE]) and HTTP end event, causing duplicate terminal events.
Detection:
sendStream({ type: 'done' }) calls in same parserFix Pattern:
export function parseClaudeStream(cardId: string, res: IncomingMessage): void {
let doneSent = false
const sendDone = (): void => {
if (doneSent) return
doneSent = true
sendStream(cardId, { cardId, type: 'done' })
}
res.on('data', (chunk) => {
// ... parse SSE events
if (evt.type === 'message_stop') {
sendDone() // Protocol-level completion
}
})
res.on('end', () => sendDone()) // HTTP stream end
}
Problem: Main process entry file (index.ts) accumulates 30+ inline ipcMain.handle calls alongside window management, app lifecycle, and branding code.
Detection:
ipcMain.handle calls in entry file vs dedicated src/main/ipc/*.ts modulesawait import('fs') patterns unique to inline handlersExtraction Pattern:
// src/main/ipc/owl.ts
import { ipcMain } from 'electron'
import { getOwlSupervisor, stopOwlSupervisor } from '../owl/runtime'
export function registerOwlIPC(): void {
ipcMain.handle('owl:health', () => getOwlSupervisor().call('health', {}))
// ... other handlers
}
// src/main/index.ts — replace inline handlers with:
import { registerOwlIPC } from './ipc/owl'
// In app.whenReady():
registerOwlIPC()
For handlers that need shared state (window creation, title maps), pass a context object:
export interface WindowIPCContext {
createWindow: (opts?) => BrowserWindow
windowTitles: Map<number, string>
broadcastWindowList: () => void
}
export function registerWindowIPC(ctx: WindowIPCContext): void {
ipcMain.handle('window:setTitle', (event, title) => {
ctx.windowTitles.set(event.sender.id, title)
ctx.broadcastWindowList()
})
}
Problem: Canvas pointer position stored as useState triggers full App re-render on every mouse move (60fps), even when no component reads the value during render.
Detection:
useState values that are SET on every mousemove/wheel/pointer eventFix Pattern:
// Before: triggers re-render on every mouse move
const [canvasPointerWorld, setCanvasPointerWorld] = useState<{x,y} | null>(null)
// After: ref + callback, no re-renders
const canvasPointerWorldRef = useRef<{x,y} | null>(null)
const setCanvasPointerWorld = useCallback(
(value: {x,y} | null | ((prev) => {x,y} | null)) => {
canvasPointerWorldRef.current = typeof value === 'function'
? value(canvasPointerWorldRef.current) : value
}, [])
Problem: useCallback hooks that depend on viewport state create new function references on every pan/zoom frame, busting downstream React.memo comparisons.
Detection:
useCallback with [viewport] or similar frequently-changing state in dependency arrayviewportRef that already existsFix Pattern:
// Before: new function reference on every viewport change
const worldToScreen = useCallback((point) => (
worldToScreenPoint(point, viewport)
), [viewport])
// After: stable identity, reads from ref at call time
const worldToScreen = useCallback((point) => (
worldToScreenPoint(point, viewportRef.current)
), [viewportRef])
Same pattern applies to event listeners:
// Before: listener torn down and recreated on every viewport change
useEffect(() => {
const onWheel = (e) => setViewport(zoomAtPoint(viewport, ...))
el.addEventListener('wheel', onWheel)
return () => el.removeEventListener('wheel', onWheel)
}, [canvasRef, viewport])
// After: stable listener reads from ref
useEffect(() => {
const onWheel = (e) => {
const vp = viewportRef.current
setViewport(zoomAtPoint(vp, ...))
}
el.addEventListener('wheel', onWheel)
return () => el.removeEventListener('wheel', onWheel)
}, [canvasRef, viewportRef])
Problem: A single global bearer token is shared across all clients (terminals, agents, renderer). If one client's token leaks, all operations are compromised.
Detection:
randomUUID() or token generation in server modules.mcp.json, mcp-server.json)Fix Pattern:
import { randomUUID } from 'crypto'
const GLOBAL_TOKEN = randomUUID()
const entityTokens = new Map<string, string>()
export function generateEntityToken(entityId: string): string {
const existing = entityTokens.get(entityId)
if (existing) return existing
const token = randomUUID()
entityTokens.set(entityId, token)
return token
}
export function revokeEntityToken(entityId: string): void {
entityTokens.delete(entityId)
}
// Auth validation checks both global and per-entity tokens
function requireAuth(token: string): boolean {
if (token === GLOBAL_TOKEN) return true
if (token && entityTokens.has(token)) return true
return false
}
// Wire into entity lifecycle
ipcMain.handle('terminal:destroy', (_, tileId) => {
// ... cleanup terminal
revokeEntityToken(tileId)
})
Problem: MCP/HTTP servers reflect any Origin header as Access-Control-Allow-Origin, allowing any website to make credentialed cross-origin requests.
Detection:
setHeader('Access-Control-Allow-Origin' in server codereq.headers.origin* fallback when no origin is presentFix Pattern:
function setCorsHeaders(res: ServerResponse, req?: IncomingMessage): void {
const origin = req?.headers.origin
const isAllowedOrigin = !origin ||
origin === 'null' || // file:// in production
origin.startsWith('http://localhost:') || // dev server
origin === 'http://localhost' ||
origin.startsWith('app://') || // custom Electron schemes
origin === 'app://codesurf'
if (isAllowedOrigin) {
res.setHeader('Access-Control-Allow-Origin', origin || '*')
if (origin) res.setHeader('Vary', 'Origin')
}
res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
}
Problem: Empty catch {} or catch { /**/ } blocks swallow errors silently, making debugging impossible when critical operations fail.
Detection:
catch \{[\s]*\} and catch \{[\s]*/\*\*/[\s]*\} patternsFix Pattern (ENOENT-tolerant logging):
// Before: silent failure on config read
try {
const raw = await fs.readFile(configPath, 'utf8')
config = JSON.parse(raw)
} catch { /**/ }
// After: log non-ENOENT errors, silently skip missing files
try {
const raw = await fs.readFile(configPath, 'utf8')
config = JSON.parse(raw)
} catch (err) {
if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
console.warn('[mcp] Failed to read existing config:', err)
}
}
Acceptable silent catches (no change needed):
try { unlinkSync(tempDb) } catch {}try { await fs.access(path) } catch { return false }try { proc.kill() } catch {}Problem: Expensive O(n²) computations (discovery graphs, connection candidates) run on every render frame during tile drags, causing frame drops with many tiles.
Detection:
tiles array in useMemo hooksuseMemo depends on tiles (changes on every drag frame)findDiscoveryMatch or similar O(n) functions called in a loopFix Pattern:
const negotiatedDiscoveryState = useMemo(() => {
// ... build connection graph from worker results ...
// Skip O(n²) auto-discovery during active drags — connections
// don't need to be recomputed while tiles are moving
const isActiveDrag = dragState.type === 'tile' ||
dragState.type === 'group' ||
dragState.type === 'resize' ||
dragState.type === 'connection'
if (autoConnectionsEnabled && !isActiveDrag) {
for (const tile of tiles) {
const discovery = findDiscoveryMatch(tile.id, tiles, ...)
// ... process discovery match
}
}
return { connectedTileIds, byTileConnections, ambientRoutes }
}, [autoConnectionsEnabled, tiles, dragState, ...])
src/main/ipc/ directory structureprocess.env in test files: Usually acceptable in test contexts# Typecheck
npx tsgo -p tsconfig.tsgo.json --noEmit
# Run security-focused tests
node --test test/stream-ssrf.test.ts test/security-hardening.test.ts test/mcp-auth.test.ts
# Run full test suite
npm test