Quelles sont les meilleures pratiques de sécurité clés en PHP ?

Question

Accepted Answer

La sécurité PHP signifie se défendre contre les vulnérabilités web courantes (OWASP Top 10) à chaque niveau — gestion des entrées, accès à la base de données, sortie, authentification et configuration. Puisque PHP alimente une grande partie du web, ces pratiques sont critiques.

## 1. Prévenir l'injection SQL — prepared statements

```php
// ❌ NEVER concatenate user input into SQL
$pdo->query("SELECT * FROM users WHERE id = " . $_GET['id']);   // INJECTION
// ✅ ALWAYS use prepared statements (input treated as data, not SQL)
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$_GET['id']]);
```

## 2. Prévenir XSS — échapper toutes les sorties

```php
// ❌ echoing raw user input → XSS (injected scripts run in the browser)
echo $_GET['name'];
// ✅ escape output for HTML context
echo htmlspecialchars($_GET['name'], ENT_QUOTES, 'UTF-8');
```

Échappez les données contrôlées par l'utilisateur à la sortie (`htmlspecialchars`) afin que le HTML/JS injecté ne puisse pas s'exécuter. (Les moteurs de templating comme Twig/Blade échappent automatiquement.)

## 3. Hacher les mots de passe correctement

```php
// ✅ use password_hash (bcrypt/argon2) — never plaintext, never MD5/SHA
$hash = password_hash($password, PASSWORD_DEFAULT);
// verify:
if (password_verify($input, $hash)) { /* correct password */ }
```

La `password_hash`/`password_verify` intégrée de PHP utilise des algorithmes forts, salés et lents — la bonne façon de stocker les mots de passe.

## 4. Prévenir CSRF — tokens

```php
// generate a token, store in the session, include in forms, verify on submit
$_SESSION['csrf'] = bin2hex(random_bytes(32));
// verify on POST: hash_equals($_SESSION['csrf'], $_POST['csrf'])
```

## 5. Valider et nettoyer toutes les entrées

```php
$email = filter_var($_POST['email'], FILTER_VALIDATE_EMAIL);   // validate
$id = (int) $_GET['id'];                                        // cast/whitelist
// never trust $_GET/$_POST/$_COOKIE — validate everything
```

## 6. Configuration sécurisée et autres pratiques

```text
✓ display_errors=Off in production (don't leak stack traces/internals to users — log instead)
✓ Keep secrets in env vars / config outside the web root, NOT in code/git
✓ Use HTTPS; set secure/httponly/samesite cookie flags
✓ Keep PHP and dependencies UPDATED (composer audit for vulnerable packages)
✓ Validate file uploads (type, size); store outside the web root
✓ Use a maintained framework (Laravel/Symfony) — they handle many protections by default
```

## Pourquoi c'est important

La sécurité est critique pour les applications PHP, et la compréhension de ces pratiques est essentielle — parce que PHP alimente une énorme partie du web, les applications PHP sont des cibles d'attaque constantes, et les défaillances de sécurité peuvent être catastrophiques (violations de données, compromission de comptes, défacement).

PHP aborde les vulnérabilités web les plus courantes et les plus dangereuses, mais contrairement à certains frameworks, beaucoup dépend du développeur qui suit les bonnes pratiques.

Les éléments essentiels non négociables : les **prepared statements** préviennent l'injection SQL (l'une des attaques les plus courantes et dévastatrices), l'**échappement de sortie** (`htmlspecialchars`) prévient XSS, **`password_hash`/`password_verify`** garantissent un stockage sécurisé des mots de passe (jamais en texte brut/hashes faibles), les **tokens CSRF** protègent les demandes changeant d'état, et la **validation d'entrée rigoureuse** (ne jamais faire confiance à `$_GET`/`$_POST`/`$_COOKIE`) est la fondation.

Également important est la **configuration sécurisée** : désactiver l'affichage des erreurs en production (les erreurs divulguent des informations sensibles aux attaquants), garder les secrets hors du code, utiliser HTTPS et les drapeaux de cookies sécurisés, valider les uploads, et maintenir PHP et les dépendances à jour (puisque les packages vulnérables sont un vecteur d'attaque majeur).

Comprendre cette approche en couches, défense en profondeur — et qu'une seule couche oubliée (une injection, un secret divulgué, une sortie non échappée, une dépendance non corrigée) peut compromettre tout le système — est une connaissance importante et enjeux élevés pour tout développeur PHP.

Bien que les frameworks modernes (Laravel, Symfony) fournissent de nombreuses protections par défaut, comprendre les menaces sous-jacentes et les pratiques est une responsabilité essentielle pour construire des applications sécurisées, ce qui rend ce sujet critique et fréquemment pertinent pour PHP en production.