Systèmes d'exploitation

Se connecter pour s'inscrire

Processus, mémoire, fichiers et utilisateurs

Relier les notions de processus, mémoire, fichiers et appels système à un programme C observé et testé.

  1. Public cible

    Débutants, étudiants et professionnels qui souhaitent acquérir une pratique structurée dans ce domaine.

  2. Objectifs

    Comprendre les notions essentielles et les appliquer dans un projet vérifiable.

  3. Prérequis

    Aucune connaissance préalable n’est strictement obligatoire ; les prérequis détaillés sont précisés dans les ateliers.

  4. Niveau

    Tous niveaux

  5. Ressources

    • Documentation officielle et références citées dans les ateliers.
    • Exercices, examens et projet de synthèse du catalogue.
  6. Validation des compétences

    La validation repose sur les évaluations actives et les livrables pratiques du cours.

  7. Besoins techniques

    Un ordinateur, un navigateur et les outils indiqués dans le premier atelier sont suffisants pour commencer.

Exercices, examens et projets

Modèle et processus

Exercice

Atelier systèmes

Manipuler processus, mémoire et fichiers avec un programme C.

Obligatoire Consulter
Examen

Examen systèmes

Évaluer les notions de processus, mémoire, fichiers et appels système.

Obligatoire Consulter
Projet

Projet systèmes

Réaliser un programme système robuste et documenté.

Livrables :

  • Code source
  • Tests
  • Documentation
Obligatoire Consulter

Mémoire et fichiers

Exercice

Atelier systèmes

Manipuler processus, mémoire et fichiers avec un programme C.

Obligatoire Consulter
Examen

Examen systèmes

Évaluer les notions de processus, mémoire, fichiers et appels système.

Obligatoire Consulter
Projet

Projet systèmes

Réaliser un programme système robuste et documenté.

Livrables :

  • Code source
  • Tests
  • Documentation
Obligatoire Consulter

Systèmes d’exploitation

Comprendre ce qu’un système d’exploitation fait pour un programme — noyau, processus, mémoire, fichiers, périphériques, journaux et réseau — puis relier chaque constat à la commande qui le prouve.

À la fin du cours

  • Situer le rôle du noyau, les modes d’exécution et les appels système.
  • Décrire le cycle de vie d’un processus et lire son état avec les outils du système.
  • Expliquer ce que les threads partagent, et prévenir conditions de course et interblocages.
  • Relier pile, tas, pagination et fichier d’échange à une erreur d’allocation.
  • Manipuler chemins, permissions, propriétaires, groupes et liens sur un système de fichiers.
  • Diagnostiquer un périphérique absent, un service muet ou un accès refusé, preuve par preuve.
  • Observer et documenter avec des commandes dont on sait exactement ce qu’elles prouvent.

Organisation

Le cours va du noyau vers l’observation : modes et appels système, processus, threads, mémoire, fichiers, périphériques, journaux, réseau, durcissement, puis méthode d’observation.

Prérequis : Bases de programmation C et de ligne de commande.

Noyau, modes d’exécution et appels système

Le noyau est la seule partie du système qui parle directement au matériel : processeur, mémoire, disques, interfaces réseau. Il décide quel programme reçoit le processeur, à qui appartient une page mémoire, quel processus ouvre quel fichier. Tout ce qui vit au-dessus — interpréteur de commandes, applications, services — demande l’autorisation au lieu d’agir.

Deux modes d’exécution structurent cette séparation. En mode utilisateur, le code applicatif s’exécute sans accès direct au matériel : écrire dans la mémoire d’un autre programme ou piloter un disque déclenche une interception et l’arrêt du programme. En mode noyau, le code privilégié du noyau fait ce que l’application ne peut pas faire elle-même. C’est cette barrière qui empêche un programme défectueux de faire tomber la machine entière.

L’appel système est la porte entre les deux modes : le processus dépose un numéro d’appel et ses arguments, le processeur bascule en mode noyau, le noyau réalise l’opération pour le compte du processus puis rend la main avec un code de retour. Les fonctions open, read, write, fork, mmap ou socket franchissent cette porte ; printf ne la franchit pas, c’est une fonction de bibliothèque qui finira par demander un write.

