Ce parcours t’apprend comment fonctionne le web, pourquoi et comment les applications web sont attaquées, comment les défendre et comment auditer un site avec méthode, jusqu’au rapport. Tu pars des réflexes du quotidien (HTTPS, comptes, phishing), tu apprends à lire une requête, un cookie, un certificat et des en-têtes, puis tu étudies les grandes familles de failles : injections, XSS et politique de sécurité du contenu, sessions et jetons, contrôle d’accès, CSRF et CORS, fichiers, SSRF et API, configuration et dépendances. Dix modules progressifs suivent le référentiel OWASP Top 10 dans son édition 2025. Chaque leçon propose un cours détaillé, des extraits de code et de requêtes commentés, des démonstrations guidées que tu rejoues sur ton ordinateur, des exemples corrigés et un quiz avec correction. Six travaux pratiques guidés et un projet final t’apprennent à lire des captures HTTP, des journaux, du code, des configurations et des listes de dépendances, à calculer une note CVSS et à classer des correctifs, avec des critères de réussite vérifiés par la plateforme. Tout est défensif et légal : tu analyses des fichiers fictifs fournis par la plateforme ou ton propre site, tu ne testes jamais un système sans autorisation écrite, et chaque leçon indique où t’entraîner légalement. Compétences visées : lire HTTP, cookies et en-têtes, reconnaître et corriger une injection, encoder et évaluer une politique de sécurité du contenu, contrôler sessions, jetons et mots de passe, repérer un défaut de contrôle d’accès ou un SSRF, durcir une configuration, noter et prioriser des vulnérabilités, puis rédiger un rapport d’audit défendable. Aucun prérequis autre que la curiosité et les bases des cours Réseaux et Fondamentaux : un ordinateur Windows avec Node.js, PowerShell ou Git Bash suffit pour rejouer les démonstrations, et les travaux pratiques se font à partir de fichiers fournis, sans serveur ni outil offensif. Les vidéos sont en préparation : chaque leçon indique clairement quand la sienne n’est pas encore disponible, et le cours écrit couvre déjà l’essentiel.
31 leçons et 0 quiz de module listés avant inscription.
Ce module pose les bases techniques du web côté sécurité : ce qui circule dans HTTP, ce que TLS protège vraiment, et ce que le navigateur isole entre deux origines. Critères de réussite : lire une requête, une réponse et leurs en-têtes ; expliquer ce que le cadenas garantit, et ce qu’il ne garantit pas ; comparer deux URL pour juger leur origine et les risques associés aux ressources tierces.
Lis un échange HTTP comme un développeur prudent : structure de la requête, sens des méthodes, codes d’état utiles et limites de confiance côté client.
Comprends ce que TLS protège dans une connexion web, ce qu’un certificat prouve vraiment, et pourquoi le cadenas ne garantit ni l’honnêteté du site ni la sécurité de l’application.
Apprends ce que le navigateur isole, comment l’origine se calcule, pourquoi la même origine bloque la lecture et non l’envoi, et où SRI ajoute une vraie défense.
Tu y renforces les comptes web du point de vue utilisateur puis serveur : hygiène des secrets, MFA adaptée, lecture prudente des messages et stockage robuste des mots de passe. Critères de réussite : prioriser la sécurisation des comptes critiques ; reconnaître un domaine ou une demande de phishing qui trompe l’œil ; décrire un stockage serveur défendable avec hachage lent, sel unique et récupération sûre.
Renforce tes comptes web avec des mots de passe uniques, un gestionnaire, une MFA adaptée et une récupération de compte qui ne devient pas le maillon faible.
Repère les demandes suspectes, lis le vrai domaine d’un lien, comprends pourquoi le cadenas ne suffit pas, puis vérifie toute demande sensible par un canal indépendant.
Passe du côté serveur : hachage lent, sel unique, comparaison sûre, politique NIST raisonnable et réinitialisation de mot de passe qui ne crée pas une nouvelle faille.
Ce module t’apprend à regarder une application web comme un système entier, puis à décrire ses faiblesses avec un vocabulaire commun et vérifiable. Critères de réussite : cartographier une surface d’attaque et ses frontières de confiance ; classer un constat dans la bonne famille OWASP Top 10:2025 ; distinguer CWE, CVE et CVSS sans confondre gravité technique et risque métier.
Tu apprends à voir une application web comme un ensemble de portes d’entrée, de frontières de confiance et de décisions de risque, pas seulement comme des pages HTML.
Tu vas apprendre à utiliser l’OWASP Top 10:2025 comme une carte de sensibilisation utile, sans le confondre avec une norme exhaustive ni avec une checklist magique.
Cette leçon t’aide à distinguer une faiblesse, une vulnérabilité précise et une note de gravité, puis à calculer et interpréter un score CVSS v3.1 sans le confondre avec le risque.
Tu y comprends pourquoi des données non fiables deviennent du code, et comment casser ce mécanisme avec des défenses sobres et vérifiables. Critères de réussite : reconnaître une injection SQL dans du code ou un journal ; appliquer le même raisonnement défensif aux commandes, filtres NoSQL et modèles ; normaliser, valider et encoder selon le bon contexte sans inventer de faux remèdes.
Tu vas voir comment une entrée non fiable devient du SQL, comment reconnaître les signes d’une injection dans du code ou un journal, et comment la bloquer proprement avec des requêtes paramétrées.
Cette leçon relie plusieurs injections moins visibles à la même cause profonde : une donnée non fiable qui traverse un interpréteur sans garde suffisante.
Tu apprendras à traiter toute donnée comme non fiable, à la normaliser avant validation, puis à encoder correctement les sorties sans croire qu’une seule règle protège tous les contextes.
Ce module t’apprend à reconnaître ce que le navigateur exécute ou charge quand une donnée non fiable traverse mal l’application, puis à ajouter des garde-fous réalistes sans les confondre avec le correctif principal. Critères de réussite : distinguer XSS réfléchi, stocké et DOM ; évaluer si une CSP ou un jeu d’en-têtes réduit vraiment le risque ; proposer une correction adaptée au contexte de sortie et aux protections du navigateur.
Tu vas distinguer les trois familles de XSS, lire leurs points d’injection, puis appliquer le bon remède : encodage de sortie, DOM sûr, assainissement du HTML riche et défenses en profondeur.
Tu apprendras à lire une politique CSP, à distinguer une politique faible d’une politique utile, puis à tester une politique avec des nonces, des hachages et un mode de déploiement prudent.
Cette leçon t’apprend à lire les principaux en-têtes de sécurité, à savoir ce qu’ils empêchent réellement, puis à les poser côté serveur ou application sans leur prêter des pouvoirs qu’ils n’ont pas.
Tu y suis l’identité technique d’un utilisateur ou d’un client web : cookie de session, jeton signé, puis délégation OAuth ou identité OIDC, avec leurs pièges de mise en œuvre les plus classiques. Critères de réussite : lire un « Set-Cookie » ou un JWT sans lui prêter de pouvoirs imaginaires ; expliquer quand régénérer, invalider ou vérifier un jeton ; décrire un flux OAuth 2.0 avec PKCE, « state » et portées minimales.
Tu verras comment HTTP sans état devient une session, quels attributs de cookie comptent vraiment, puis comment éviter fixation, réutilisation et déconnexion incomplète.
Tu apprendras à décoder un JWT, à vérifier sa signature et ses déclarations, puis à reconnaître les erreurs de mise en œuvre les plus coûteuses : « alg » non maîtrisé, secret faible ou stockage trop exposé.
Tu vas distinguer délégation et authentification, suivre le flux code d’autorisation avec PKCE, puis repérer les pièges de redirection, de « state » ou de portées trop larges.
Tu y apprends à décider qui peut faire quoi, depuis quelle origine et avec quelles garanties quand un navigateur transporte déjà des cookies ou appelle une API. Critères de réussite : corriger un accès à l’objet d’un autre utilisateur côté serveur ; expliquer quand un jeton anti-CSRF et « SameSite » sont nécessaires ; configurer une liste d’origines CORS exacte sans refléter tout ce qui arrive.
Tu apprends à distinguer authentification et autorisation, à reconnaître un IDOR, puis à corriger un contrôle d’accès côté serveur sans te laisser tromper par une URL cachée ou un identifiant compliqué.
Tu comprends comment un navigateur joint automatiquement les cookies, pourquoi cela ouvre la porte au CSRF, puis comment combiner SameSite, jeton anti-CSRF et contrôles d’origine sans te raconter d’histoire.
Tu comprends quand le navigateur déclenche une pré-requête CORS, pourquoi « * » et les cookies ne vont pas ensemble, puis comment écrire une liste d’origines exacte au lieu de refléter tout ce qui arrive.
Ce module relie les entrées les plus piégeuses d’une application web : fichiers envoyés par l’utilisateur, URLs récupérées par le serveur et objets exposés par l’API. Critères de réussite : vérifier un téléversement sans faire confiance au nom ou au type annoncé ; bloquer une destination SSRF locale, privée ou non autorisée ; borner une API par objet, propriété et rythme de requêtes avec des journaux utiles.
Tu apprends à traiter un téléversement comme une chaîne de contrôles, puis à bloquer une traversée de chemin en validant à la fois le contenu réel, le nom servi et le chemin canonique.
Tu apprends à reconnaître une SSRF, à limiter les destinations qu’un serveur peut appeler, puis à éviter les pièges voisins que sont les entités XML externes et la désérialisation d’objets non fiables.
Tu apprends à lire l’API Top 10 2023 avec des exemples concrets, puis à combiner autorisation par objet, limitation de débit, validation de schéma et journalisation sobre pour une API réellement défensive.
Ce module t’apprend à durcir une application web au-delà du code métier : configuration, secrets, dépendances, pipeline et défense en profondeur. Critères de réussite : repérer une mauvaise configuration ou un secret mal placé ; classer une alerte de dépendance selon son exposition réelle ; expliquer ce qu’un WAF, une limitation de débit et de bons journaux apportent, sans les confondre avec un correctif.
Apprends à reconnaître une mauvaise configuration, à protéger les secrets hors du code, et à faire échouer une application sans divulguer d’informations utiles à un attaquant.
Comprends pourquoi ton application embarque surtout du code tiers, comment verrouiller les versions, lire un avis de sécurité et prioriser une mise à jour sans casser la production.
Intègre la sécurité au cycle de développement : exigences, revue de code, détection de secrets, tests automatisés et pipeline qui bloque avant la production.
Découvre comment ralentir, voir et qualifier une attaque web avec un WAF, une limitation de débit et des journaux utiles, sans confondre défense en profondeur et correction définitive.
Tu y apprends à cadrer un audit, à le conduire avec méthode, puis à transformer les observations en rapport actionnable. Critères de réussite : vérifier un périmètre et des règles d’engagement avant tout test ; consigner des preuves reproductibles en distinguant lecture seule, hypothèse et conclusion ; rédiger un constat avec preuve, sévérité, recommandation et re-test.
Pose le cadre légal et opérationnel d’un audit web : qui autorise, quoi tester, quand s’arrêter, comment traiter les données et comment s’entraîner légalement.
Suis une méthode d’audit web progressive : lecture seule d’abord, cartographie, configuration, sessions, accès, entrées, puis consignation rigoureuse des preuves.
Transforme une observation brute en constat exploitable : preuve reproductible, catégorie OWASP et CWE, score CVSS, recommandation actionnable et plan de re-test.
