Beveilig mijn WebSocket-implementatie tegen veelvoorkomende aanvallen
description
Met deze prompt krijg je specifieke, praktische beveiligingsadviezen om je WebSocket-verbindingen te beschermen tegen de meest voorkomende en gevaarlijke aanvallen. Dit helpt je om de integriteit en vertrouwelijkheid van je data te waarborgen en voorkomt dat je kwetsbaar bent voor hackers. Het is beter dan algemene beveiligingstips omdat het direct toepasbare aanbevelingen en codevoorbeelden biedt, afgestemd op jouw technologieën.
prompt
Help me mijn WebSocket-implementatie te beveiligen tegen veelvoorkomende bedreigingen en aanvallen. Mijn servertechnologie: <voer de servertechnologie in die ik gebruik>
Mijn clienttechnologie: <voer de clienttechnologie in die ik gebruik>
Mijn beveiligingsdoelstellingen: <beschrijf welke beveiligingsaspecten voor mi ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hieronder vind je gerichte aanbevelingen en codevoorbeelden om jouw WebSocket-implementatie te beveiligen, specifiek gericht op authenticatie, encryptie, en het voorkomen van bedreigingen zoals cross-site WebSocket hijacking, man-in-de-middle-aanvallen en denial-of-service.
1. Gebruik WSS (WebSocket Secure)
Zorg dat je WebSocket-verbinding via WSS loopt, dus over TLS/SSL. Dit encryptie niveau beschermt tegen man-in-de-middle-aanvallen en onderschept verkeer.
**Server (Node.js + Express + ws):**
```javascript
const https = require('https');
const fs = require('fs');
const WebSocket = require('ws');
const server = https.createServer({
cert: fs.readFileSync('cert.pem'),
key: fs.readFileSync('key.pem')
});
const wss = new WebSocket.Server({ server });
// Start de server op poort 443 (https)
server.listen(443, () => {
console.log('Secure WebSocket server gestart op poort 443');
});
```
2. Authenticatie en autorisatie voor WebSocket
Gebruik tokens (bijvoorbeeld JWT) die bij het opzetten van de verbinding worden meegestuurd, en controleer deze op de server.
**Client (React):**
```javascript
const token = 'jouwJWTtoken'; // Haal dit token op uit login/auth flow
const ws = new WebSocket(`wss://jouwdomein.com/socket?token=${token}`);
```
**Server (Node.js):**
```javascript
wss.on('connection', (ws, req) => {
const params = new URL(req.url, 'https://dummy').searchParams;
const token = params.get('token');
// Verifieer token (bijv. met jsonwebtoken)
try {
const payload = jwt.verify(token, 'jouwSuperSecretKey');
ws.user = payload.userId; // Bewaar gebruikersinformatie
} catch (err) {
ws.close(1008, 'Authenticatie mislukt');
return;
}
});
```
3. Cross-site WebSocket hijacking voorkomen
- Controleer de Origin-header om te zorgen dat verbindingen alleen van vertrouwde domeinen komen.
- Gebruik een CSRF-Token of vergelijkbare methoden indien nodig.
**Server:**
```javascript
wss.on('connection', (ws, req) => {
const origin = req.headers.origin;
const vertrouwdDomein = 'https://jouwdomein.com';
if (origin !== vertrouwdDomein) {
ws.close(1008, 'Ongeldig origin');
return;
}
// doorgaan met verbinding
});
```
4. Beperken van DoS-aanvallen
- Implementeer rate limiting op het WebSocket-kanaal.
- Sluit inactieve of overmatig gebruikte verbindingen af.
**Voorbeeld:**
```javascript
const rateLimitMap = new Map();
wss.on('connection', (ws) => {
const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
if (!rateLimitMap.has(ip)) {
rateLimitMap.set(ip, { count: 0, timestamp: Date.now() });
}
const record = rateLimitMap.get(ip);
if (record.count > 100) { // bijvoorbeeld max 100 berichten per minuut
ws.close(1013, 'Te veel verzoeken');
return;
}
// Reset na een minuut
if (Date.now() - record.timestamp > 60000) {
record.count = 0;
record.timestamp = Date.now();
}
ws.on('message', () => {
record.count++;
});
});
```
5. Extra beveiligingstips
- Gebruik subprotocols om te controleren op client authenticatie.
- Sluit ongeautoriseerde of verdachte verbindingen meteen.
- Monitor je WebSocket-verkeer voor abnormale patronen.
**Kort samengevat:**
- Gebruik WSS voor encryptie.
- Authenticeer via tokens (bijv. JWT).
- Controleer de origin-header.
- Implementeer rate limiting.
- Beperk de toegestane verbindingen en monitor het verkeer.
Met deze maatregelen verhoog je de beveiliging van je WebSocket-verbindingen aanzienlijk tegen de genoemde bedreigingen.
provider: deepseek
model: deepseek-chat
Zeker, hier is een gestructureerde beveiligingsaanpak voor uw WebSocket-implementatie:
# WebSocket Beveiliging - Node.js/React
## 1. Authenticatie & Autorisatie
**Server-side (Node.js/Express):**
```javascript
const WebSocket = require('ws');
const jwt = require('jsonwebtoken');
const wss = new WebSocket.Server({ noServer: true });
// Upgrade request authenticatie
server.on('upgrade', (request, socket, head) => {
const token = request.headers['sec-websocket-protocol'];
if (!token) {
socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
socket.destroy();
return;
}
try {
const decoded = jwt.verify(token, process.env.JWT_SECRET);
request.user = decoded;
wss.handleUpgrade(request, socket, head, (ws) => {
wss.emit('connection', ws, request);
});
} catch (error) {
socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
socket.destroy();
}
});
// Connection handling
wss.on('connection', (ws, request) => {
ws.user = request.user;
ws.on('message', (message) => {
// Verifieer elke message indien nodig
if (!validateMessage(message, ws.user)) {
ws.close(1008, 'Ongeldig bericht');
return;
}
// Verwerk bericht
});
});
```
**Client-side (React):**
```javascript
import { useEffect } from 'react';
import jwt from 'jsonwebtoken';
const useWebSocket = (url) => {
useEffect(() => {
const token = localStorage.getItem('authToken');
const ws = new WebSocket(url, [token]);
ws.onopen = () => {
console.log('Beveiligde WebSocket verbinding geopend');
};
return () => ws.close();
}, [url]);
};
```
## 2. Cross-Site WebSocket Hijacking (CSWSH) Preventie
**Origin Validation:**
```javascript
// Server-side origin check
const allowedOrigins = ['https://uwdomein.com', 'https://www.uwdomein.com'];
server.on('upgrade', (request, socket, head) => {
const origin = request.headers.origin;
if (!allowedOrigins.includes(origin)) {
socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
socket.destroy();
return;
}
// Verdere authenticatie...
});
```
**SameSite Cookies & CORS:**
```javascript
// Express CORS configuratie
const cors = require('cors');
app.use(cors({
origin: ['https://uwdomein.com', 'https://www.uwdomein.com'],
credentials: true
}));
// Cookie configuratie
app.use(session({
secret: process.env.SESSION_SECRET,
cookie: {
secure: true,
sameSite: 'strict',
httpOnly: true
}
}));
```
## 3. Encryptie & TLS Beveiliging
**HTTPS/WSS Implementatie:**
```javascript
const https = require('https');
const fs = require('fs');
const server = https.createServer({
cert: fs.readFileSync('/path/to/cert.pem'),
key: fs.readFileSync('/path/to/key.pem'),
minVersion: 'TLSv1.2',
ciphers: 'ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4'
}, app);
// Client-side verbinding
const ws = new WebSocket('wss://uwdomein.com/ws', {
protocols: [authToken]
});
```
## 4. Rate Limiting & DoS Bescherming
**WebSocket Rate Limiter:**
```javascript
const rateLimit = new Map();
wss.on('connection', (ws, request) => {
const ip = request.socket.remoteAddress;
const now = Date.now();
if (rateLimit.has(ip)) {
const { count, resetTime } = rateLimit.get(ip);
if (now > resetTime) {
rateLimit.set(ip, { count: 1, resetTime: now + 60000 });
} else if (count > 100) { // 100 messages per minuut
ws.close(1008, 'Rate limit exceeded');
return;
} else {
rateLimit.set(ip, { count: count + 1, resetTime });
}
} else {
rateLimit.set(ip, { count: 1, resetTime: now + 60000 });
}
// Heartbeat voor inactieve verbindingen
ws.isAlive = true;
ws.on('pong', () => { ws.isAlive = true; });
});
```
## 5. Input Validatie & Sanitization
**Message Validation:**
```javascript
const validateMessage = (message, user) => {
try {
const data = JSON.parse(message);
// Type validatie
if (typeof data !== 'object') return false;
// Size limit (bijv. 1MB)
if (message.length > 1048576) return false;
// Content validatie
if (data.type && !['chat', 'update', 'ping'].includes(data.type)) {
return false;
}
return true;
} catch {
return false;
}
};
```
## 6. Complete Beveiligingsconfiguratie
**Environment Variabelen:**
```bash
JWT_SECRET=uw_super_geheim_jwt_secret
SESSION_SECRET=uw_session_secret
NODE_ENV=production
```
**Package.json Dependencies:**
```json
{
"dependencies": {
"ws": "^8.0.0",
"jsonwebtoken": "^9.0.0",
"cors": "^2.8.5",
"express-rate-limit": "^6.0.0"
}
}
```
## Belangrijke Beveiligingspraktijken:
1. **Always use WSS** (WebSocket Secure) in productie
2. **Validate all input** zowel client- als server-side
3. **Implement proper session management**
4. **Use HTTPS everywhere**
5. **Regular security updates** voor alle dependencies
6. **Monitor and log** alle WebSocket activiteiten
Deze implementatie biedt een robuuste basis voor beveiligde WebSocket-communicatie met bescherming tegen de meest voorkomende aanvallen.