La bascule n’est pas gratuite. Une boucle qui lit un octet à la fois paie deux changements de mode par octet, là où une lecture par bloc les amortit : un programme lent n’est donc pas toujours un programme qui calcule mal, c’est parfois un programme qui sollicite le noyau trop souvent.

Appel système Ce qu’il demande au noyau Code d’erreur de retour fréquent
open Ouvrir un fichier et obtenir un descripteur. EACCES : droits insuffisants. ENOENT : chemin absent.
fork Dupliquer le processus courant en un processus fils. EAGAIN : limite de processus ou de mémoire atteinte.
read et write Lire ou écrire des octets sur un descripteur. EBADF : descripteur fermé. EINTR : appel interrompu par un signal.
mmap Projeter un fichier ou une zone en mémoire. ENOMEM : plus d’espace adressable disponible.
socket Créer un point de communication réseau. EMFILE : trop de descripteurs ouverts par le processus.
graph LR A["Application : mode utilisateur"] -->|"appel système"| N["Noyau : mode privilégié"] N --> M["Processeur, mémoire, disques, réseau"] M -->|"résultat ou code d’erreur"| A A -. "instruction interdite" .-> E["Interception : arrêt du programme"]

Un programme qui échoue sans message utile se lit dans l’appel système fautif : l’outil de trace montre l’appel, ses arguments et le code de retour. Sans cette trace on devine, avec elle on sait — et la cause peut être citée dans un compte rendu.

Point de contrôle : Je distingue ce qui s’exécute en mode utilisateur de ce qui relève du noyau, et je nomme l’appel système derrière chaque opération.

Processus et concurrence

Un processus est un programme en cours d’exécution, avec son espace d’adressage, ses descripteurs de fichiers, ses droits et son identifiant. Le noyau l’ordonnance : il lui donne le processeur, le lui retire, puis le lui rend, de sorte que plusieurs programmes semblent progresser en même temps.

Son cycle de vie comporte quatre moments. La création charge l’image du programme ou duplique le processus père. L’exécution alterne entre prêt et élu, selon la décision de l’ordonnanceur. L’attente endort le processus jusqu’à ce qu’une ressource soit disponible : lecture disque, réponse réseau, temporisation. La terminaison ferme les descripteurs et libère la mémoire, mais laisse un enregistrement zombie jusqu’à ce que le père lise le code de retour.

Deux situations reviennent souvent. Un processus qui occupe le processeur sans jamais le rendre affame tous les autres et fait grimper la charge ; un processus qui dort sur une ressource bloquée entraîne toute une chaîne derrière lui sans consommer de processeur. Un fils jamais attendu reste zombie, un fils orphelin est recueilli par le processus d’initialisation du système.

Les commandes de supervision répondent à deux questions différentes. ps donne une photographie datée : identifiant, état, temps consommé, ligne de commande. top montre le même tableau en évolution et permet de le trier par consommation. La première prouve un instant, la seconde une tendance ; aucune des deux ne donne la cause.

# Photographie : qui consomme, dans quel etat, depuis quand ?
ps aux --sort=-%cpu | head -n 15
ps -eo pid,ppid,stat,etime,time,comm --sort=-time | head -n 15

# Suivi continu, trie par processeur puis par memoire
top

# Un processus precis : etat, nombre de threads, memoire, commande
ps -o pid,ppid,stat,nlwp,rss,etime,cmd -p 1234
État Signification Ce que l’intervenant en déduit
R ou S En cours, ou en veille simple en attente d’un événement. Un R permanent sur un service métier annonce une boucle sans issue.
D Attente d’entrée-sortie non interruptible. Suspicion immédiate sur le stockage ou un montage réseau bloqué.
Z Terminé, mais le père n’a pas encore lu le code de retour. Défaut de collecte dans le programme père, pas une fuite de mémoire.
T Suspendu par un signal, en attente de reprise. Intervention manuelle ou supervision : confirmer avant de le supprimer.
I Thread du noyau en veille. Normal en nombre limité ; une hausse brutale signale un module en défaut.
graph TD C["Création : fork puis chargement"] --> P["Prêt"] P --> E["Élu : le processus s’exécute"] E --> P E --> A["Attente : ressource indisponible"] A --> P E --> T["Terminaison : exit"] T --> Z["Zombie : code de retour à lire"] Z --> F["Collecté : fin du processus"]

