Protection CSRF en PHP

Qu’est-ce que le CSRF ?

Cross-Site Request Forgery (CSRF) est une vulnérabilité de sécurité Web qui permet à un attaquant de tromper les utilisateurs authentifiés pour qu'ils exécutent des actions indésirables sur un site Web sur lequel ils sont actuellement connectés. L'attaque fonctionne en exploitant la confiance qu'un site Web a dans le navigateur d'un utilisateur.

Comment fonctionnent les attaques CSRF

1. L'utilisateur se connecte au site Web légitime A et reçoit un cookie de session
2. L'utilisateur visite le site Web malveillant B alors qu'il est encore connecté à A
3. Le site Web B contient du code qui fait une demande au site Web A
4. Le navigateur inclut automatiquement le cookie de session
5. Le site Web A traite la demande en pensant qu'elle est légitime

Méthodes de protection CSRF en PHP

1. Protection basée sur des jetons utilisant une entrée cachée

C'est la méthode la plus courante. Voici comment le mettre en œuvre :

// In your session initialization (e.g., at login)
session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// In your form
function generateFormWithCSRFToken() {
    return '

'; } // In your form processing function validateCSRFToken() { if (!isset($_POST['csrf_token']) || !isset($_SESSION['csrf_token']) || !hash_equals($_SESSION['csrf_token'], $_POST['csrf_token'])) { die('CSRF token validation failed'); } return true; }

2. Protection CSRF à l'aide d'en-têtes personnalisés

Cette méthode utilise des requêtes AJAX avec des en-têtes personnalisés :

// PHP Backend
session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// Validate the token
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $headers = getallheaders();
    if (!isset($headers['X-CSRF-Token']) || 
        !hash_equals($_SESSION['csrf_token'], $headers['X-CSRF-Token'])) {
        http_response_code(403);
        die('CSRF token validation failed');
    }
}

// JavaScript Frontend
const csrfToken = '<?php echo $_SESSION["csrf_token"]; ?>';

fetch('/api/endpoint', {
    method: 'POST',
    headers: {
        'X-CSRF-Token': csrfToken,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
});

3. Modèle de cookie à double soumission

Cette méthode consiste à envoyer le token à la fois sous forme de cookie et de paramètre de requête :

// Set both cookie and session token
session_start();
$token = bin2hex(random_bytes(32));
$_SESSION['csrf_token'] = $token;
setcookie('csrf_token', $token, [
    'httponly' => true,
    'secure' => true,
    'samesite' => 'Strict'
]);

// Validation function
function validateDoubleSubmitToken() {
    if (!isset($_COOKIE['csrf_token']) || 
        !isset($_POST['csrf_token']) || 
        !isset($_SESSION['csrf_token'])) {
        return false;
    }

    return hash_equals($_COOKIE['csrf_token'], $_POST['csrf_token']) && 
           hash_equals($_SESSION['csrf_token'], $_POST['csrf_token']);
}

4. Attribut du cookie SameSite

Les applications modernes peuvent également utiliser l'attribut de cookie SameSite comme couche de protection supplémentaire :

// Set cookie with SameSite attribute
session_start();
session_set_cookie_params([
    'lifetime' => 0,
    'path' => '/',
    'domain' => $_SERVER['HTTP_HOST'],
    'secure' => true,
    'httponly' => true,
    'samesite' => 'Strict'
]);

Meilleures pratiques pour la protection CSRF

1. Génération de jetons
   • Utilisez des générateurs de nombres aléatoires cryptographiquement sécurisés
   • Créez des jetons suffisamment longs (au moins 32 octets)
   • Générez de nouveaux jetons pour chaque session

function generateSecureToken($length = 32) {
    return bin2hex(random_bytes($length));
}

1. Validation des jetons
   • Utilisez des fonctions de comparaison sécurisées pour le timing
   • Valider la présence et la valeur du jeton
   • Mettre en œuvre une gestion appropriée des erreurs

function validateToken($userToken, $storedToken) {
    if (empty($userToken) || empty($storedToken)) {
        return false;
    }
    return hash_equals($storedToken, $userToken);
}

1. Mise en œuvre du formulaire
   • Inclure les jetons sous toutes les formes
   • Mettre en œuvre l'injection automatique de jetons
   • Gérer la rotation des jetons

class CSRFProtection {
    public static function getTokenField() {
        return sprintf(
            '<input type="hidden" name="csrf_token" value="%s">',
            htmlspecialchars($_SESSION['csrf_token'])
        );
    }
}

Protection spécifique au framework

De nombreux frameworks PHP offrent une protection CSRF intégrée :

Exemple Laravel

// In your session initialization (e.g., at login)
session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// In your form
function generateFormWithCSRFToken() {
    return '

'; } // In your form processing function validateCSRFToken() { if (!isset($_POST['csrf_token']) || !isset($_SESSION['csrf_token']) || !hash_equals($_SESSION['csrf_token'], $_POST['csrf_token'])) { die('CSRF token validation failed'); } return true; }

Exemple Symfony

// PHP Backend
session_start();
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// Validate the token
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $headers = getallheaders();
    if (!isset($headers['X-CSRF-Token']) || 
        !hash_equals($_SESSION['csrf_token'], $headers['X-CSRF-Token'])) {
        http_response_code(403);
        die('CSRF token validation failed');
    }
}

// JavaScript Frontend
const csrfToken = '<?php echo $_SESSION["csrf_token"]; ?>';

fetch('/api/endpoint', {
    method: 'POST',
    headers: {
        'X-CSRF-Token': csrfToken,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
});

Pièges courants à éviter

1. N'utilisez pas de jetons prévisibles
2. Ne stockez pas les jetons dans des variables JavaScript accessibles globalement
3. Ne sautez pas la protection CSRF pour les requêtes AJAX
4. Ne comptez pas uniquement sur la vérification de l'en-tête Referer
5. N'utilisez pas le même jeton pour plusieurs formulaires

La protection CSRF est cruciale pour la sécurité des applications Web. Bien qu'il existe plusieurs approches pour mettre en œuvre la protection CSRF, l'approche basée sur des jetons utilisant des champs de formulaire masqués reste la méthode la plus largement utilisée et la plus fiable. N'oubliez pas de combiner différentes méthodes de protection pour une sécurité renforcée et suivez toujours les meilleures pratiques de sécurité lors de la mise en œuvre de la protection CSRF dans vos applications PHP.

N'oubliez pas que la protection CSRF doit faire partie d'une stratégie de sécurité plus large qui comprend une gestion appropriée des sessions, une gestion sécurisée des cookies et une validation des entrées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!