PHP
Sécuriser un formulaire PHP : les erreurs à ne plus faire
Requêtes préparées, échappement, jeton CSRF, honeypot : les erreurs concrètes qui rendent un formulaire PHP vulnérable, et comment les corriger sans plugin lourd.
Un formulaire de contact qui envoie un mail, un formulaire d’inscription qui écrit en base, un formulaire de devis qui déclenche une notification : chacun de ces points d’entrée est une porte ouverte sur votre serveur si vous ne verrouillez pas la validation, l’échappement et l’authentification des requêtes. Le problème ne se voit pas tout de suite — le formulaire fonctionne très bien en démo, avec un utilisateur qui remplit correctement les champs. Il se voit trois mois plus tard, quand un bot injecte des liens publicitaires dans votre table de messages ou qu’un attaquant récupère votre base clients via une requête SQL mal filtrée. Voici les erreurs qui reviennent le plus souvent dans les formulaires PHP que j’audite, et comment les corriger concrètement.
Ne jamais faire confiance à $_POST
La première erreur, la plus répandue : valider côté JavaScript et considérer que c’est suffisant. Un attaquant n’utilise pas votre formulaire, il envoie directement une requête POST avec curl ou Postman, en contournant totalement votre HTML et votre JS. Toute donnée qui arrive dans $_POST doit être revalidée côté serveur, sans exception, y compris les champs cachés, les select à valeurs fixes et les checkbox.
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
if ($email === false || $email === null) {
http_response_code(422);
exit('Adresse email invalide');
}
$nom = trim($_POST['nom'] ?? '');
if ($nom === '' || mb_strlen($nom) > 100) {
http_response_code(422);
exit('Nom invalide');
}
Chaque champ a un type attendu — email, entier, chaîne bornée, valeur issue d’une liste fermée : validez-le explicitement plutôt que de faire confiance à ce que le HTML est censé imposer.
Échapper systématiquement les sorties, pas seulement les entrées
La confusion classique consiste à « nettoyer » les données à l’entrée puis à les considérer propres partout ailleurs. Ça ne fonctionne pas : c’est le contexte de sortie qui détermine l’échappement nécessaire. Une donnée réinjectée dans du HTML doit passer par htmlspecialchars(), une donnée réinjectée dans une requête SQL doit passer par une requête préparée, une donnée réinjectée dans une URL doit passer par urlencode(). Un filtrage unique à l’entrée qui ignore le contexte de sortie laisse presque toujours une faille XSS quelque part, en général sur la page de confirmation qui réaffiche « Merci {nom} pour votre message ».
echo "Merci " . htmlspecialchars($nom, ENT_QUOTES, 'UTF-8') . " pour votre message";
Bannir les requêtes SQL construites par concaténation
Si votre formulaire écrit en base et que vous voyez encore une ligne du type « INSERT INTO … VALUES (‘ . $_POST[‘x’] . ‘) », c’est une injection SQL en attente d’exploitation. Les requêtes préparées avec paramètres liés ne sont pas une option parmi d’autres : c’est le seul mécanisme fiable, et PDO les rend triviales à mettre en place.
$stmt = $pdo->prepare('INSERT INTO contacts (nom, email, message) VALUES (:nom, :email, :message)');
$stmt->execute([
'nom' => $nom,
'email' => $email,
'message' => $message,
]);
Aucune raison de mélanger les deux approches par habitude ou par copier-coller d’un vieux script : dès qu’une variable venant de l’utilisateur touche une requête SQL, elle passe par un paramètre lié, point final.
Ajouter un jeton CSRF sur tout formulaire qui modifie une donnée
Sans protection CSRF, un site tiers malveillant peut forcer le navigateur d’un utilisateur déjà connecté à soumettre votre formulaire à son insu — changement de mot de passe, ajout d’un compte administrateur, validation d’une commande. Le principe est simple : générer un jeton unique en session, l’insérer dans un champ caché, le vérifier à la réception.
// Génération
if (empty($_SESSION['csrf_token'])) {
$_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}
echo '<input type="hidden" name="csrf_token" value="' . $_SESSION['csrf_token'] . '">';
// Vérification
if (!hash_equals($_SESSION['csrf_token'] ?? '', $_POST['csrf_token'] ?? '')) {
http_response_code(403);
exit('Requête invalide');
}
hash_equals() a son importance ici : une comparaison avec === expose théoriquement à une attaque par timing sur le jeton.
Filtrer le spam sans dégrader l’expérience
Poser un reCAPTCHA sur tous les formulaires est la solution de facilité, mais elle dégrade la conversion et charge un script tiers supplémentaire pour un résultat souvent médiocre contre les bots récents. Deux mécanismes légers, combinés, arrêtent l’immense majorité du spam automatisé :
- un champ honeypot, invisible en CSS, que seul un bot va remplir — s’il est rempli, on rejette silencieusement la soumission ;
- une vérification de délai minimal entre l’affichage du formulaire et sa soumission, stockée en session, pour éliminer les envois instantanés ;
- une limitation de fréquence par adresse IP, en base ou en cache, pour bloquer les envois en rafale.
<input type="text" name="site_web" style="position:absolute;left:-9999px" tabindex="-1" autocomplete="off">
// côté serveur
if (!empty($_POST['site_web'])) {
exit; // silencieux, pour ne rien renseigner au bot
}
Sécuriser l’upload de fichiers si le formulaire en accepte
Un formulaire de candidature ou de devis avec pièce jointe est une cible fréquente : vérifier l’extension du fichier ne suffit pas, un script PHP renommé en photo.jpg passe ce test sans broncher. Il faut contrôler le type MIME réel du fichier, imposer une taille maximale, générer un nom de fichier aléatoire côté serveur, et surtout stocker les fichiers reçus hors de la racine web ou dans un répertoire où l’exécution PHP est désactivée.
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mime = finfo_file($finfo, $_FILES['piece_jointe']['tmp_name']);
$autorises = ['application/pdf', 'image/jpeg', 'image/png'];
if (!in_array($mime, $autorises, true)) {
exit('Format non autorisé');
}
Ne pas oublier la configuration serveur autour du formulaire
Le code du formulaire peut être irréprochable et la faille venir d’ailleurs : formulaire accessible en HTTP alors qu’il transmet un mot de passe, en-têtes de sécurité absents, messages d’erreur PHP affichés en production qui révèlent des chemins serveur ou la structure des requêtes. Ces éléments sont indépendants du code du formulaire lui-même mais conditionnent sa sécurité réelle. C’est un point que je vérifie systématiquement quand je reprends un site existant, que le CMS soit WordPress, PrestaShop ou un formulaire PHP maison : display_errors doit être désactivé en production, et les logs doivent aller dans un fichier, jamais à l’écran.
Sur WordPress en particulier, la tentation est grande de passer par un plugin de formulaire généraliste plutôt que de coder le traitement soi-même. Ça résout une partie du problème mais en ouvre un autre : chaque plugin ajouté est une surface d’attaque de plus à maintenir à jour. Quand je développe un thème en wordpress sur mesure, je code les formulaires directement dans le thème, avec les mêmes règles de validation, d’échappement et de protection CSRF que sur un projet PHP natif — moins de dépendances, moins de failles héritées d’un plugin tiers.
Revoir ces points régulièrement, pas une seule fois
Une faille corrigée aujourd’hui peut se rouvrir avec une montée de version PHP, un changement de configuration serveur, ou un plugin installé sans vérification par un collaborateur. La sécurité d’un formulaire n’est pas un état, c’est un processus de vérification continue : c’est précisément ce que couvre un contrat de maintenance wordpress, avec des mises à jour suivies et un contrôle régulier des points d’entrée exposés au public.
Si un ou plusieurs de vos formulaires n’ont jamais été audités depuis leur mise en ligne, mieux vaut le vérifier avant qu’un tiers ne s’en charge à votre place.
FAQ
Faut-il utiliser un framework PHP pour sécuriser un formulaire, ou le PHP natif suffit-il ?
Le PHP natif suffit largement si vous appliquez vous-même les règles ci-dessus : requêtes préparées, échappement en sortie, jeton CSRF, validation stricte des types. Un framework comme Symfony apporte ces protections par défaut dans ses composants Form et Validator, ce qui réduit le risque d’oubli sur un projet volumineux, mais n’apporte rien qu’un développeur rigoureux ne puisse reproduire à la main sur un formulaire isolé.
Un certificat SSL suffit-il à sécuriser un formulaire ?
Non. Le SSL/TLS chiffre le transport entre le navigateur et le serveur, ce qui empêche l’interception des données en transit, mais ne protège en rien contre l’injection SQL, le XSS, le CSRF ou le spam automatisé. Ce sont deux couches de sécurité complètement indépendantes : l’une protège le trajet des données, l’autre protège leur traitement une fois arrivées sur le serveur.
Comment savoir si un formulaire existant est vulnérable sans tout réécrire ?
Un audit ciblé — lecture du code de traitement, test des requêtes SQL, vérification de l’échappement des sorties et de la présence d’un jeton CSRF — permet en général d’identifier les failles sans repartir de zéro. La plupart du temps, les corrections se font champ par champ, requête par requête, sans toucher au design ni à l’expérience utilisateur du formulaire.
À lire ensuite · PHP
Un projet PHP sérieux ?
Applications Symfony robustes, API Platform, reprise d'existant — code testé et documenté.