Un processus à l’état D ne peut pas être réveillé : le supprimer ne libère pas toujours la ressource qu’il attend, et le redémarrage devient la seule sortie. C’est le seul état où le redémarrage se discute en premier, et il se documente comme tel.

Point de contrôle : Le programme indique son identifiant, son état et la raison de sa terminaison.

Threads, conditions de course et interblocages

Un thread est un fil d’exécution à l’intérieur d’un processus. Les threads d’un même processus partagent le même espace d’adressage : variables globales, allocations du tas, descripteurs de fichiers ouverts, bibliothèques chargées. Chaque thread possède en propre sa pile d’appels, ses registres et son compteur d’instruction.

Le partage est à la fois l’intérêt et le danger. Deux threads qui modifient la même variable sans coordination produisent une condition de course : le résultat dépend de l’ordre d’exécution, donc du hasard, et le défaut n’apparaît souvent qu’en charge. Un mécanisme de synchronisation rétablit un ordre ; l’oublier à la libération produit un interblocage, où deux threads s’attendent mutuellement et ne progressent plus.

Quatre règles évitent la majorité des cas : une seule ressource protégée par un seul verrou, un verrou pris et relâché dans la même fonction, jamais d’appel bloquant ou d’attente longue sous verrou, et un ordre de prise des verrous identique dans tout le programme. La dernière est celle qui supprime les interblocages circulaires.

Côté observation, un thread bloqué sur un verrou ne consomme pas de processeur : il est invisible dans un tableau trié par consommation. Il faut regarder les threads eux-mêmes, leur état et leur pile d’appels, puis la ressource qu’ils attendent.

# Les threads d un processus : etat et consommation
ps -T -p 1234
top -H -p 1234

# Un thread bloque : attente et pile d appels
pidstat -w -t -p 1234 1
Ressource Partagée entre threads ? Conséquence
Variables globales et allocations du tas Oui Condition de course : à protéger par un verrou.
Pile d’appels, registres, compteur d’instruction Non Chaque thread exécute ses propres fonctions sans conflit.
Descripteurs de fichiers Oui, table commune Un octet lu par un thread est perdu pour l’autre : la position est partagée.
Signaux reçus par le processus Oui Un signal destiné au processus réveille un thread quelconque.
Nom, affinité et priorité Non Réglables par thread : utile pour repérer le thread fautif.
graph TD T1["Thread 1 détient le verrou A"] --> T1B["Demande le verrou B"] T2["Thread 2 détient le verrou B"] --> T2B["Demande le verrou A"] T1B --> ATT["Attente circulaire : plus aucun thread n’avance"] T2B --> ATT ATT --> REG["Règle : ordre de prise des verrous identique"]

Un interblocage ne se répare pas à chaud, il se prévient. Un verrou pris avec un délai maximal, une seule ressource protégée à la fois et un ordre de prise fixé à l’écriture du code suffisent à éliminer la plupart des cas rencontrés en pratique.

Point de contrôle : Chaque donnée partagée entre threads est protégée par un verrou, et le verrou est toujours relâché.

Mémoire et appel système

Chaque processus dispose d’un espace d’adressage virtuel que le noyau fait correspondre à la mémoire physique par pages. Le programme voit des adresses continues ; dessous, les pages sont en mémoire physique, absentes et rangées dans le fichier d’échange, ou partagées avec un autre processus. Une pagination légère est normale ; une pagination continue est un symptôme.

La pile croît vers le bas au fil des appels et porte les variables locales, les adresses de retour et le contexte d’appel. Le tas croît vers le haut et porte ce qui est alloué dynamiquement et doit survivre à la fonction qui l’a demandé. Retourner l’adresse d’une variable locale consiste donc à rendre une zone déjà réutilisable : la panne survient plus tard, loin de la cause, et devient difficile à reproduire.

Quand la mémoire physique manque, le noyau déplace des pages vers le fichier d’échange. La machine reste disponible mais tout ralentit, car chaque accès à une page sortie coûte une entrée-sortie. Un effondrement des performances sans saturation du processeur est presque toujours un problème de mémoire et non de calcul : le premier réflexe est de regarder l’usage du fichier d’échange.

Une erreur d’allocation se lit dans l’ordre : tester la valeur retournée avant de l’utiliser, consulter le code d’erreur associé, puis mesurer la mémoire disponible et la limite appliquée au processus. Une allocation qui échoue alors que la machine a encore de la mémoire libre désigne une limite de ressources ou une fragmentation, pas un manque global.

