Les attaques de l'homme du milieu (MitM) constituent une menace importante pour la sécurité Web. Dans ces attaques, un acteur malveillant intercepte la communication entre un client et un serveur, lui permettant d'écouter, de manipuler ou de voler des données. Ce blog explorera le fonctionnement des attaques MitM dans le contexte des applications JavaScript et fournira des étapes pratiques pour sécuriser votre application contre ces menaces.
Une attaque Man-in-the-Middle se produit lorsqu'un attaquant intercepte et relaie secrètement des messages entre deux parties qui pensent communiquer directement entre elles. Cette interception peut conduire à un accès non autorisé à des données sensibles, telles que des identifiants de connexion, des informations financières et des informations personnelles.
Les attaques MitM peuvent être exécutées de différentes manières, notamment :
1. Usurpation DNS : L'usurpation DNS consiste à modifier les enregistrements DNS pour rediriger les utilisateurs vers des sites Web malveillants.
Exemple :
Supposons que vous ayez déployé votre application Node.js et React sur xyz.com. Un pirate informatique peut manipuler les enregistrements DNS de sorte que lorsque les utilisateurs tentent de visiter xyz.com, ils soient redirigés vers un site malveillant qui semble identique au vôtre.
Étapes pour empêcher l'usurpation d'identité DNS :
# Example of enabling DNSSEC on your domain using Cloudflare # Visit your domain's DNS settings on Cloudflare # Enable DNSSEC with a single click
2. Usurpation d'adresse IP
L'usurpation d'adresse IP consiste à prétendre être une adresse IP fiable pour intercepter le trafic réseau.
Exemple :
Un attaquant pourrait usurper l'adresse IP de votre serveur pour intercepter le trafic entre vos clients et votre serveur Node.js.
Étapes pour empêcher l'usurpation d'adresse IP :
// Example of IP whitelisting in Express.js
const express = require('express');
const app = express();
const allowedIPs = ['123.45.67.89']; // Replace with your trusted IPs
app.use((req, res, next) => {
const clientIP = req.ip;
if (!allowedIPs.includes(clientIP)) {
return res.status(403).send('Forbidden');
}
next();
});
// Your routes here
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
3. Usurpation HTTPS
L'usurpation d'identité HTTPS consiste à créer de faux certificats SSL pour usurper l'identité d'un site Web sécurisé.
Exemple :
Un attaquant pourrait créer un faux certificat SSL pour xyz.com et configurer un serveur malveillant qui semble identique à votre serveur légitime.
Étapes pour empêcher l'usurpation d'identité HTTPS :
// Example of implementing HPKP in Express.js
const helmet = require('helmet');
const app = express();
app.use(helmet.hpkp({
maxAge: 60 * 60 * 24 * 90, // 90 days
sha256s: ['yourPublicKeyHash1', 'yourPublicKeyHash2'], // Replace with your public key hashes
includeSubDomains: true
}));
// Your routes here
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
4. Écoutes Wi-Fi
L'écoute Wi-Fi consiste à intercepter les données transmises sur des réseaux Wi-Fi non sécurisés.
Exemple :
Un pirate informatique pourrait configurer un point d'accès Wi-Fi malveillant et intercepter les données transmises entre les utilisateurs et votre serveur lorsqu'ils s'y connectent.
Étapes pour empêcher les écoutes Wi-Fi :
// Example of enforcing HTTPS in Express.js
const express = require('express');
const app = express();
app.use((req, res, next) => {
if (req.headers['x-forwarded-proto'] !== 'https') {
return res.redirect(['https://', req.get('Host'), req.url].join(''));
}
next();
});
// Your routes here
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
1. Utilisez HTTPS partout
Assurez-vous que toutes les communications entre le client et le serveur sont cryptées à l'aide de HTTPS. Utilisez des outils comme Let's Encrypt pour obtenir des certificats SSL/TLS gratuits.
// Enforce HTTPS in Express.js
const express = require('express');
const app = express();
app.use((req, res, next) => {
if (req.headers['x-forwarded-proto'] !== 'https') {
return res.redirect(['https://', req.get('Host'), req.url].join(''));
}
next();
});
// Your routes here
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
2. Valider les certificats SSL/TLS
Utilisez une validation forte pour les certificats SSL/TLS et évitez les certificats auto-signés en production.
3. Mettre en œuvre la politique de sécurité du contenu (CSP)
Utilisez les en-têtes CSP pour restreindre les sources à partir desquelles votre application peut charger des ressources, réduisant ainsi le risque d'injection de scripts malveillants.
// Setting CSP headers in Express.js
const helmet = require('helmet');
app.use(helmet.contentSecurityPolicy({
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'", 'trusted.com'],
styleSrc: ["'self'", 'trusted.com']
}
}));
4. Utilisez des cookies sécurisés
Assurez-vous que les cookies sont marqués comme Secure et HttpOnly pour empêcher leur accès via des scripts côté client.
// Setting secure cookies in Express.js
app.use(require('cookie-parser')());
app.use((req, res, next) => {
res.cookie('session', 'token', { secure: true, httpOnly: true });
next();
});
5. Mettre en œuvre le HSTS (HTTP Strict Transport Security)
Utilisez HSTS pour forcer les navigateurs à communiquer uniquement avec votre serveur via HTTPS.
// Setting HSTS headers in Express.js
const helmet = require('helmet');
app.use(helmet.hsts({
maxAge: 31536000, // 1 year
includeSubDomains: true,
preload: true
}));
Man-in-the-Middle attacks can have devastating consequences for web applications, leading to data theft and injection attacks. By understanding how these attacks work and implementing robust security measures, you can protect your JavaScript applications and ensure the safety of your users' data. Always use HTTPS, validate SSL/TLS certificates, implement CSP, secure cookies, and enforce HSTS to mitigate the risks of MitM attacks.
以上是防止 JavaScript 应用程序中的中间人 (MitM) 攻击的步骤的详细内容。更多信息请关注PHP中文网其他相关文章！
