Comment PHP se défend contre les attaques CSRF

Comment utiliser PHP pour se défendre contre les attaques CSRF (cross-site request forgery)

Avec le développement et la popularité des applications Web, les problèmes de sécurité des réseaux deviennent de plus en plus importants. Les attaques CSRF (Cross-site request forgery) sont devenues l’une des méthodes d’attaque courantes. Une attaque CSRF fait référence à un attaquant effectuant certaines opérations malveillantes en se faisant passer pour des demandes d'utilisateurs légitimes, telles que transférer de l'argent, modifier des mots de passe, etc. sans que l'utilisateur en soit conscient. Pour protéger les utilisateurs et les applications Web, les développeurs doivent prendre des mesures pour se défendre contre de telles attaques. Cet article explique comment utiliser PHP pour se défendre contre les attaques CSRF.

1. Comprendre les principes des attaques CSRF
   Avant de nous défendre contre les attaques CSRF, nous devons comprendre les principes des attaques. Le principe de l'attaque CSRF est d'utiliser les informations des cookies après que l'utilisateur s'est connecté à d'autres sites Web ou applications Web pour déguiser les demandes malveillantes en demandes légitimes et les envoyer au site Web ou à l'application cible. Par conséquent, les attaques CSRF exigent que les utilisateurs du site Web cible soient des utilisateurs légitimes ayant réussi l’authentification.
2. Générer et vérifier des tokens
   Afin de nous défendre contre les attaques CSRF, nous pouvons utiliser des tokens pour vérifier la légitimité des demandes. Le jeton est une chaîne générée aléatoirement, associée à la session de l'utilisateur et stockée côté serveur. Dans chaque formulaire, nous ajoutons un champ masqué qui contient la valeur du token. Lorsque l'utilisateur soumet le formulaire, nous devons vérifier que la valeur du jeton est cohérente avec la valeur stockée côté serveur. S'ils sont incohérents, la demande est illégale et nous pouvons y mettre fin ou effectuer tout autre traitement nécessaire.

Voici un exemple de code utilisant le token :

// 生成令牌
function generateToken() {
    $token = bin2hex(random_bytes(32));
    $_SESSION['csrf_token'] = $token;
    return $token;
}

// 验证令牌
function verifyToken($token) {
    if(isset($_SESSION['csrf_token']) && $_SESSION['csrf_token'] === $token) {
        return true;
    }
    return false;
}

// 在表单中添加令牌字段
function addTokenField() {
    $token = generateToken();
    echo '<input type="hidden" name="csrf_token" value="'.$token.'">';
}

3. Vérifiez la source de la requête
   Seulement vérifier le token ne suffit pas, Parce que l’attaquant peut toujours obtenir le jeton par d’autres moyens. Pour plus de sécurité, nous pouvons également vérifier l'origine de la demande. Il existe deux méthodes pour vérifier la source de la demande : l’une consiste à vérifier l’en-tête Referer et l’autre consiste à vérifier l’en-tête Origin.

Exemple de code pour vérifier l'en-tête Referer :

function verifyReferer() {
    if(isset($_SERVER['HTTP_REFERER']) && strpos($_SERVER['HTTP_REFERER'], $_SERVER['HTTP_HOST']) !== false) {
        return true;
    }
    return false;
}

Exemple de code pour vérifier l'en-tête Origin :

function verifyOrigin() {
    if(isset($_SERVER['HTTP_ORIGIN']) && $_SERVER['HTTP_ORIGIN'] === 'https://www.example.com') {
        return true;
    }
    return false;
}

4. Définir correctement les attributs des cookies
   Afin d'améliorer la sécurité, nous pouvons augmenter la difficulté des attaques CSRF en définissant les attributs des cookies. Par exemple, vous pouvez paramétrer la transmission des cookies uniquement sous les connexions HTTPS, limiter la portée des cookies uniquement au nom de domaine actuel, etc.

Exemple de code pour définir les propriétés des cookies :

session_set_cookie_params([
    'lifetime' => 86400, // Cookie的有效期为一天
    'path' => '/',
    'domain' => '.example.com',
    'secure' => true, // 仅在HTTPS连接下传输
    'httponly' => true // 仅通过HTTP协议访问
]);
session_start();

5. Faites attention à la sécurité de la connexion et de la déconnexion
   La connexion et la déconnexion sont Web les applications sont des opérations très importantes, et leur sécurité nécessite également une attention particulière. Une gestion correcte du processus de connexion et de déconnexion peut permettre de se défendre efficacement contre les attaques CSRF.

Pendant le processus de connexion, nous pouvons générer un jeton de connexion et le stocker côté serveur et dans la session. Dans chaque demande de connexion, nous devons vérifier la validité du jeton pour garantir que le jeton ne peut être obtenu que via le processus de connexion.

Pendant le processus de déconnexion, nous devons détruire les données de session liées à l'utilisateur et supprimer l'ID de session. Cela empêche les attaquants de voler les identifiants de session pour usurper l'identité des utilisateurs.

Résumé :
Les attaques CSRF sont un problème courant de sécurité des réseaux, mais nous pouvons prendre certaines mesures pour nous défendre contre cette attaque. Cet article présente certaines méthodes d'utilisation de PHP pour se défendre contre les attaques CSRF, notamment la génération et la vérification de jetons, la vérification des sources de requêtes, la définition des attributs des cookies et l'attention portée à la sécurité de connexion et de déconnexion. Grâce à l’utilisation combinée de ces méthodes, nous pouvons protéger efficacement la sécurité des applications Web et des utilisateurs.

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!