# Memoire disponible, utilisee, et usage du fichier d echange
free -h
vmstat 1 5

# Detail par processus : memoire residente et virtuelle
ps -eo pid,comm,rss,vsz --sort=-rss | head -n 15

# Limites appliquees a un processus
ulimit -a
Zone mémoire Ce qu’elle contient Erreur typique
Pile Variables locales, adresses de retour, cadres d’appels. Dépassement par récursion sans condition d’arrêt : arrêt brutal du processus.
Tas Allocations dynamiques, à libérer explicitement. Fuite : mémoire allouée jamais rendue, consommation qui monte sans redescendre.
Données et code Variables globales, constantes, instructions du programme. Écriture dans une zone en lecture seule.
Bibliothèques partagées Code commun chargé une fois pour tous les processus. Version absente ou incompatible au démarrage.
graph TD P["Processus : adresses virtuelles"] --> T["Table des pages du noyau"] T --> R["Page présente en mémoire physique"] T --> S["Page absente : rapportée du disque"] R --> OK["Accès immédiat"] S --> L["Échange : chaque accès coûte une entrée-sortie"]

Une mesure prise une seule fois ne prouve rien en mémoire : consulter deux fois, à quelques secondes d’intervalle. Ce qui monte entre les deux lectures est une fuite, ce qui reste stable est un simple plateau d’utilisation.

Point de contrôle : Le programme gère ses allocations et ses ressources, et chaque erreur d’allocation est expliquée par un code d’erreur et une mesure.

Fichiers et permissions

Un chemin décrit l’emplacement logique d’une ressource : absolu depuis la racine de l’arborescence, relatif au répertoire courant. Le système le découpe en une suite de répertoires qu’il doit traverser. Cette traversée explique un accès refusé incompréhensible : sur un répertoire, le droit d’exécution n’autorise pas à lancer un programme, il autorise à franchir le répertoire pour atteindre ce qu’il contient.

Chaque fichier porte trois droits — lecture, écriture, exécution — pour trois catégories : le propriétaire, le groupe, les autres. Le masque de création, réglé par umask, retire des droits au moment de la création : avec un masque de 022, un fichier créé en 0666 arrive en 0644. Le masque se règle avant la création, jamais après, car corriger après coup laisse des fichiers déjà exposés.

Un lien physique est un second nom pour le même contenu : il partage droits, taille et données, et la suppression d’un nom ne supprime pas l’autre. Un lien symbolique est un raccourci qui contient un chemin : il peut pointer vers une cible absente, lien cassé, et il se résout vers ce que le chemin indique, ce qui autorise une sortie du répertoire prévu. Un service qui écrit ne doit jamais suivre un lien fourni de l’extérieur.

Les écritures sensibles se font en deux temps : écrire dans un fichier temporaire du même répertoire, puis renommer. Le renommage est atomique, donc un lecteur voit l’ancien contenu ou le nouveau, jamais un fichier à moitié écrit. C’est la seule façon d’éviter qu’une interruption laisse un fichier de configuration tronqué.

# Droits, proprietaire, groupe, taille, dates
ls -l /etc/app/config.txt
stat /etc/app/config.txt

# Appliquer des droits, un proprietaire et un groupe
chmod 640 /etc/app/config.txt
chown app:app /etc/app/config.txt

# Masque de creation, avant toute creation
umask 027

# Lien physique (meme contenu) et lien symbolique (raccourci)
ln /srv/data/base.db /srv/data/base.db.dur
ln -s /srv/data/base.db /srv/app/base.db
Notation Qui peut faire quoi Emploi conseillé
r, w, x Trois droits de base : 4 pour lire, 2 pour écrire, 1 pour exécuter. Base de toute décision, à additionner par catégorie.
644 Le propriétaire lit et écrit ; le groupe et les autres lisent. Contenu publié, jamais un secret.
600 Le propriétaire seul, personne d’autre. Clé privée, fichier de secrets.
640 Le propriétaire lit et écrit ; le groupe lit ; les autres rien. Configuration lue par un service dédié.
750 Le propriétaire fait tout ; le groupe lit et traverse ; les autres rien. Répertoire applicatif.
755 Le propriétaire fait tout ; le groupe et les autres lisent et traversent. Programme installé, accessible à tous.
umask 022 Retire l’écriture au groupe et aux autres à la création. Fichier en 644, répertoire en 755.
umask 077 Retire tout au groupe et aux autres à la création. Fichier en 600, répertoire en 700.
graph TD Q["Accès demandé"] --> G{"Le compte est-il le propriétaire ?"} G -->|"Oui"| D1["Droits du propriétaire"] G -->|"Non"| H{"Le compte est-il dans le groupe ?"} H -->|"Oui"| D2["Droits du groupe"] H -->|"Non"| D3["Droits des autres"] D1 --> T["Test du droit demandé : lecture, écriture ou traversée"] D2 --> T D3 --> T

