149 lines
22 KiB
JavaScript
149 lines
22 KiB
JavaScript
// Contenus pédagogiques rédigés (CM, QCM, TD, TP). Clé = identifiant ; "match" relie un titre de chapitre au contenu.
|
||
window.CONTENUS = [
|
||
{ id: 'binaire', match: /binaire|hexad/i, titre: 'Entiers naturels : binaire et hexadécimal', duree: '2 h', niveau: 'NSI Première · BTS · BUT 1',
|
||
objectifs: ['Convertir un entier entre les bases 10, 2 et 16', 'Comprendre le poids de chaque bit', 'Lire une adresse IP ou une couleur en hexadécimal'],
|
||
cm: [
|
||
['Pourquoi le binaire ?', 'Un ordinateur ne manipule que deux états électriques : le courant passe ou ne passe pas. On les note <b>0</b> et <b>1</b>. Un chiffre binaire s’appelle un <b>bit</b>, et 8 bits forment un <b>octet</b>, qui peut représenter 2<sup>8</sup> = 256 valeurs, de 0 à 255.'],
|
||
['Le poids des bits', 'Comme en base 10, la position d’un chiffre donne sa valeur. En base 2, les poids sont les puissances de 2 : 128, 64, 32, 16, 8, 4, 2, 1. Ainsi <code>1011 0010</code> vaut 128 + 32 + 16 + 2 = <b>178</b>.'],
|
||
['Du décimal au binaire', 'Méthode des soustractions : on retire la plus grande puissance de 2 possible et on écrit 1 à sa place, 0 sinon. Pour 45 : 32 (1), reste 13 ; 16 (0) ; 8 (1), reste 5 ; 4 (1), reste 1 ; 2 (0) ; 1 (1). Donc 45 = <code>101101</code>.'],
|
||
['L’hexadécimal', 'La base 16 utilise 0 à 9 puis A à F (A = 10, F = 15). Un chiffre hexadécimal correspond exactement à 4 bits. On regroupe donc les bits par 4 : <code>1011 0010</code> = <code>B2</code>. C’est la notation des couleurs web (#FF6FB5) et des adresses MAC.']],
|
||
retenir: ['1 octet = 8 bits = 256 valeurs', 'Poids des bits : 128 64 32 16 8 4 2 1', '1 chiffre hexadécimal = 4 bits'],
|
||
qcm: [
|
||
['Combien de valeurs différentes peut-on coder sur un octet ?', ['8', '128', '255', '256'], 3, 'Un octet a 8 bits, soit 2⁸ = 256 combinaisons, de 0 à 255.'],
|
||
['Que vaut 1010 en décimal ?', ['8', '10', '12', '5'], 1, '8 + 2 = 10.'],
|
||
['Comment s’écrit 255 en hexadécimal ?', ['FF', 'F0', '1FF', 'EE'], 0, '255 = 1111 1111, soit F et F.'],
|
||
['Combien de bits représente un chiffre hexadécimal ?', ['2', '4', '8', '16'], 1, '16 = 2⁴, donc 4 bits par chiffre.'],
|
||
['Que vaut 0x1A en décimal ?', ['26', '16', '110', '20'], 0, '1 × 16 + 10 = 26.']],
|
||
td: [['Convertir en binaire : 13, 100, 200.', '13 = 1101 · 100 = 110 0100 · 200 = 1100 1000'], ['Convertir en décimal : 1111, 1000 0001, 0110 0100.', '15 · 129 · 100'], ['Convertir 192.168.10.65 en binaire (4 octets).', '11000000.10101000.00001010.01000001'], ['Écrire la couleur (255, 111, 181) en hexadécimal.', '#FF6FB5']],
|
||
tp: { type: 'Générateur', url: 'apercu-generateur.html', desc: 'Conversions aléatoires à l’infini, corrigées instantanément.' } },
|
||
|
||
{ id: 'terminal', match: /terminal|commandes de base|premiers pas/i, titre: 'Découverte du terminal, commandes de base', duree: '2 h', niveau: 'SNT · NSI · BTS SIO · BUT R&T',
|
||
objectifs: ['Se repérer dans l’arborescence', 'Créer, déplacer et supprimer des fichiers', 'Lire l’aide d’une commande'],
|
||
cm: [
|
||
['Le shell', 'Le terminal permet de piloter la machine en tapant des commandes. Le programme qui les interprète s’appelle le <b>shell</b> (souvent <code>bash</code>). L’invite <code>eleve@debian:~$</code> indique l’utilisateur, la machine et le dossier courant (<code>~</code> = dossier personnel).'],
|
||
['Se déplacer', '<code>pwd</code> affiche le dossier courant, <code>ls</code> liste son contenu (<code>ls -la</code> pour tout voir avec les détails) et <code>cd dossier</code> y entre. <code>cd ..</code> remonte d’un niveau, <code>cd</code> seul ramène au dossier personnel.'],
|
||
['Manipuler des fichiers', '<code>mkdir</code> crée un dossier, <code>touch</code> un fichier vide, <code>cp</code> copie, <code>mv</code> déplace ou renomme, <code>rm</code> supprime (sans corbeille !). <code>rm -r</code> supprime un dossier et son contenu.'],
|
||
['Trouver de l’aide', '<code>man ls</code> ouvre le manuel d’une commande (q pour quitter). <code>ls --help</code> donne un résumé. La touche Tab complète les noms, et les flèches rappellent les commandes précédentes.']],
|
||
retenir: ['pwd · ls · cd pour se repérer', 'mkdir · touch · cp · mv · rm pour agir', 'man et Tab sont vos meilleurs amis'],
|
||
qcm: [
|
||
['Quelle commande affiche le dossier courant ?', ['ls', 'pwd', 'cd', 'dir'], 1, 'pwd = print working directory.'],
|
||
['Que fait cd .. ?', ['Supprime le dossier', 'Remonte d’un niveau', 'Va à la racine', 'Liste les dossiers'], 1, '.. désigne le dossier parent.'],
|
||
['Quelle commande renomme notes.txt en cours.txt ?', ['cp notes.txt cours.txt', 'rn notes.txt cours.txt', 'mv notes.txt cours.txt', 'rm notes.txt'], 2, 'mv déplace, et donc renomme.'],
|
||
['Que signifie ~ dans l’invite ?', ['La racine', 'Le dossier personnel', 'Un fichier caché', 'Une erreur'], 1, '~ est un raccourci vers /home/utilisateur.'],
|
||
['Quelle option de ls affiche les fichiers cachés ?', ['-l', '-a', '-h', '-r'], 1, '-a = all, y compris les fichiers commençant par un point.']],
|
||
td: [['Créer l’arborescence projets/{web,reseau} en une commande.', 'mkdir -p projets/web projets/reseau'], ['Copier notes.txt dans projets/web puis le renommer en index.txt.', 'cp notes.txt projets/web/ && mv projets/web/notes.txt projets/web/index.txt'], ['Supprimer le dossier projets/reseau et son contenu.', 'rm -r projets/reseau']],
|
||
tp: { type: 'Lab VM', url: 'apercu-lab-essai.html', desc: 'Un vrai terminal Debian, 6 étapes corrigées automatiquement.' } },
|
||
|
||
{ id: 'droits', match: /droits|chmod/i, titre: 'Droits : chmod, chown, umask', duree: '3 h', niveau: 'BTS SIO SISR · BTS CIEL · BUT R&T',
|
||
objectifs: ['Lire les droits d’un fichier', 'Modifier les droits en symbolique et en octal', 'Changer le propriétaire'],
|
||
cm: [
|
||
['Lire ls -l', '<code>-rwxr-x---</code> se lit en 4 parties : le type (<code>-</code> fichier, <code>d</code> dossier), puis les droits du <b>propriétaire</b>, du <b>groupe</b> et des <b>autres</b>. r = lire, w = écrire, x = exécuter (ou traverser pour un dossier).'],
|
||
['La notation octale', 'Chaque droit a un poids : r = 4, w = 2, x = 1. On additionne par catégorie : rwx = 7, r-x = 5, --- = 0. Donc <code>rwxr-x---</code> = <b>750</b>.'],
|
||
['chmod', '<code>chmod 640 fichier</code> en octal, ou en symbolique : <code>chmod u+x script.sh</code>, <code>chmod g-w,o= rapport.txt</code>. u = user, g = group, o = others, a = all.'],
|
||
['chown et umask', '<code>chown alice:profs fichier</code> change le propriétaire et le groupe (réservé à root). <code>umask 022</code> définit les droits retirés à la création : un fichier créé aura 644, un dossier 755.']],
|
||
retenir: ['r = 4 · w = 2 · x = 1', 'Ordre : propriétaire, groupe, autres', '755 pour un dossier public, 600 pour un secret'],
|
||
qcm: [
|
||
['Que vaut rw-r--r-- en octal ?', ['644', '755', '622', '744'], 0, 'rw- = 6, r-- = 4, r-- = 4.'],
|
||
['Quelle commande rend script.sh exécutable par son propriétaire ?', ['chmod o+x script.sh', 'chmod u+x script.sh', 'chown +x script.sh', 'chmod 444 script.sh'], 1, 'u = user, le propriétaire.'],
|
||
['Que permet x sur un dossier ?', ['Le supprimer', 'Le traverser (cd)', 'Lister son contenu', 'Rien'], 1, 'x sur un dossier autorise à y entrer.'],
|
||
['Avec umask 027, quels droits a un nouveau fichier ?', ['640', '750', '644', '600'], 0, '666 − 027 → 640.'],
|
||
['Qui peut exécuter chown ?', ['Tout le monde', 'Le propriétaire', 'root', 'Le groupe'], 2, 'Changer de propriétaire est réservé à l’administrateur.']],
|
||
td: [['Traduire en octal : rwxr-xr-x, rw-------, rwxrwx---.', '755 · 600 · 770'], ['Écrire la commande pour que seul le propriétaire lise et écrive secret.txt.', 'chmod 600 secret.txt'], ['Donner le dossier partage au groupe profs, avec lecture et écriture pour le groupe.', 'chown :profs partage && chmod 770 partage']],
|
||
tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Lab « Droits et utilisateurs » : créer des comptes, un dossier partagé, tester les accès.' } },
|
||
|
||
{ id: 'tubes', match: /redirection|tubes|grep/i, titre: 'Redirections, tubes et filtres', duree: '2 h', niveau: 'BTS SIO · BTS CIEL · BUT R&T',
|
||
objectifs: ['Rediriger la sortie d’une commande vers un fichier', 'Enchaîner des commandes avec un tube', 'Filtrer du texte avec grep, cut, sort'],
|
||
cm: [
|
||
['Les trois flux', 'Chaque commande a une entrée (<b>stdin</b>), une sortie (<b>stdout</b>) et une sortie d’erreur (<b>stderr</b>). Par défaut, stdout et stderr s’affichent à l’écran.'],
|
||
['Redirections', '<code>></code> écrit la sortie dans un fichier (en l’écrasant), <code>>></code> ajoute à la fin, <code>2></code> redirige les erreurs, <code><</code> lit l’entrée depuis un fichier. Exemple : <code>ls /etc > liste.txt 2> erreurs.txt</code>.'],
|
||
['Le tube |', 'Le tube envoie la sortie d’une commande dans l’entrée de la suivante : <code>cat /etc/passwd | grep bash | wc -l</code> compte les comptes qui utilisent bash.'],
|
||
['Les filtres', '<code>grep</code> garde les lignes qui contiennent un motif, <code>cut -d: -f1</code> découpe des colonnes, <code>sort</code> trie, <code>uniq -c</code> compte les doublons, <code>wc -l</code> compte les lignes.']],
|
||
retenir: ['> écrase · >> ajoute · 2> erreurs', '| relie deux commandes', 'grep, cut, sort, uniq, wc : la boîte à outils'],
|
||
qcm: [
|
||
['Quelle redirection ajoute à la fin d’un fichier ?', ['>', '>>', '<', '2>'], 1, '>> ajoute sans écraser.'],
|
||
['Que fait grep root /etc/passwd ?', ['Supprime root', 'Affiche les lignes contenant root', 'Compte les lignes', 'Crée root'], 1, 'grep filtre les lignes.'],
|
||
['Comment compter le nombre de fichiers dans /etc ?', ['ls /etc | wc -l', 'wc /etc', 'count /etc', 'ls -c /etc'], 0, 'ls liste, wc -l compte les lignes.'],
|
||
['Où va la sortie de ls /faux 2> err.txt ?', ['À l’écran', 'Dans err.txt', 'Nulle part', 'Dans /faux'], 1, '2> redirige stderr, où sort le message d’erreur.']],
|
||
td: [['Lister les utilisateurs de /etc/passwd (1re colonne), triés.', 'cut -d: -f1 /etc/passwd | sort'], ['Compter les lignes de auth.log contenant « Failed ».', 'grep Failed /var/log/auth.log | wc -l'], ['Trouver les 3 adresses IP les plus fréquentes dans acces.log (1re colonne).', "cut -d' ' -f1 acces.log | sort | uniq -c | sort -rn | head -3"]],
|
||
tp: { type: 'IDE', url: 'apercu-ide.html?ex=bash-tp', desc: 'Exercices Bash avec tests automatiques.' } },
|
||
|
||
{ id: 'osi', match: /OSI|TCP\/IP|modèle|encapsulation/i, titre: 'Modèles OSI et TCP/IP', duree: '2 h', niveau: 'BTS SIO · BTS CIEL · BUT R&T 1',
|
||
objectifs: ['Nommer les couches OSI et TCP/IP', 'Associer protocoles et couches', 'Expliquer l’encapsulation'],
|
||
cm: [
|
||
['Pourquoi des couches ?', 'Pour communiquer, deux machines doivent se mettre d’accord sur beaucoup de choses : le câble, les adresses, la fiabilité, le format des données. Le modèle en couches sépare ces problèmes : chaque couche rend un service à celle du dessus.'],
|
||
['Les 7 couches OSI', '1 Physique (bits), 2 Liaison (trames, adresses MAC), 3 Réseau (paquets, adresses IP), 4 Transport (segments, ports, TCP/UDP), 5 Session, 6 Présentation, 7 Application (HTTP, DNS, SSH).'],
|
||
['Le modèle TCP/IP', 'Utilisé en pratique, il regroupe en 4 couches : Accès réseau (1-2), Internet (3), Transport (4), Application (5-7).'],
|
||
['Encapsulation', 'En descendant les couches, chacune ajoute son en-tête : données HTTP → segment TCP (ports) → paquet IP (adresses IP) → trame Ethernet (adresses MAC). À l’arrivée, chaque couche retire son en-tête : c’est la désencapsulation.']],
|
||
retenir: ['OSI : 7 couches · TCP/IP : 4 couches', 'MAC = couche 2 · IP = couche 3 · port = couche 4', 'Chaque couche ajoute un en-tête'],
|
||
qcm: [
|
||
['À quelle couche OSI appartient l’adresse IP ?', ['2', '3', '4', '7'], 1, 'La couche Réseau gère l’adressage IP et le routage.'],
|
||
['Quel protocole est de couche transport ?', ['HTTP', 'IP', 'UDP', 'Ethernet'], 2, 'TCP et UDP sont les protocoles de transport.'],
|
||
['Comment s’appelle l’unité de données de la couche 2 ?', ['Paquet', 'Segment', 'Trame', 'Bit'], 2, 'Couche Liaison = trame.'],
|
||
['Combien de couches compte le modèle TCP/IP ?', ['4', '5', '7', '3'], 0, 'Accès réseau, Internet, Transport, Application.']],
|
||
td: [['Classer par couche OSI : HTTP, IP, switch, TCP, câble RJ45, routeur.', '7 · 3 · 2 · 4 · 1 · 3'], ['Dessiner l’encapsulation d’une requête web.', 'HTTP → TCP (port 80/443) → IP (adresses) → Ethernet (MAC)'], ['Pourquoi DNS utilise-t-il souvent UDP ?', 'Requêtes courtes, pas besoin de connexion : UDP est plus rapide.']],
|
||
tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Observer l’encapsulation avec tcpdump pendant un curl.' } },
|
||
|
||
{ id: 'sql', match: /SQL|SELECT|requête/i, titre: 'Requêtes SQL : SELECT, WHERE, JOIN', duree: '3 h', niveau: 'NSI Terminale · BTS SIO SLAM · BUT Info',
|
||
objectifs: ['Écrire une requête de sélection', 'Filtrer et trier', 'Joindre deux tables'],
|
||
cm: [
|
||
['Une base relationnelle', 'Les données sont rangées en <b>tables</b> (lignes et colonnes). Chaque ligne a une <b>clé primaire</b> unique. Une <b>clé étrangère</b> fait référence à la clé d’une autre table.'],
|
||
['SELECT', '<code>SELECT nom, prenom FROM eleves;</code> affiche deux colonnes. <code>SELECT *</code> affiche tout. <code>DISTINCT</code> retire les doublons.'],
|
||
['Filtrer et trier', '<code>WHERE classe = \'SIO1\' AND moyenne >= 10</code> filtre, <code>ORDER BY moyenne DESC</code> trie, <code>LIMIT 5</code> garde les 5 premières lignes.'],
|
||
['Jointure et agrégats', '<code>SELECT e.nom, c.libelle FROM eleves e JOIN classes c ON e.classe_id = c.id;</code> relie deux tables. <code>COUNT</code>, <code>AVG</code>, <code>SUM</code> avec <code>GROUP BY</code> calculent par groupe.']],
|
||
retenir: ['SELECT … FROM … WHERE … ORDER BY', 'JOIN … ON relie les clés', 'GROUP BY pour les agrégats'],
|
||
qcm: [
|
||
['Quelle clause filtre les lignes ?', ['ORDER BY', 'WHERE', 'GROUP BY', 'FROM'], 1, 'WHERE garde les lignes qui vérifient la condition.'],
|
||
['Comment trier du plus grand au plus petit ?', ['ORDER BY x', 'ORDER BY x DESC', 'SORT x', 'ORDER x DOWN'], 1, 'DESC = décroissant.'],
|
||
['Que renvoie SELECT COUNT(*) FROM eleves ?', ['La liste des élèves', 'Le nombre de lignes', 'La première ligne', 'Une erreur'], 1, 'COUNT(*) compte les lignes.'],
|
||
['À quoi sert une clé étrangère ?', ['Chiffrer', 'Relier deux tables', 'Trier', 'Indexer le texte'], 1, 'Elle référence la clé primaire d’une autre table.']],
|
||
td: [['Afficher les élèves de SIO1 triés par nom.', "SELECT * FROM eleves WHERE classe = 'SIO1' ORDER BY nom;"], ['Moyenne par classe.', 'SELECT classe, AVG(moyenne) FROM eleves GROUP BY classe;'], ['Nom de chaque élève et libellé de sa classe.', 'SELECT e.nom, c.libelle FROM eleves e JOIN classes c ON e.classe_id = c.id;']],
|
||
tp: { type: 'IDE', url: 'apercu-ide.html?ex=sql-select', desc: 'Base SQLite dans le navigateur, requêtes corrigées automatiquement.' } },
|
||
|
||
{ id: 'python', match: /Python|programmation|boucle|variable/i, titre: 'Python : variables, conditions, boucles', duree: '3 h', niveau: 'SNT · NSI · BTS SIO SLAM · BUT',
|
||
objectifs: ['Manipuler des variables et des types', 'Écrire des conditions', 'Répéter avec for et while'],
|
||
cm: [
|
||
['Variables et types', 'Une variable associe un nom à une valeur : <code>age = 17</code>. Types courants : <code>int</code> (17), <code>float</code> (3.5), <code>str</code> ("Léa"), <code>bool</code> (True). <code>type(x)</code> donne le type.'],
|
||
['Conditions', '<code>if note >= 10:</code> puis un bloc indenté, <code>elif</code> pour un autre cas, <code>else</code> pour le reste. L’indentation (4 espaces) délimite les blocs.'],
|
||
['Boucle for', '<code>for i in range(5):</code> répète 5 fois avec i de 0 à 4. On peut parcourir une liste : <code>for nom in eleves:</code>.'],
|
||
['Boucle while et fonctions', '<code>while x < 100:</code> répète tant que la condition est vraie (attention aux boucles infinies). <code>def carre(x): return x * x</code> définit une fonction réutilisable.']],
|
||
retenir: ['L’indentation fait partie du code', 'range(n) va de 0 à n − 1', 'def … return pour réutiliser'],
|
||
qcm: [
|
||
['Que vaut type(3.0) ?', ['int', 'float', 'str', 'bool'], 1, '3.0 est un nombre à virgule.'],
|
||
['Combien de tours fait for i in range(3) ?', ['2', '3', '4', '0'], 1, 'i prend 0, 1, 2.'],
|
||
['Que délimite un bloc en Python ?', ['Les accolades', 'L’indentation', 'Les parenthèses', 'end'], 1, 'Python utilise l’indentation.'],
|
||
['Que renvoie len("réseau") ?', ['5', '6', '7', 'Erreur'], 1, '6 caractères.']],
|
||
td: [['Afficher les nombres pairs de 0 à 20.', 'for i in range(0, 21, 2): print(i)'], ['Écrire une fonction mention(note) qui renvoie « Bien » si note ≥ 14.', 'def mention(n):\n return "Bien" if n >= 14 else "—"'], ['Compter les voyelles d’un mot.', 'sum(1 for c in mot if c in "aeiouy")']],
|
||
tp: { type: 'IDE', url: 'apercu-ide.html?ex=py-pair', desc: 'Exercices Python corrigés par des tests automatiques.' } },
|
||
|
||
{ id: 'web', match: /HTML|CSS|Le Web|HTTP/i, titre: 'Le Web : HTTP, HTML et CSS', duree: '2 h', niveau: 'SNT · NSI · BTS SIO SLAM',
|
||
objectifs: ['Décrire un échange HTTP', 'Structurer une page en HTML', 'La mettre en forme avec CSS'],
|
||
cm: [
|
||
['URL et HTTP', 'Une URL (<code>https://site.fr/page</code>) indique le protocole, le serveur et la ressource. Le navigateur envoie une <b>requête</b> (GET, POST) et reçoit une <b>réponse</b> avec un code : 200 OK, 404 introuvable, 500 erreur serveur.'],
|
||
['HTML', 'HTML décrit la structure : <code><h1></code> titre, <code><p></code> paragraphe, <code><a href></code> lien, <code><img></code> image, <code><ul><li></code> liste. Les balises s’ouvrent et se ferment.'],
|
||
['CSS', 'CSS décrit l’apparence : <code>h1 { color: #ec3013; font-size: 2rem; }</code>. On cible par balise, par classe (<code>.carte</code>) ou par identifiant (<code>#menu</code>).'],
|
||
['HTTPS', 'HTTPS chiffre l’échange avec TLS. Le cadenas indique que le certificat du serveur est valide : personne ne peut lire ou modifier les données en chemin.']],
|
||
retenir: ['HTML = structure · CSS = apparence', '200, 404, 500 : les codes à connaître', 'HTTPS = HTTP + chiffrement TLS'],
|
||
qcm: [
|
||
['Que signifie le code HTTP 404 ?', ['OK', 'Ressource introuvable', 'Erreur serveur', 'Redirection'], 1, '404 = Not Found.'],
|
||
['Quelle balise crée un lien ?', ['<link>', '<a>', '<href>', '<url>'], 1, '<a href="…">.'],
|
||
['Quel langage gère les couleurs d’une page ?', ['HTML', 'CSS', 'HTTP', 'SQL'], 1, 'CSS gère la présentation.'],
|
||
['Quel port utilise HTTPS par défaut ?', ['80', '22', '443', '8080'], 2, 'HTTPS écoute sur 443.']],
|
||
td: [['Écrire une page avec un titre, un paragraphe et un lien.', '<h1>Titre</h1><p>Texte</p><a href="https://…">Lien</a>'], ['Mettre tous les paragraphes en gris foncé, taille 18 px.', 'p { color: #333; font-size: 18px; }'], ['Quelle méthode HTTP pour envoyer un formulaire de connexion ?', 'POST, pour ne pas mettre le mot de passe dans l’URL.']],
|
||
tp: { type: 'Lab web', url: 'apercu-lab-web.html', desc: 'Installer Apache sur la VM et voir sa page dans le navigateur relié.' } },
|
||
|
||
{ id: 'crypto', match: /mot de passe|hachage|chiffrement|crypto|cybers/i, titre: 'Mots de passe, hachage et chiffrement', duree: '2 h', niveau: 'BTS SIO · BTS CIEL · BUT R&T · Master cyber',
|
||
objectifs: ['Distinguer hachage et chiffrement', 'Expliquer le stockage sûr des mots de passe', 'Comprendre le chiffrement asymétrique'],
|
||
cm: [
|
||
['Hachage', 'Une fonction de hachage (SHA-256) transforme un texte en une empreinte de taille fixe. Impossible de revenir en arrière, et le moindre changement donne une empreinte totalement différente. Elle sert à vérifier l’intégrité.'],
|
||
['Stocker un mot de passe', 'On ne stocke jamais un mot de passe en clair. On stocke son hachage avec un <b>sel</b> aléatoire, par une fonction lente (bcrypt, Argon2) pour freiner les attaques par force brute.'],
|
||
['Chiffrement symétrique', 'Une même clé chiffre et déchiffre (AES). Rapide, mais il faut partager la clé de façon sûre.'],
|
||
['Chiffrement asymétrique', 'Une paire de clés : la <b>publique</b> chiffre, la <b>privée</b> déchiffre (RSA, courbes elliptiques). C’est la base de HTTPS et de SSH, et des signatures numériques.']],
|
||
retenir: ['Hachage = sens unique · chiffrement = réversible', 'Mot de passe : hachage lent + sel', 'Clé publique pour chiffrer, privée pour déchiffrer'],
|
||
qcm: [
|
||
['Peut-on retrouver un mot de passe à partir de son hachage ?', ['Oui, facilement', 'Non, c’est à sens unique', 'Oui avec la clé', 'Seulement en AES'], 1, 'Le hachage n’est pas réversible, on ne peut que tester des candidats.'],
|
||
['À quoi sert le sel ?', ['Accélérer', 'Rendre chaque hachage unique', 'Chiffrer', 'Compresser'], 1, 'Deux mots de passe identiques n’ont pas la même empreinte.'],
|
||
['Quel algorithme est symétrique ?', ['RSA', 'AES', 'SHA-256', 'ECDSA'], 1, 'AES utilise une seule clé.'],
|
||
['Avec quelle clé chiffre-t-on un message pour Alice ?', ['Sa clé privée', 'Sa clé publique', 'La nôtre', 'Aucune'], 1, 'Seule sa clé privée pourra le déchiffrer.']],
|
||
td: [['Calculer le hachage SHA-256 de « bonjour » puis de « Bonjour ». Comparer.', 'echo -n bonjour | sha256sum : les empreintes n’ont rien en commun.'], ['Pourquoi MD5 est-il déconseillé pour les mots de passe ?', 'Trop rapide et vulnérable aux collisions.'], ['Générer une paire de clés SSH.', 'ssh-keygen -t ed25519']],
|
||
tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Lab « SSH par clés » : générer, déposer et tester une clé.' } }
|
||
];
|