Comment protéger un formulaire en PHP contre les attaques CSRF ?
Pour protéger un formulaire en PHP contre les attaques CSRF (Cross-Site Request Forgery), il est essentiel de mettre en œuvre une stratégie qui vérifie que la requête soumise par l’utilisateur est légitime et non falsifiée par un tiers malveillant. Voici quelques méthodes couramment utilisées pour sécuriser les formulaires contre les attaques CSRF, illustrées avec des exemples et des sources fiables.
1. Utiliser des jetons CSRF
L’une des méthodes les plus efficaces pour se protéger contre les attaques CSRF est l’utilisation de jetons CSRF (Tokenization). Un jeton CSRF est une valeur unique, générée par le serveur et associée à une session utilisateur spécifique. Les étapes pour implémenter cette méthode sont les suivantes :
Génération du Jeton sur le Serveur
```
// Commencez par démarrer une session PHP
session_start();
// Générez un jeton CSRF unique et le stocker dans une variable de session
if (empty($_SESSION[‘csrf_token’])) {
$_SESSION[‘csrf_token’] = bin2hex(random_bytes(32));
}
// Incluez le jeton CSRF dans le formulaire
echo ‘’;
```
Vérification du Jeton à la Soumission du Formulaire
```
// Vérifiez si le jeton CSRF soumis correspond à celui stocké dans la session
if ($_SERVER[‘REQUEST_METHOD’] = 'POST') {
if (!isset($_POST['csrf_token']) || $_POST['csrf_token'] ! $_SESSION[‘csrf_token’]) {
die(‘Invalid CSRF token’);
}
// Si le jeton est valide, continuez le traitement du formulaire
}
```
Cette méthode de sécurisation est extrêmement efficace car un attaquant potentiel ne peut pas deviner le jeton CSRF, surtout si celui-ci est généré de manière aléatoire et sécurisé.
2. Valider les référents HTTP (HTTP Referer Validation)
Une autre technique consiste à vérifier l’en-tête `Referer` des requêtes HTTP pour s’assurer qu’elles proviennent de la même application. Toutefois, cette méthode est moins fiable car certains navigateurs et réseaux peuvent ne pas inclure l’en-tête `Referer`.
Exemple de vérification du Référent
```
if ($_SERVER[‘REQUEST_METHOD’] = 'POST') {
if (empty($_SERVER['HTTP_REFERER']) || parse_url($_SERVER['HTTP_REFERER'], PHP_URL_HOST) ! $_SERVER[‘HTTP_HOST’]) {
die(‘Invalid HTTP Referer’);
}
}
```
Pour les requêtes AJAX, vous pouvez utiliser des en-têtes personnalisés. Dans ce cas, vous configurez votre application pour s’attendre à un en-tête spécifique, puis vérifiez cet en-tête sur le serveur.
Configuration de l’en-tête personnalisé
```
// Exemple d’en-tête AJAX personnalisé
var xhr = new XMLHttpRequest();
xhr.open(‘POST’, ‘/path/to/your/api’, true);
xhr.setRequestHeader(‘X-CSRF-Token’, csrfToken);
xhr.send(data);
```
Vérification de l’en-tête personnalisé côté serveur
```
if ($_SERVER[‘REQUEST_METHOD’] = 'POST') {
$csrfToken = $_SERVER['HTTP_X_CSRF_TOKEN'];
if ($csrfToken ! $_SESSION[‘csrf_token’]) {
die(‘Invalid CSRF token’);
}
}
```
Source :
- Mozilla Developer Network (MDN). “HTTP headers.” https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
Conclusion
Protéger les formulaires PHP contre les attaques CSRF implique la mise en œuvre de méthodes robustes comme les jetons CSRF, la validation des référents HTTP ou l’utilisation d’en-têtes personnalisés. Chaque méthode a ses propres avantages et peut être renforcée en combinant plusieurs techniques pour une sécurité optimale.