Un fichier lisible dont le répertoire parent n’est pas traversable reste inaccessible : le test de droits porte sur chaque répertoire du chemin, pas seulement sur le fichier. C’est la première chose à vérifier quand la lecture échoue alors que les droits du fichier semblent corrects.

Point de contrôle : Le fichier créé porte les permissions documentées, appartient au bon compte et au bon groupe, et ne contient pas de secret en clair.

Périphériques, pilotes et diagnostic

Dans un système de la famille Unix, un périphérique n’est pas un objet séparé : c’est un fichier. Disques, terminaux, ports série et pseudo-périphériques apparaissent dans l’arborescence, sous /dev, et se manipulent avec les mêmes appels système qu’un fichier ordinaire. Un programme n’a donc pas besoin de savoir s’il écrit sur un disque, sur un port ou sur un tube.

Le pilote est le code du noyau qui parle au matériel. Lorsqu’il manque ou qu’il échoue, le périphérique est simplement invisible : aucun fichier, aucune interface, aucun message côté application. Le diagnostic commence alors par le journal du noyau, jamais par l’application, car c’est le noyau qui a vu, ou non, le branchement.

Pour un disque qui n’apparaît pas, la méthode va du physique au logiciel et chaque étape élimine une cause : alimentation et câble, puis visibilité par le noyau, puis fichiers de périphérique, puis table des partitions, puis système de fichiers, enfin point de montage. Sauter une étape fait chercher une erreur de montage là où le câble est débranché.

Une panne silencieuse s’annonce avant de frapper : compteurs d’erreurs qui montent, secteurs réattribués, lectures qui ralentissent. Relever ces compteurs à intervalle régulier est la seule façon d’anticiper, et une sauvegarde ne se décide pas au moment de la panne.

# Le noyau a-t-il vu le peripherique et le pilote ?
dmesg | tail -n 30

# Les disques et partitions exposes
lsblk
ls -l /dev/sd*

# Table des partitions et systemes de fichiers
fdisk -l
blkid

# Ce qui est monte, et ou
mount | grep srv
Étape Commande ou observation Ce qu’elle prouve
1 Alimentation et câble Voyant allumé, disque visible dans le microprogramme de la machine. Le disque est alimenté et détecté avant tout logiciel.
2 Noyau et pilote dmesg, consultation du journal du noyau Le noyau a vu le périphérique et le pilote s’est chargé.
3 Fichiers de périphérique lsblk, ls -l /dev/sd* Le noyau expose le disque et ses partitions.
4 Table des partitions fdisk -l, parted -l Une table est lisible et décrit les périmètres.
5 Système de fichiers blkid, fsck -n Le système de fichiers est identifiable et sain.
6 Montage mount, /etc/fstab Le système de fichiers est attaché à un répertoire.
graph TD D["Disque absent de l’arborescence"] --> A{"Le noyau l’a-t-il vu ?"} A -->|"Non"| C1["Alimentation, câble ou pilote manquant"] A -->|"Oui"| B{"Le fichier de périphérique existe ?"} B -->|"Non"| C2["Pilote en erreur, périphérique non réclamé"] B -->|"Oui"| E{"La table des partitions est lisible ?"} E -->|"Non"| C3["Table absente ou corrompue : restaurer ou recréer"] E -->|"Oui"| F{"Le système de fichiers est sain ?"} F -->|"Non"| C4["Vérifier puis réparer, sauvegarde avant"] F -->|"Oui"| G["Point de montage absent ou ligne de configuration fautive"]

Ne jamais lancer une réparation de système de fichiers sur un volume monté : l’opération modifie les données pendant que le système les utilise, et une panne de disque devient une perte de données. Démonter, ou travailler sur une copie.

