Appearance
TP 5 - Attaquer et corriger sa propre API
BTS SIO SLAM 2ème année Durée : 1 heure PHP + PDO + MySQLContexte
Votre API est maintenant protégée par authentification (JWT). Mais l'authentification n'est qu'une brique de sécurité. Pour aller plus loin, l'application passe d'un stockage en fichiers JSON à une base de données MySQL.
Le code de la migration vous est donné dans ce TP. Avant de le « mettre en production », vous allez l'auditer comme le ferait un attaquant : il contient trois failles classiques (injection SQL, XSS, CORS trop permissif). Vous allez les exploiter sur votre propre application, puis les corriger.
Cadre du TP
Vous attaquez uniquement votre propre application, en local, sur votre machine. Tester des failles sur un site dont on n'est pas propriétaire est illégal.
Mission 1 - Migrer vers une base de données
Tâche 1.1 - Créer la base avec phpMyAdmin
Ouvrez phpMyAdmin (http://localhost/phpmyadmin), onglet Importer, et importez le script suivant (ou collez-le dans l'onglet SQL) :
sql
DROP DATABASE IF EXISTS notes_app;
CREATE DATABASE notes_app CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
USE notes_app;
CREATE TABLE users (
id INT PRIMARY KEY AUTO_INCREMENT,
email VARCHAR(255) NOT NULL UNIQUE,
password_hash VARCHAR(255) NOT NULL
);
CREATE TABLE notes (
id INT PRIMARY KEY AUTO_INCREMENT,
texte VARCHAR(1000) NOT NULL,
id_utilisateur INT NOT NULL,
FOREIGN KEY (id_utilisateur) REFERENCES users (id)
);
-- Comptes de test (mots de passe : MonMotDePasse123 et MotDePasseDeBob)
INSERT INTO users (id, email, password_hash) VALUES
(1, 'alice@example.com', '$2y$10$s6KFh7OKjuhSI2NrmKm97.w0B20OgxDPZLsKDY4zGcjvo1gQSusqW'),
(2, 'bob@example.com', '$2y$10$YmksD6sDQHPy/0bd2ll5resdLOUVGd5joVe/wlaj3pfIocJktBmtq');
INSERT INTO notes (texte, id_utilisateur) VALUES
('Code du casier : 4821', 1),
('Rendre le dossier de projet avant vendredi', 1),
('Acheter un câble HDMI', 2);Tâche 1.2 - Configurer la connexion à la base
Vous continuez avec votre dossier notes-app du TP 4. vendor/, api/auth.php et index.html restent en place : seules les routes PHP changent, pour lire la base au lieu des fichiers JSON.
| Fichier | Ce qui change |
|---|---|
config.php | Ajout des informations de connexion à la base |
api/db.php | Nouveau : ouvre la connexion PDO |
api/cors.php | Nouveau : regroupe les en-têtes communs à toutes les routes |
api/register.php, api/notes.php, api/login.php | Lisent et écrivent dans la base au lieu des fichiers JSON |
api/auth.php | Inchangé (le middleware du TP 4) |
Ajoutez les informations de connexion dans config.php (valeurs par défaut de WAMP et XAMPP), en gardant votre JWT_SECRET du TP 3 :
php
<?php
define('JWT_SECRET', 'votre-cle-secrete-longue-et-aleatoire-ici');
define('JWT_EXPIRATION', 3600);
// Connexion à la base de données
define('DB_HOST', 'localhost');
define('DB_PORT', 3306);
define('DB_NAME', 'notes_app');
define('DB_USER', 'root');
define('DB_PASS', '');Créez ensuite api/db.php, qui utilise ces constantes pour ouvrir la connexion :
php
<?php
require_once __DIR__ . '/../config.php';
// Ouvre une connexion PDO à la base notes_app
function connexion(): PDO
{
$dsn = 'mysql:host=' . DB_HOST . ';port=' . DB_PORT . ';dbname=' . DB_NAME . ';charset=utf8mb4';
$pdo = new PDO($dsn, DB_USER, DB_PASS);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
return $pdo;
}Tâche 1.3 - Regrouper les en-têtes dans cors.php
Depuis le TP 1, chaque route commence par les mêmes header(...) et la même réponse au OPTIONS. Créez api/cors.php pour les écrire une seule fois :
php
<?php
// En-têtes communs à toutes les routes de l'API
header('Content-Type: application/json');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST');
header('Access-Control-Allow-Headers: Content-Type, Authorization');
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
http_response_code(204);
exit;
}Tâche 1.4 - Migrer les trois routes
Remplacez le contenu des trois fichiers suivants. Chacun inclut maintenant cors.php et db.php au lieu de répéter les en-têtes et de lire un fichier JSON.
api/register.php enregistre le compte dans la table users :
php
<?php
require_once __DIR__ . '/cors.php';
require_once __DIR__ . '/db.php';
if ($_SERVER['REQUEST_METHOD'] !== 'POST') { http_response_code(405); echo json_encode(['erreur' => 'Méthode non autorisée']); exit; }
$body = json_decode(file_get_contents('php://input'), true);
if (empty($body['email']) || empty($body['password'])) {
http_response_code(400);
echo json_encode(['erreur' => 'Email et mot de passe obligatoires']);
exit;
}
$pdo = connexion();
$requete = $pdo->prepare('SELECT id FROM users WHERE email = ?');
$requete->execute([$body['email']]);
if ($requete->fetch()) {
http_response_code(409);
echo json_encode(['erreur' => 'Cet email est déjà utilisé']);
exit;
}
$requete = $pdo->prepare('INSERT INTO users (email, password_hash) VALUES (?, ?)');
$requete->execute([$body['email'], password_hash($body['password'], PASSWORD_BCRYPT)]);
http_response_code(201);
echo json_encode(['message' => 'Compte créé', 'email' => $body['email']]);api/notes.php lit et écrit dans la table notes, toujours protégé par verifierToken() du TP 4 :
php
<?php
require_once __DIR__ . '/cors.php';
require_once __DIR__ . '/auth.php';
require_once __DIR__ . '/db.php';
$utilisateur = verifierToken();
$pdo = connexion();
$methode = $_SERVER['REQUEST_METHOD'];
if ($methode === 'GET') {
$requete = $pdo->prepare('SELECT id, texte FROM notes WHERE id_utilisateur = ? ORDER BY id');
$requete->execute([$utilisateur->sub]);
echo json_encode($requete->fetchAll(PDO::FETCH_ASSOC));
} elseif ($methode === 'POST') {
$body = json_decode(file_get_contents('php://input'), true);
if (empty($body['texte'])) {
http_response_code(400);
echo json_encode(['erreur' => 'Le champ texte est obligatoire']);
exit;
}
$requete = $pdo->prepare('INSERT INTO notes (texte, id_utilisateur) VALUES (?, ?)');
$requete->execute([$body['texte'], $utilisateur->sub]);
http_response_code(201);
echo json_encode(['id' => (int) $pdo->lastInsertId(), 'texte' => $body['texte']]);
} else {
http_response_code(405);
echo json_encode(['erreur' => 'Méthode non autorisée']);
}api/login.php interroge la table users :
php
<?php
require_once __DIR__ . '/cors.php';
require_once __DIR__ . '/db.php';
require_once __DIR__ . '/../vendor/autoload.php';
use Firebase\JWT\JWT;
if ($_SERVER['REQUEST_METHOD'] !== 'POST') { http_response_code(405); echo json_encode(['erreur' => 'Méthode non autorisée']); exit; }
$body = json_decode(file_get_contents('php://input'), true);
if (empty($body['email']) || empty($body['password'])) {
http_response_code(400);
echo json_encode(['erreur' => 'Email et mot de passe obligatoires']);
exit;
}
$pdo = connexion();
$sql = "SELECT * FROM users WHERE email = '" . $body['email'] . "'";
$userTrouve = $pdo->query($sql)->fetch(PDO::FETCH_ASSOC);
if (!$userTrouve) {
http_response_code(401);
echo json_encode(['erreur' => 'Identifiants incorrects']);
exit;
}
$now = time();
$payload = ['sub' => (int) $userTrouve['id'], 'email' => $userTrouve['email'], 'iat' => $now, 'exp' => $now + JWT_EXPIRATION];
echo json_encode(['token' => JWT::encode($payload, JWT_SECRET, 'HS256')]);Le dossier data/
Les fichiers data/notes.json et data/users.json ne sont plus utilisés, vous pouvez les laisser. Les comptes créés aux TP 2 à 4 ne sont pas repris : utilisez les comptes de test du script SQL, ou créez-en un nouveau avec le formulaire d'inscription.
Tâche 1.5 - Afficher le numéro des notes en gras
Dans index.html, modifiez la fonction chargerNotes() du TP 4 pour que le numéro de chaque note s'affiche en gras :
javascript
async function chargerNotes() {
const notes = await appelerApi('notes.php');
if (notes === null) return;
const liste = document.getElementById('liste-notes');
liste.innerHTML = '';
notes.forEach(note => {
liste.innerHTML += `<li><strong>#${note.id}</strong> ${note.texte}</li>`;
});
}Pour mettre du gras, il faut une balise <strong> : textContent l'afficherait comme du texte, on passe donc par innerHTML.
Tâche 1.6 - Vérifier que tout fonctionne
Ouvrez l'application, connectez-vous avec alice@example.com / MonMotDePasse123. Vous devez voir les notes d'Alice, avec leur numéro en gras.
📸 Capture 1
L'application fonctionnelle après migration, notes d'Alice affichées.
Mission 2 - L'injection SQL sur le login
Tâche 2.1 - Lire la requête de connexion
Regardez cette ligne de login.php :
php
$sql = "SELECT * FROM users WHERE email = '" . $body['email'] . "'";L'email saisi est collé directement dans la requête SQL. Avec alice@example.com, la requête devient :
sql
SELECT * FROM users WHERE email = 'alice@example.com'Mais l'email est une saisie libre. Que se passe-t-il si elle contient des caractères SQL ?
Tâche 2.2 - Exploiter la faille
Sur la page de connexion, saisissez dans le champ Email :
' OR '1'='1' --et n'importe quoi comme mot de passe. Validez.
| Question | Votre réponse |
|---|---|
| Êtes-vous connecté ? Sous quel compte ? | |
| Avez-vous eu besoin du bon mot de passe ? |
Pourquoi ça marche
La requête envoyée devient :
sql
SELECT * FROM users WHERE email = '' OR '1'='1' -- ''1'='1' est toujours vrai : la requête renvoie tous les utilisateurs. Le code prend le premier (Alice) et vous connecte. Le -- transforme la fin de la ligne en commentaire SQL.
📸 Capture 2
La connexion réussie en tant qu'Alice, obtenue avec la saisie d'injection et sans son mot de passe.
Tâche 2.3 - Corriger avec une requête préparée
Remplacez le bloc vulnérable de login.php par une requête préparée, et rétablissez la vérification du mot de passe avec password_verify() :
php
$pdo = connexion();
// L'email est envoyé comme donnée, jamais comme code
$requete = $pdo->prepare('SELECT id, email, password_hash FROM users WHERE email = ?');
$requete->execute([$body['email']]);
$userTrouve = $requete->fetch(PDO::FETCH_ASSOC);
// On revérifie toujours le mot de passe
if (!$userTrouve || !password_verify($body['password'], $userTrouve['password_hash'])) {
http_response_code(401);
echo json_encode(['erreur' => 'Identifiants incorrects']);
exit;
}Le ? est un emplacement
Avec prepare() et execute(), la valeur est envoyée séparément de la requête. Le SGBD la traite comme une donnée : même ' OR '1'='1' -- est cherché tel quel comme email, et ne correspond à personne.
Tâche 2.4 - Vérifier la correction
Retentez l'injection ' OR '1'='1' --. Vous devez maintenant obtenir 401 Identifiants incorrects. Vérifiez qu'une connexion normale (bon email + bon mot de passe) fonctionne toujours.
Mission 3 - Le XSS dans l'affichage des notes
Tâche 3.1 - Injecter du HTML dans une note
Connectez-vous normalement, puis ajoutez une note contenant exactement :
html
<img src=x onerror="alert('XSS !')">Rechargez la liste des notes.
| Question | Votre réponse |
|---|---|
| Que se passe-t-il à l'affichage de la note ? | |
| Le texte de la note s'affiche-t-il, ou autre chose ? |
Le script s'exécute
Une boîte d'alerte s'ouvre. Le navigateur a interprété votre note comme du HTML, et exécuté le JavaScript du onerror. Un attaquant pourrait, à la place, voler le token dans le localStorage et le laisser exécuter dans le navigateur des autres utilisateurs.
Tâche 3.2 - Trouver la cause
Regardez la fonction chargerNotes() que vous avez modifiée à la Tâche 1.5 :
javascript
liste.innerHTML += `<li><strong>#${note.id}</strong> ${note.texte}</li>`;innerHTML interprète le HTML. Le texte de la note est inséré comme du code, pas comme du texte.
Tâche 3.3 - Corriger avec textContent
Remplacez la construction de chaque <li> pour insérer le texte avec textContent :
javascript
notes.forEach(note => {
const li = document.createElement('li');
li.textContent = '#' + note.id + ' ' + note.texte;
liste.appendChild(li);
});textContent affiche du texte, pas du HTML
Avec textContent, les caractères < et > sont affichés tels quels. La note <img src=x ...> apparaît comme du texte à l'écran, et rien ne s'exécute.
Tâche 3.4 - Vérifier la correction
Rechargez la page. L'ancienne note piégée doit maintenant s'afficher comme du texte, sans ouvrir d'alerte.
📸 Capture 3
La note <img src=x onerror=...> affichée comme du texte après correction, sans boîte d'alerte.
Et côté serveur ?
Côté PHP, la bonne pratique équivalente est htmlspecialchars($texte) avant d'afficher une donnée venue d'un utilisateur. Ici, l'affichage se fait côté client, donc on sécurise côté client avec textContent.
Mission 4 - CORS : qui a le droit d'appeler l'API ?
Tâche 4.1 - Observer le CORS actuel
Dans api/cors.php, l'en-tête est :
php
header('Access-Control-Allow-Origin: *');Le * autorise n'importe quel site à appeler votre API depuis un navigateur.
Tâche 4.2 - Tester depuis une autre page
Ouvrez un nouvel onglet sur une page quelconque (par exemple https://www.google.fr), ouvrez la console (F12) et exécutez :
javascript
fetch('http://localhost/notes-app/api/login.php', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email: 'alice@example.com', password: 'x' })
}).then(r => console.log('Réponse reçue, statut', r.status));Avec *, le navigateur laisse passer la réponse : une page extérieure peut dialoguer avec votre API.
Tâche 4.3 - Restreindre l'origine
Remplacez le * par l'origine de votre application :
php
header('Access-Control-Allow-Origin: http://localhost');Refaites le test de la Tâche 4.2 depuis Google : le navigateur bloque maintenant la lecture de la réponse (erreur CORS dans la console).
| Question | Votre réponse |
|---|---|
| Quel message apparaît dans la console depuis Google ? | |
L'application sur http://localhost fonctionne-t-elle toujours ? |
CORS ne protège pas tout
Le CORS est une sécurité du navigateur. Un attaquant avec curl ou Postman ignore le CORS. La vraie protection des données reste le token vérifié côté serveur (TP 4). Le CORS limite seulement quels sites web peuvent appeler l'API depuis un navigateur.
Bonus - Sortir les secrets du code
La clé JWT_SECRET et le mot de passe de la base sont écrits en dur dans config.php. Si ce fichier est poussé sur GitHub, ils sont exposés.
- Créez un fichier
.envà la racine du projet :
JWT_SECRET=X7k#9pLqR2mVzW8n_changez_moi
DB_PASS=- Ajoutez
.envà votre.gitignore. - Cherchez comment lire ces valeurs en PHP (par exemple avec la librairie
vlucas/phpdotenv, ou une simple fonction qui lit le fichier).
Pourquoi
Le code (versionné, partagé) et les secrets (propres à chaque environnement) doivent être séparés. On ne met jamais de clé ni de mot de passe dans un fichier suivi par Git.
Questions de réflexion
Répondez dans votre compte-rendu :
- Pourquoi une requête préparée empêche-t-elle l'injection SQL, alors que la concaténation ne le fait pas ?
- Quelle est la différence entre
innerHTMLettextContentdu point de vue de la sécurité ? - Un camarade dit : « le CORS suffit à protéger mon API ». A-t-il raison ? Pourquoi ?
- Les trois failles de ce TP ont un point commun. Lequel ?
Récapitulatif
| Faille | Exploitation | Correction |
|---|---|---|
| Injection SQL | ' OR '1'='1' -- dans le login → connexion sans mot de passe | Requête préparée (prepare / execute) + password_verify() |
| XSS | <img src=x onerror=...> dans une note → script exécuté | textContent (client) ou htmlspecialchars() (serveur) |
| CORS trop ouvert | * → n'importe quel site appelle l'API | Access-Control-Allow-Origin limité à son origine |
| Secrets en dur | Clé visible sur GitHub | Fichier .env dans .gitignore |
La suite
La semaine prochaine, vous situerez ces failles dans le OWASP Top 10, le classement de référence des risques de sécurité web, et vous ferez un audit croisé de l'application d'un autre binôme.