Point de contrôle : Un disque absent est diagnostiqué du câble au point de montage, avec une preuve à chaque étape.

Journalisation et supervision locale

Un système en bonne santé parle peu dans ses journaux ; un système qui tombe y laisse tout. Les journaux locaux sont la mémoire des incidents et la première source à consulter, avant toute reproduction, parce qu’eux seuls datent les faits avec précision.

Les emplacements varient selon la distribution : fichiers texte sous /var/log pour les services classiques, journal binaire consulté avec journalctl quand le système est supervisé par systemd. Les deux cohabitent fréquemment ; savoir où chercher évite de perdre un temps précieux au mauvais endroit.

La rotation empêche les journaux de remplir le disque : ils sont découpés par taille ou par date, compressés, et un nombre limité de générations est conservé. Une rotation mal réglée produit l’un ou l’autre des deux excès : un journal presque vide qui ne prouve plus rien, ou un disque plein qui provoque une seconde panne.

Ce qu’on cherche en priorité, dans cet ordre : les erreurs et avertissements qui se répètent, la ligne qui précède immédiatement la première occurrence, les messages d’authentification avec leurs échecs, puis les événements de démarrage et d’arrêt des services. La première occurrence compte plus que la dernière, parce qu’elle précède la cause.

# Les cent dernieres lignes du systeme
tail -n 100 /var/log/syslog

# Un service precis, sur une fenetre de temps
journalctl -u nginx --since "2026-10-09 08:00" --until "2026-10-09 09:00"

# Les erreurs repetees et leur volume
journalctl -p err --since today
grep -c "echec" /var/log/auth.log
Journal Ce qu’il contient Ce qu’on y cherche en priorité
/var/log/syslog ou /var/log/messages Événements généraux du système et des services. La première erreur de la série, pas la dernière.
/var/log/auth.log ou /var/log/secure Connexions, échecs, élévations de droits. Tentatives répétées, comptes inconnus, usage de sudo.
Journal du noyau Pilotes, matériel, mémoire, stockage. Erreurs de disque, périphérique non réclamé, mémoire insuffisante.
journalctl -u service Toutes les lignes d’un service, redémarrages compris. La date du dernier redémarrage et l’erreur qui l’a précédé.
Journal applicatif Ce que le service a choisi de tracer. L’exception complète et l’identifiant de la requête concernée.
graph LR F["Fait système"] --> J["Journal local"] J --> R["Rotation : taille, date, compression"] R --> C["Générations limitées dans le temps"] J --> L["Lecture : journalctl ou fichiers"] L --> P["Preuve datée et exploitable"]

La rotation ne conserve qu’un nombre limité de générations : quelques jours plus tard, la preuve a disparu. Extraire immédiatement la fenêtre concernée avec son horodatage, dans un dossier d’incident, avant qu’elle ne soit compressée puis supprimée.

Point de contrôle : Pour une panne datée, je nomme le journal consulté, la commande employée et l’extrait retenu.

Réseau vu du système

Du point de vue du système, le réseau est un ensemble d’interfaces, d’adresses, de routes, de règles de résolution et de règles de filtrage. Une application qui n’atteint pas une cible peut être en défaut, mais le système est interrogé d’abord : c’est lui qui détient l’état réel, là où l’application ne voit qu’un refus.

Les interfaces portent les adresses et leur état ; la table de routage décide par où sort un paquet ; le résolveur traduit un nom en adresse, aidé d’un cache local et d’un fichier de configuration. Un même symptôme — le service ne répond pas — a des causes différentes selon le maillon en défaut, et les commandes ne se remplacent pas.

Le pare-feu local ajoute une seconde barrière, distincte de celle posée par l’équipement d’interconnexion. Une règle locale trop stricte coupe un service pourtant fonctionnel ; un port ouvert à la hâte pour un test reste ouvert. Le diagnostic réseau compare donc toujours les deux côtés : ce que la machine autorise, et ce que le réseau laisse entrer.

Depuis le système, on prouve que l’interface est active, que la route existe, que le nom se résout et que le service écoute. Depuis l’extérieur, on prouve que la même cible répond sur le même port. Un test qui réussit d’un seul côté désigne le filtrage, sans qu’il soit nécessaire de tout réinstaller.

# Interfaces, adresses, etat
ip a
ip link

# Routes et passerelle par defaut
ip route

# Le nom se resout-il, et vers quelle adresse ?
getent hosts srv-app.test
cat /etc/resolv.conf

# Ports en ecoute, avec le processus
ss -tlnp

# Regles locales du pare-feu
iptables -L -n -v
Maillon Commande Ce qu’elle prouve Ce qu’elle ne prouve pas
Interface et adresse ip a L’interface existe, porte une adresse, son état est actif. Que l’adresse est correcte pour le réseau.
Table de routage ip route Par où le système envoie ce qu’il ne sait pas router. Que la passerelle accepte réellement le trafic.
Résolution de nom getent hosts nom Le résolveur configuré traduit le nom en adresse. Que le service distant est joignable.
Port en écoute ss -tlnp Un service local attend sur une adresse et un port donnés. Que le filtrage laisse entrer le trafic.
Règles de filtrage iptables -L -n -v, nft list ruleset Les règles appliquées et leur compteur d’utilisation. Ce que laisse passer l’équipement en amont du poste.
graph TD A["Service injoignable"] --> B{"Interface avec adresse active ?"} B -->|"Non"| R1["Lien, adressage automatique ou service réseau arrêté"] B -->|"Oui"| C{"Route par défaut présente ?"} C -->|"Non"| R2["Table de routage incomplète"] C -->|"Oui"| D["Le nom se résout-il ?"] D -->|"Non"| R3["Résolveur, cache ou configuration"] D -->|"Oui"| E{"Le service écoute-t-il localement ?"} E -->|"Non"| R4["Service arrêté ou lié à la mauvaise adresse"] E -->|"Oui"| F{"Le pare-feu local laisse-t-il passer ?"} F -->|"Non"| R5["Règle locale trop stricte"] F -->|"Oui"| R6["Filtrage en amont : transmettre au réseau"]

Un service qui écoute uniquement sur l’adresse de boucle locale est injoignable depuis le réseau, alors que tout paraît correct en local. Vérifier l’adresse d’écoute avant d’accuser le pare-feu : c’est une cause plus fréquente qu’une règle oubliée.

Point de contrôle : Un service injoignable est localisé du lien au filtrage, avec une preuve du côté système et du côté réseau.

Durcissement minimal du système

Durcir consiste à réduire la surface exposée : moins de services actifs, moins de comptes, moins de droits permanents. Un système qui n’exécute que ce dont il a besoin tombe moins souvent et se diagnostique plus vite, parce qu’il y a moins de journaux à lire et moins de causes possibles.

Les services inutiles se neutralisent en premier : chacun est un point d’entrée, un processus à maintenir et une source de bruit dans les journaux. Arrêter un service ne suffit pas, il faut aussi l’empêcher de repartir au prochain démarrage, sinon la mesure ne survit pas au redémarrage suivant.

Les mises à jour de sécurité s’appliquent tôt et se vérifient en trois temps : lister les correctifs disponibles, contrôler la version réellement installée, puis recharger le service concerné. Une mise à jour appliquée sans rechargement laisse l’ancien code en mémoire : la version installée prouve le fichier, pas le processus.

Les comptes se réduisent et se surveillent : pas de compte partagé, pas de mot de passe vide, pas de session ouverte directement avec le compte d’administration. Les tâches d’administration passent par sudo, qui conserve chaque commande et chaque compte : c’est une piste d’audit autant qu’un confort d’exécution.

# Services reellement actifs
systemctl list-units --type=service --state=running

# Ports en ecoute et processus associes
ss -tlnp

# Comptes disposant d un interpreteur de commandes
getent passwd | grep -v nologin

# Droits accordes a un compte
sudo -l
Mesure Effet attendu Vérification
Arrêter et désactiver les services inutiles Moins de points d’entrée et de processus à maintenir. La liste des services actifs ne contient plus que le nécessaire, y compris après redémarrage.
Appliquer les mises à jour de sécurité Correctifs connus appliqués au système. La liste des mises à jour disponibles est vide.
Supprimer les comptes inutilisés Moins de cibles et moins de mots de passe à tourner. La liste des comptes ne contient que des comptes justifiés.
Interdire la connexion directe en administrateur Toute élévation de droits passe par sudo et se trace. Aucune session directe, chaque commande dans le journal d’audit.
Restreindre le pare-feu local Seuls les ports utiles sont joignables. Un balayage depuis l’extérieur ne voit que les ports attendus.
graph TD S["Système exposé"] --> A["Réduire les services"] A --> B["Réduire les comptes"] B --> C["Appliquer les correctifs"] C --> D["Restreindre le pare-feu"] D --> E["Superviser : journaux et alertes"] E --> A

Ouvrir un port « temporairement » sans date de retour est la faille la plus fréquente : la règle reste, et personne ne se souvient de son motif. Toute ouverture se note comme un contournement, avec son motif et sa date de retrait.

Point de contrôle : Le système ne fait tourner que les services justifiés, ses comptes sont connus et chaque élévation de droits est tracée.

Observer et reproduire

Une commande ne prouve que ce qu’elle mesure. ps montre un instant, top une tendance, ss un port en écoute, strace une séquence réelle d’appels, lsof un descripteur ouvert, journalctl un fait daté. Mélanger leurs conclusions produit un diagnostic flou que personne ne peut reproduire.

La méthode ne change pas : observer avant de modifier, changer une seule variable, reproduire, comparer. Un constat non reproductible n’est pas un diagnostic, c’est une coïncidence ; il ne peut ni être expliqué à un tiers ni servir de preuve.

Le laboratoire se prépare avec un programme aux entrées connues, des erreurs attendues et un protocole de compilation et d’exécution. Chaque observation est datée et recopiée telle quelle, sans correction après coup : la trace doit survivre à la rédaction du compte rendu.

# Protocole de laboratoire
# 1) Compilation avec tous les avertissements
cc -Wall -Wextra -O0 -g -o demo demo.c

# 2) Cas nominal : le programme donne son PID et son resultat
./demo data.txt

# 3) Erreurs provoquees : chemin absent, droits retires, allocation geante
./demo absent.txt
chmod 000 data.txt && ./demo data.txt ; chmod 644 data.txt

# 4) Observations pendant et apres l execution
ps -o pid,ppid,stat,rss,time,cmd -C demo
free -h
Commande Ce qu’elle prouve Ce qu’elle ne prouve pas
ps aux --sort=-%cpu La consommation et l’état des processus à un instant donné. Rien sur l’évolution : un pic peut être déjà passé.
top L’évolution du processeur, de la mémoire et de la charge. La cause : il reste à croiser avec le journal ou la trace.
ps -eLf, top -H Les threads, leur état et leur consommation. Le verrou en cause : seulement le blocage apparent.
free -h, vmstat 1 La mémoire disponible et l’usage du fichier d’échange. Qui consomme : il faut croiser avec les processus.
ls -l, stat Droits, propriétaire, groupe, taille et dates. Le contenu du fichier ni son usage réel.
ss -tlnp Les ports en écoute et le processus qui les détient. Le filtrage en amont du poste.
journalctl -u service Les faits datés d’un service, redémarrages compris. Ce qui s’est passé hors du système : réseau, matériel.
strace Les appels système réels, leurs arguments et leurs codes de retour. Le comportement voulu : seulement le comportement observé.

Le même scénario rejoué deux fois doit donner la même trace. S’il ne le fait pas, la cause est une variable non maîtrisée — environnement, minute de démarrage, ordre des threads — et le compte rendu doit le dire au lieu de cacher la différence.

Méthode

  1. Compiler avec les avertissements.
  2. Exécuter un cas nominal.
  3. Provoquer une erreur.
  4. Comparer les traces et l’état.
Point de contrôle : Le programme est compilé, exécuté, observé, et chaque commande employée indique la preuve qu’elle apporte.

Livrables et validation

Le livrable doit montrer une compréhension personnelle, des choix explicités et une vérification par un cas de test ou une procédure reproductible.

  • Un mini-programme C commenté par étapes.
  • Un protocole de compilation et d’exécution.
  • Des observations de processus, mémoire et fichiers.
  • Une analyse d’une erreur et de sa correction.
  • Un tableau de correspondance entre commande et preuve apportée.
  • Une fiche de diagnostic : disque absent, service muet ou accès refusé.
Critère de réussite : Le cours est validé lorsque le programme compile, produit le résultat attendu et que son comportement système est expliqué par des traces datées et reproductibles, chaque commande étant reliée à la preuve qu’elle apporte.

Publié le 09/05/2025