Module 4 — Linux Overview

🐧 4.1 — Pourquoi Linux en cybersecurite ?

Linux n'est pas qu'un systeme d'exploitation parmi d'autres. C'est le systeme de reference en cybersecurite, dans les data centers, sur les serveurs web et dans les SOC (Security Operations Centers).

Imagine une boite a outils universelle que tu peux personnaliser a l'infini : ajouter des tiroirs, changer les outils, modifier la serrure. C'est Linux. Contrairement a Windows qui est un coffre ferme dont seul Microsoft a la cle, Linux est open source — tu peux voir, modifier et adapter chaque piece.

Pourquoi les professionnels de la securite utilisent Linux ?

Open source — le code est visible, auditable, modifiable
Leger et performant — fonctionne sur du materiel minimal (serveurs, Raspberry Pi, conteneurs)
Controle total — chaque aspect du systeme est configurable via la ligne de commande
Outils de securite natifs — la majorite des outils de pentesting et de monitoring tournent sur Linux
Stabilite — les serveurs Linux tournent des mois/annees sans redemarrage
Scripting puissant — automatisation via Bash, Python, etc.

Les distributions cles en cybersecurite

Kali Linux — La distribution offensive

Basee sur Debian, elle est concue pour le penetration testing et l'audit de securite.

600+ outils pre-installes (Nmap, Wireshark, Metasploit, Burp Suite, John the Ripper...)
Utilisee par les pentesters, les red teams et les chercheurs en securite
Mise a jour reguliere avec les derniers outils

Attention

Kali n'est pas faite pour etre utilisee comme systeme principal. C'est un outil de travail, pas un OS du quotidien.

Ubuntu / Debian — La base solide

Ubuntu est la distribution la plus populaire pour les debutants et les serveurs.

Facilite d'utilisation — interface graphique moderne
LTS (Long Term Support) — support de 5 ans pour les versions stables
Enorme communaute — documentation et support abondants
Base de nombreux serveurs web et applications cloud

CentOS / RHEL — L'entreprise

Red Hat Enterprise Linux (RHEL) et son clone gratuit CentOS sont les references en entreprise.

Stabilite extreme — utilise en production dans les banques, hopitaux, gouvernements
SELinux — systeme de securite avancee integre
Cycle de support long — jusqu'a 10 ans
Gestionnaire de paquets : yum / dnf (vs apt pour Debian)

Security Onion — Le monitoring reseau

Distribution dediee a la detection d'intrusion et au monitoring reseau.

Integre Suricata (IDS), Zeek (analyse de trafic), Elasticsearch + Kibana
Utilisee dans les SOC pour la surveillance en temps reel
Deploiement rapide pour l'analyse forensique reseau

Linux dans les chiffres

Indicateur	Valeur
Part de marche sur les serveurs web	~80%
Part dans le cloud (AWS, Azure, GCP)	~90%
Supercomputers utilisant Linux (Top 500)	100%
Appareils Android bases sur le kernel Linux	~3 milliards

🏗️ 4.2 — Architecture Linux

Linux est organise en couches, du materiel (hardware) jusqu'a l'utilisateur. Comprendre ces couches est essentiel pour diagnostiquer des problemes et securiser un systeme.

Pense a un immeuble. Le hardware, c'est le terrain et les fondations. Le kernel, c'est la structure portante (murs, electricite, plomberie) — invisible mais indispensable. Le shell, c'est le concierge a l'accueil : il recoit tes demandes et les transmet. Les applications, ce sont les appartements ou tu vis et travailles.

Les couches de l'architecture Linux

👤 Applications & Utilisateur

Les programmes que tu utilises : navigateur, editeur, outils de securite (Nmap, Wireshark...).

Ils interagissent avec le systeme via le shell ou des appels systeme (system calls).

💻 Shell (interface en ligne de commande)

L'interprete de commandes. Le plus courant est Bash (Bourne Again Shell).

Il traduit tes commandes textuelles en appels systeme pour le kernel.

Autres shells : zsh, sh, fish, csh.

⚙️ Kernel (noyau)

Le coeur du systeme. Il gere :

Processus — creation, ordonnancement, terminaison
Memoire — allocation, memoire virtuelle, swap
Peripheriques — pilotes (drivers), acces au materiel
Systeme de fichiers — lecture/ecriture sur les disques
Reseau — pile TCP/IP, sockets

🔩 Hardware (materiel)

Le materiel physique : CPU, RAM, disques, carte reseau, GPU.

Le kernel communique avec le hardware via des drivers (pilotes).

Le Filesystem Hierarchy Standard (FHS)

Sous Linux, tout est organise dans une arborescence unique partant de / (root). Chaque repertoire a un role precis :

Repertoire	Role	Analogie
`/`	Racine du systeme de fichiers	Le hall d'entree de l'immeuble
`/home`	Repertoires personnels des utilisateurs	Les appartements individuels
`/etc`	Fichiers de configuration systeme	Le tableau electrique / les plans de l'immeuble
`/var`	Donnees variables (logs, emails, bases de donnees)	Les boites aux lettres et le journal de bord
`/tmp`	Fichiers temporaires (effaces au redemarrage)	Le tableau d'affichage temporaire
`/bin`	Programmes essentiels (ls, cp, cat...)	La boite a outils de base
`/sbin`	Programmes systeme (iptables, fdisk...)	Les outils reserves au technicien
`/usr`	Programmes et donnees utilisateur	La bibliotheque de l'immeuble
`/proc`	Systeme de fichiers virtuel (infos kernel/processus)	Le panneau de controle en temps reel
`/dev`	Fichiers representant les peripheriques	Les prises et branchements

Philosophie Linux

Sous Linux, tout est fichier (everything is a file). Les peripheriques (/dev/sda), les processus (/proc/1234), meme le reseau — tout est represente comme un fichier. Cette uniformite simplifie enormement l'administration.

⌨️ 4.3 — Commandes essentielles

La ligne de commande (CLI — Command Line Interface) est l'outil principal de tout analyste securite sous Linux. Voici les commandes incontournables classees par categorie.

La CLI, c'est comme parler directement au systeme dans sa langue maternelle. L'interface graphique (GUI), c'est comme utiliser un traducteur. Le CLI est plus rapide, plus precis, et permet d'automatiser des taches repetitives.

Commande	Description	Exemple
`pwd`	Affiche le repertoire courant (Print Working Directory)	`pwd` → `/home/analyst`
`ls`	Liste le contenu d'un repertoire	`ls -la /etc`
`cd`	Change de repertoire (Change Directory)	`cd /var/log`
`cat`	Affiche le contenu complet d'un fichier	`cat /etc/hostname`
`head`	Affiche les premieres lignes	`head -20 /var/log/syslog`
`tail`	Affiche les dernieres lignes	`tail -f /var/log/auth.log`
`less`	Affiche un fichier page par page	`less /etc/passwd`

Options detaillees de `ls`

Option	Description
`-l`	Format long (permissions, owner, group, taille, date)
`-a`	Affiche les fichiers caches (commencant par `.`)
`-la`	Combinaison : format long + fichiers caches (la plus utilisee en SOC)
`-lh`	Format long avec tailles lisibles (Ko, Mo, Go)
`-lt`	Tri par date de modification (le plus recent en premier)
`-lR`	Listing recursif de tous les sous-repertoires
`-li`	Affiche le numero d'inode de chaque fichier

Astuce SOC

tail -f permet de suivre un fichier log en temps reel. Indispensable pour monitorer les tentatives de connexion suspectes dans /var/log/auth.log.

ls -lat /tmp trie les fichiers de /tmp par date — utile pour identifier les fichiers recemment crees par un attaquant.

Commande	Description	Exemple
`cp`	Copie un fichier ou repertoire	`cp file.txt /backup/`
`mv`	Deplace ou renomme	`mv old.txt new.txt`
`rm`	Supprime un fichier	`rm -rf /tmp/malware/`
`mkdir`	Cree un repertoire	`mkdir -p /evidence/case42`
`touch`	Cree un fichier vide ou met a jour la date	`touch rapport.txt`

Danger

rm -rf / supprime TOUT le systeme. Ne jamais executer cette commande. L'option -rf signifie : recursif (-r) et force (-f), sans demander de confirmation.

Commande	Description	Exemple
`find`	Recherche des fichiers selon des criteres	`find / -name "*.log" -mtime -1`
`grep`	Recherche du texte dans des fichiers	`grep -r "FAILED" /var/log/`
`locate`	Recherche rapide via une base de donnees indexee	`locate passwd`
`which`	Localise un programme executable	`which nmap`

Options detaillees de `find`

Option	Description	Exemple
`-name`	Recherche par nom (sensible a la casse)	`find / -name "passwd"`
`-iname`	Recherche par nom (insensible a la casse)	`find / -iname "*.Conf"`
`-type f`	Fichiers uniquement	`find /etc -type f -name "*.conf"`
`-type d`	Repertoires uniquement	`find / -type d -name "backup"`
`-perm`	Recherche par permissions	`find / -perm -4000 -type f` (fichiers SUID)
`-perm -o+w`	Fichiers inscriptibles par tous	`find /var -perm -o+w -type f`
`-user`	Recherche par proprietaire	`find / -user root -perm -4000`
`-group`	Recherche par groupe	`find /home -group soc-team`
`-mtime -N`	Modifie dans les N derniers jours	`find / -mtime -1` (dernieres 24h)
`-mmin -N`	Modifie dans les N dernieres minutes	`find /tmp -mmin -30`
`-size +N`	Fichiers plus gros que N	`find / -size +100M` (plus de 100 Mo)
`-exec`	Execute une commande sur chaque resultat	`find /tmp -name "*.sh" -exec ls -la {} \;`
`-newer`	Fichiers plus recents qu'un fichier reference	`find / -newer /etc/passwd`

Options detaillees de `grep`

Option	Description	Exemple
`-r`	Recherche recursive dans les sous-repertoires	`grep -r "error" /var/log/`
`-i`	Insensible a la casse	`grep -i "failed" auth.log`
`-n`	Affiche les numeros de ligne	`grep -n "root" /etc/passwd`
`-v`	Inverse la recherche (lignes qui ne correspondent PAS)	`grep -v "nologin" /etc/passwd`
`-c`	Compte le nombre de correspondances	`grep -c "Failed" auth.log`
`-l`	Affiche seulement les noms de fichiers	`grep -rl "password" /etc/`
`-w`	Mot entier uniquement	`grep -w "root" /etc/passwd`
`-A N`	Affiche N lignes apres la correspondance	`grep -A 3 "error" syslog`
`-B N`	Affiche N lignes avant la correspondance	`grep -B 2 "Failed" auth.log`
`-E`	Active les expressions regulieres etendues (= `egrep`)	`grep -E "Failed\|Invalid" auth.log`

Exemples concrets pour un analyste SOC

find / -perm -4000 -type f 2>/dev/null — Lister tous les fichiers SUID du systeme
find /tmp -perm -o+w -type f -mtime -1 — Fichiers inscriptibles par tous dans /tmp, modifies dans les 24h
find / -user root -perm -4000 -not -path "/usr/*" — Fichiers SUID root en dehors des chemins normaux
grep -i "failed password" /var/log/auth.log — Chercher les tentatives de connexion echouees
grep -rn "192.168.1.100" /var/log/ — Chercher une IP suspecte dans tous les logs avec numeros de lignes
grep -E "Failed|Invalid|error" /var/log/auth.log | wc -l — Compter toutes les erreurs d'authentification
find / -name "*.php" -newer /etc/passwd — Fichiers PHP modifies apres un point de reference
find / -nouser -o -nogroup 2>/dev/null — Fichiers sans proprietaire ou sans groupe (orphelins, suspect)

La puissance de Linux reside dans la capacite a enchainer les commandes avec des pipes (|) et a rediriger les entrees/sorties.

Les descripteurs de fichiers

Chaque processus Linux a 3 flux de donnees standard :

Descripteur	Nom	Numero	Role
stdin	Standard Input	`0`	Entree (clavier par defaut)
stdout	Standard Output	`1`	Sortie normale (ecran par defaut)
stderr	Standard Error	`2`	Sortie d'erreur (ecran par defaut)

Operateurs de redirection

Operateur	Role	Exemple
`\|`	Pipe — envoie stdout d'une commande vers stdin d'une autre	`cat access.log \| grep "404"`
`>`	Redirige stdout vers un fichier (ecrase le contenu)	`ls -la > listing.txt`
`>>`	Redirige stdout vers un fichier (ajoute a la fin)	`echo "alerte" >> incidents.log`
`<`	Redirige un fichier comme stdin	`wc -l < access.log`
`2>`	Redirige stderr vers un fichier	`find / -name "*.conf" 2>/dev/null`
`2>&1`	Redirige stderr vers stdout (combine les deux)	`command > output.txt 2>&1`
`&>`	Redirige stdout ET stderr vers un fichier	`command &> all_output.txt`
`/dev/null`	Le "trou noir" — supprime toute donnee envoyee	`find / -perm -4000 2>/dev/null`

Commandes de traitement de texte (utilisees avec les pipes)

Commande	Role	Exemple
`sort`	Trie les lignes	`cat ips.txt \| sort`
`uniq`	Supprime les doublons consecutifs	`sort ips.txt \| uniq -c` (compte les occurrences)
`wc`	Compte les lignes (`-l`), mots (`-w`), caracteres (`-c`)	`cat auth.log \| grep "Failed" \| wc -l`
`cut`	Extrait des colonnes	`cut -d: -f1 /etc/passwd` (liste les noms d'utilisateurs)
`awk`	Traitement avance de colonnes	`awk -F: '$3 == 0 {print $1}' /etc/passwd`
`sed`	Editeur de flux (remplacement de texte)	`sed 's/old/new/g' file.txt`
`tee`	Lit stdin et ecrit dans stdout ET un fichier	`ls -la \| tee listing.txt`
`xargs`	Construit et execute des commandes a partir de stdin	`find / -name "*.tmp" \| xargs rm`

Un pipe, c'est comme une chaine de montage. Chaque ouvrier (commande) fait une tache precise et passe le resultat a l'ouvrier suivant. Exemple : cat auth.log | grep "Failed" | wc -l = lire le fichier → filtrer les echecs → compter les lignes.

Exemples de pipelines SOC courants

grep "Failed password" auth.log | awk '{print $11}' | sort | uniq -c | sort -rn | head -10
→ Top 10 des IP avec le plus de tentatives echouees
cat access.log | cut -d' ' -f1 | sort | uniq -c | sort -rn | head -20
→ Top 20 des IP les plus actives dans les logs Apache
ps aux | grep -v grep | grep "suspicious"
→ Chercher un processus suspect sans afficher la ligne grep elle-meme
netstat -tulnp 2>/dev/null | grep LISTEN | awk '{print $4}' | sort
→ Liste triee de tous les ports en ecoute

🔐 4.4 — Permissions et propriete des fichiers

Le systeme de permissions Linux est fondamental pour la securite. Il controle qui peut lire, ecrire ou executer chaque fichier et repertoire.

Imagine un document confidentiel dans un bureau. Le proprietaire (owner) peut tout faire avec. Les collegues du meme service (group) ont des droits limites. Les visiteurs (others) ne devraient avoir aucun acces. C'est exactement comme ca que Linux gere les permissions.

Comprendre la notation `rwx`

Decomposition des permissions : -rwxr-xr--

Type

Owner (u)

Group (g)

Others (o)

-

r w x

r - x

r - -

d = dir
- = file
l = link

Read + Write + Execute
= 7 (4+2+1)

Read + Execute
= 5 (4+0+1)

Read only
= 4 (4+0+0)

Valeurs octales

Permission	Symbole	Valeur octale	Signification
Read	`r`	4	Lire le contenu du fichier / lister un repertoire
Write	`w`	2	Modifier le fichier / ajouter/supprimer dans un repertoire
Execute	`x`	1	Executer le fichier / acceder a un repertoire
Aucune	`-`	0	Aucune permission

Permissions courantes a connaitre

Octal	Symbolique	Signification	Usage typique
`777`	`rwxrwxrwx`	Tous les droits pour tout le monde	Tres dangereux ! Jamais en production
`755`	`rwxr-xr-x`	Owner: tout. Group/Others: lecture + execution	Scripts executables, repertoires publics
`750`	`rwxr-x---`	Owner: tout. Group: lecture + execution. Others: rien	Repertoires d'equipe
`700`	`rwx------`	Owner uniquement, tous les droits	Repertoire `~/.ssh`, scripts prives
`644`	`rw-r--r--`	Owner: lire/ecrire. Group/Others: lecture seule	Fichiers de config, documents
`640`	`rw-r-----`	Owner: lire/ecrire. Group: lecture. Others: rien	Fichiers de logs sensibles
`600`	`rw-------`	Owner uniquement, lire/ecrire	Cles SSH (`~/.ssh/id_rsa`), `/etc/shadow`
`400`	`r--------`	Owner uniquement, lecture seule	Cles privees critiques

Methode de conversion octale

Pour convertir rwxr-x--- en octal :

rwx = 4+2+1 = 7
r-x = 4+0+1 = 5
--- = 0+0+0 = 0

Resultat : 750

Pour convertir 644 en symbolique :

6 = 4+2 = rw-
4 = 4 = r--
4 = 4 = r--

Resultat : rw-r--r--

Commandes de gestion des permissions

Commande	Description	Exemple
`chmod`	Modifie les permissions	`chmod 755 script.sh` `chmod u+x script.sh`
`chown`	Change le proprietaire	`chown analyst:soc rapport.txt`
`chgrp`	Change le groupe	`chgrp security /evidence/`

Permissions speciales (bits speciaux)

En plus des permissions classiques rwx, Linux dispose de 3 bits speciaux qui modifient le comportement d'execution. En notation octale, ils forment un 4eme chiffre place devant les 3 chiffres habituels.

Bit special	Valeur octale	Sur un fichier	Sur un repertoire	Symbole dans `ls -la`
SUID	`4000`	Execute avec les droits du proprietaire	(pas d'effet)	`s` a la place de `x` du owner
SGID	`2000`	Execute avec les droits du groupe	Fichiers crees heritent du groupe	`s` a la place de `x` du group
Sticky bit	`1000`	(pas d'effet)	Seul le proprietaire peut supprimer ses fichiers	`t` a la place de `x` des others

Quand le bit SUID est active sur un executable, celui-ci s'execute avec les privileges de son proprietaire (et non de l'utilisateur qui le lance).

Exemple classique : /usr/bin/passwd a le bit SUID pour permettre a un utilisateur de modifier son propre mot de passe (qui est stocke dans /etc/shadow, accessible uniquement par root).

ls -la /usr/bin/passwd → -rwsr-xr-x 1 root root

Fichiers SUID legitimes courants

Fichier	Permission	Raison
`/usr/bin/passwd`	`-rwsr-xr-x`	Permet aux utilisateurs de changer leur mot de passe
`/usr/bin/sudo`	`-rwsr-xr-x`	Permet l'elevation de privileges temporaire
`/usr/bin/su`	`-rwsr-xr-x`	Permet de changer d'utilisateur
`/usr/bin/ping`	`-rwsr-xr-x`	Necessite l'acces aux sockets raw (ICMP)

Mise en place : chmod 4755 script.sh ou chmod u+s script.sh

Risque de securite majeur

Un fichier SUID appartenant a root est une cible privilegiee pour l'escalade de privileges. Si un attaquant trouve une vulnerabilite dans un programme SUID root, il obtient un shell root.

Detection :

find / -perm -4000 -type f 2>/dev/null — Lister tous les fichiers SUID
find / -perm -4000 -type f -not -path "/usr/*" -not -path "/bin/*" 2>/dev/null — SUID en dehors des chemins normaux (suspect)
Un fichier SUID dans /tmp, /dev/shm, /home est un indicateur de compromission (IOC)

Sur un fichier executable : le programme s'execute avec les privileges du groupe proprietaire du fichier (similaire au SUID mais pour le groupe).

Sur un repertoire : tous les fichiers crees a l'interieur heritent automatiquement du groupe du repertoire (et non du groupe principal de l'utilisateur). Tres utile pour le travail collaboratif.

Exemple pratique

chmod 2770 /shared/project/ → drwxrws---

Tout fichier cree dans /shared/project/ appartiendra au groupe du repertoire, pas au groupe de l'utilisateur qui l'a cree.

Mise en place : chmod g+s repertoire/ ou chmod 2755 repertoire/

Detection

find / -perm -2000 -type f 2>/dev/null — Lister les fichiers SGID

Sur un repertoire, le sticky bit empeche les utilisateurs de supprimer ou renommer les fichiers des autres. Seuls le proprietaire du fichier, le proprietaire du repertoire ou root peuvent supprimer un fichier.

Exemple typique : /tmp a le sticky bit active (drwxrwxrwt) pour que chaque utilisateur puisse creer des fichiers temporaires sans que les autres les suppriment.

ls -ld /tmp → drwxrwxrwt 15 root root 4096 ...

Mise en place : chmod 1777 /tmp ou chmod +t /tmp

Note sur le symbole t vs T

t minuscule = sticky bit + permission x pour others → normal
T majuscule = sticky bit SANS permission x pour others → inhabituel
Meme logique pour SUID/SGID : s = bit special + x ; S = bit special SANS x

⚙️ 4.5 — Gestion des processus

Un processus est un programme en cours d'execution. Chaque processus a un identifiant unique appele PID (Process ID). Savoir surveiller et gerer les processus est essentiel pour detecter des activites suspectes.

Les processus, c'est comme les employes dans un immeuble de bureaux. Chaque employe (processus) a un badge (PID), un chef (parent process), un bureau (espace memoire) et une mission. En tant que gardien (analyste SOC), tu dois savoir qui est dans le batiment, ce qu'il fait, et reperer les intrus.

Commande	Description	Utilisation SOC
`ps aux`	Liste tous les processus en cours	Identifier des processus suspects
`ps -ef`	Liste avec hierarchie parent/enfant	Voir l'arborescence des processus
`top`	Moniteur en temps reel (CPU, RAM)	Detecter des processus gourmands (cryptominer ?)
`htop`	Version amelioree de top (interactive)	Analyse detaillee et intuitive
`kill <PID>`	Envoie un signal a un processus	`kill -9 1234` = terminer de force
`killall <nom>`	Tue tous les processus portant ce nom	`killall suspicious_process`
`jobs`	Liste les taches en arriere-plan du shell	Voir les processus lances en background
`bg / fg`	Envoie une tache en arriere/avant-plan	Gerer les outils lances en background
`nice / renice`	Ajuste la priorite d'un processus	Reduire la priorite d'un scan non urgent

Le repertoire `/proc`

Le systeme de fichiers virtuel /proc expose en temps reel les informations du kernel et des processus :

Chemin	Information
`/proc/<PID>/cmdline`	La commande qui a lance le processus
`/proc/<PID>/environ`	Les variables d'environnement du processus
`/proc/<PID>/fd/`	Les fichiers ouverts par le processus
`/proc/<PID>/exe`	Lien vers l'executable du processus
`/proc/cpuinfo`	Informations sur le processeur
`/proc/meminfo`	Informations sur la memoire
`/proc/net/tcp`	Connexions TCP actives

Indicateurs de compromission (IOC) dans les processus

Un processus svchost.exe sur Linux (c'est un processus Windows !)
Un processus lance depuis /tmp ou /dev/shm
Un processus avec un nom qui imite un service systeme (ex: sshd lance par un utilisateur non-root)
Un processus qui consomme enormement de CPU (potentiel cryptominer)
Des connexions reseau sortantes vers des ports inhabituels (4444, 5555, 8080...)

🌐 4.6 — Reseau sous Linux

Linux offre des outils reseau extremement puissants, utilises quotidiennement par les analystes SOC pour diagnostiquer, surveiller et securiser les communications.

Configuration et surveillance reseau

Commande	Description
`ip addr show`	Affiche les adresses IP des interfaces (remplace `ifconfig`)
`ip route show`	Affiche la table de routage
`ifconfig`	Ancienne commande (encore utilisee) pour la configuration IP
`ss -tulnp`	Liste les ports ouverts et les processus associes (remplace `netstat`)
`netstat -tulnp`	Ancienne commande pour les connexions/ports ouverts

Conseil

ss est le remplacant moderne de netstat, et ip remplace ifconfig. L'examen CyberOps Associate demande de connaitre les deux.

Outils de diagnostic

Commande	Description	Utilisation
`ping`	Teste la connectivite (ICMP Echo)	`ping -c 4 8.8.8.8`
`traceroute`	Trace le chemin des paquets	`traceroute google.com`
`tcpdump`	Capture de paquets en ligne de commande	`tcpdump -i eth0 port 443`
`curl / wget`	Telecharge ou teste des URL	`curl -I https://example.com`

Requetes DNS

Commande	Description	Exemple
`nslookup`	Requete DNS simple	`nslookup example.com`
`dig`	Requete DNS detaillee (plus puissant)	`dig example.com MX`
`host`	Requete DNS rapide	`host example.com`

dig est l'outil prefere des analystes car il fournit des informations detaillees sur les enregistrements DNS (A, AAAA, MX, NS, CNAME, TXT...).

iptables — Le firewall Linux

iptables est le firewall integre au kernel Linux (module netfilter). Il filtre les paquets selon des regles organisees en tables, chaines et actions.

Les 3 tables principales

Table	Role	Chaines utilisees
filter (defaut)	Filtrage des paquets (accepter, rejeter, supprimer)	INPUT, OUTPUT, FORWARD
nat	Traduction d'adresses (Network Address Translation)	PREROUTING, POSTROUTING, OUTPUT
mangle	Modification des en-tetes de paquets (TTL, TOS, marquage)	Toutes les chaines

Les 3 chaines de la table filter

Chaine	Role	Quand est-elle evaluee ?
INPUT	Trafic entrant destine a la machine locale	Paquets recus a destination de ce serveur
OUTPUT	Trafic sortant genere par la machine locale	Paquets envoyes par ce serveur
FORWARD	Trafic transitant par la machine (routage)	Paquets routes d'un reseau a un autre

Les actions (targets)

Action	Effet	Reponse au client
ACCEPT	Autorise le paquet	Le paquet est transmis
DROP	Supprime le paquet silencieusement	Aucune reponse (le client attend un timeout)
REJECT	Refuse le paquet avec une notification	Message ICMP "port unreachable" envoye
LOG	Enregistre le paquet dans les logs	Le paquet continue dans la chaine

Commandes essentielles

Commande	Description
`iptables -L -n -v`	Liste toutes les regles (avec compteurs de paquets)
`iptables -L -n --line-numbers`	Liste les regles avec numeros de ligne
`iptables -A INPUT -p tcp --dport 22 -j ACCEPT`	Autorise SSH entrant
`iptables -A INPUT -p tcp --dport 23 -j DROP`	Bloque Telnet entrant
`iptables -A INPUT -s 10.0.0.55 -j DROP`	Bloque tout le trafic d'une IP suspecte
`iptables -A OUTPUT -d 185.234.72.0/24 -j DROP`	Bloque le trafic sortant vers un reseau malveillant
`iptables -I INPUT 1 -p tcp --dport 80 -j ACCEPT`	Insere une regle en position 1 (prioritaire)
`iptables -D INPUT 3`	Supprime la regle numero 3 de la chaine INPUT
`iptables -F`	Efface (flush) toutes les regles
`iptables -P INPUT DROP`	Politique par defaut : bloquer tout le trafic entrant

A retenir pour l'examen

Les regles sont evaluees dans l'ordre (top-down). La premiere regle qui correspond est appliquee.
Si aucune regle ne correspond, la politique par defaut (policy) est appliquee.
Bonne pratique : politique par defaut = DROP, puis ajouter des regles ACCEPT specifiques (approche whitelist).
DROP vs REJECT : DROP est plus discret (pas de reponse), REJECT est plus courtois (notification).
Les regles ne sont pas persistantes par defaut — elles disparaissent au redemarrage. Utiliser iptables-save et iptables-restore.

⏰ 4.7 — Planification de taches (cron, at, systemd timers)

Les taches planifiees sont essentielles pour l'administration systeme, mais aussi un vecteur d'attaque courant. Un attaquant peut installer un cron job pour maintenir sa persistance sur un systeme compromis.

Un cron job, c'est comme un reveil programme. Tu le regles une fois, et il execute une tache a l'heure dite, chaque jour, chaque semaine... Un attaquant peut aussi programmer un "reveil" qui relance son malware toutes les 5 minutes.

crontab — Le planificateur classique

Le format d'une entree crontab comporte 5 champs de temps + la commande :

*     *     *     *     *    commande
|     |     |     |     |
|     |     |     |     +-- Jour de la semaine (0-7, 0 et 7 = dimanche)
|     |     |     +-------- Mois (1-12)
|     |     +------------- Jour du mois (1-31)
|     +------------------ Heure (0-23)
+----------------------- Minute (0-59)

Exemple	Signification
`0 2 * * * /backup.sh`	Tous les jours a 2h00
`/5 * * * /check.sh`	Toutes les 5 minutes
`0 0 * * 0 /weekly.sh`	Chaque dimanche a minuit
`30 8 1 * * /monthly.sh`	Le 1er de chaque mois a 8h30
`@reboot /startup.sh`	A chaque demarrage du systeme

Commandes de gestion cron

Commande	Description
`crontab -l`	Lister les cron jobs de l'utilisateur courant
`crontab -e`	Editer les cron jobs
`crontab -l -u root`	Lister les cron jobs de root (necessite sudo)
`crontab -r`	Supprimer tous les cron jobs

Fichiers et repertoires cron

Emplacement	Description
`/etc/crontab`	Crontab systeme global
`/etc/cron.d/`	Cron jobs additionnels du systeme
`/etc/cron.daily/`	Scripts executes quotidiennement
`/etc/cron.hourly/`	Scripts executes toutes les heures
`/etc/cron.weekly/`	Scripts executes chaque semaine
`/etc/cron.monthly/`	Scripts executes chaque mois
`/var/spool/cron/crontabs/`	Crontabs individuels des utilisateurs

at — Tache unique a une heure donnee

Contrairement a cron (recurrent), at execute une commande une seule fois a un moment donne.

Commande	Description
`at 14:00`	Planifier une tache a 14h00 aujourd'hui
`at now + 30 minutes`	Planifier une tache dans 30 minutes
`atq`	Lister les taches `at` en attente
`atrm <job_id>`	Supprimer une tache planifiee

systemd timers — L'alternative moderne

Les systemd timers remplacent progressivement cron sur les distributions modernes.

Commande	Description
`systemctl list-timers`	Lister tous les timers actifs
`systemctl list-timers --all`	Lister tous les timers (actifs et inactifs)
`systemctl status <timer>.timer`	Voir le statut d'un timer specifique

Securite : taches planifiees et persistance

Les attaquants utilisent les cron jobs pour maintenir leur acces. Lors d'une investigation, verifier :

crontab -l -u root — Cron jobs de root
ls -la /etc/cron.d/ — Fichiers cron du systeme
cat /etc/crontab — Crontab systeme
for user in $(cut -d: -f1 /etc/passwd); do crontab -l -u $user 2>/dev/null; done — Cron jobs de tous les utilisateurs
Un cron job qui execute un script dans /tmp ou qui telecharge un fichier depuis Internet est tres suspect

📦 4.8 — Gestion des paquets (apt, yum/dnf, rpm)

La gestion des paquets permet d'installer, mettre a jour et supprimer des logiciels de maniere securisee. Chaque famille de distributions Linux utilise son propre gestionnaire de paquets.

apt — Advanced Package Tool (Debian, Ubuntu, Kali)

Commande	Description
`apt update`	Met a jour la liste des paquets disponibles
`apt upgrade`	Met a jour tous les paquets installes
`apt install <paquet>`	Installe un paquet
`apt remove <paquet>`	Desinstalle un paquet (garde la config)
`apt purge <paquet>`	Desinstalle un paquet + sa configuration
`apt search <mot-cle>`	Recherche un paquet
`apt show <paquet>`	Affiche les details d'un paquet
`apt list --installed`	Liste tous les paquets installes
`dpkg -l`	Liste tous les paquets installes (bas niveau Debian)
`dpkg -L <paquet>`	Liste les fichiers installes par un paquet

yum / dnf (RHEL, CentOS, Fedora)

dnf est le remplacant moderne de yum (meme syntaxe, meilleure performance).

Commande	Description
`yum update` / `dnf update`	Met a jour tous les paquets
`yum install <paquet>`	Installe un paquet
`yum remove <paquet>`	Desinstalle un paquet
`yum search <mot-cle>`	Recherche un paquet
`yum info <paquet>`	Affiche les details d'un paquet
`yum list installed`	Liste tous les paquets installes

rpm — Red Hat Package Manager (bas niveau)

rpm est l'outil de bas niveau pour gerer les paquets .rpm (comme dpkg pour .deb).

Commande	Description
`rpm -qa`	Liste tous les paquets installes
`rpm -qi <paquet>`	Informations detaillees sur un paquet
`rpm -ql <paquet>`	Liste les fichiers installes par un paquet
`rpm -ivh <paquet.rpm>`	Installe un paquet depuis un fichier .rpm
`rpm -e <paquet>`	Desinstalle un paquet

Securite et gestion des paquets

Toujours maintenir les paquets a jour (apt update && apt upgrade) pour corriger les vulnerabilites
Verifier les depots configures : cat /etc/apt/sources.list (Debian) ou ls /etc/yum.repos.d/ (RHEL)
Un depot non officiel ajoute par un attaquant peut fournir des paquets compromis
Verifier l'integrite : dpkg --verify (Debian) ou rpm -Va (RHEL) pour detecter les fichiers modifies

📋 4.9 — Fichiers de configuration critiques

Un analyste SOC doit connaitre les fichiers de configuration cles de Linux. Ce sont souvent les premieres cibles lors d'une intrusion et les premieres sources d'information lors d'une investigation.

Chaque ligne represente un utilisateur. Le fichier est lisible par tous (644). Format exact avec 7 champs separes par : :

username:password:UID:GID:comment:home_directory:shell

Exemple : analyst:x:1001:1001:SOC Analyst:/home/analyst:/bin/bash

#	Champ	Exemple	Signification
1	Username	`analyst`	Nom de connexion de l'utilisateur
2	Password	`x`	`x` = mot de passe stocke dans `/etc/shadow`. Si vide, pas de mot de passe
3	UID	`1001`	User ID — identifiant numerique unique
4	GID	`1001`	Group ID — identifiant du groupe principal
5	Comment (GECOS)	`SOC Analyst`	Description, nom complet ou commentaire
6	Home directory	`/home/analyst`	Repertoire personnel de l'utilisateur
7	Shell	`/bin/bash`	Shell de connexion. `/usr/sbin/nologin` ou `/bin/false` = pas d'acces interactif

Plages d'UID a connaitre

Plage UID	Type de compte	Exemples
0	root (superutilisateur)	`root` — acces total au systeme
1 — 999	Comptes systeme / services	`daemon` (1), `sshd` (105), `www-data` (33), `mysql` (106)
1000+	Utilisateurs normaux (humains)	`analyst` (1001), `admin` (1000)
65534	Compte `nobody`	Utilise pour les processus sans privileges

Points de vigilance pour le SOC

Un compte avec UID 0 autre que root est tres suspect (backdoor) : awk -F: '$3 == 0 {print $1}' /etc/passwd
Un compte avec un shell interactif (/bin/bash, /bin/sh) mais un nom de service est suspect
Un compte avec home dans /tmp est un signe de compromission
Comptes sans mot de passe (champ 2 vide) : awk -F: '$2 == "" {print $1}' /etc/passwd

Contient les mots de passe haches (non lisibles) de chaque utilisateur. Accessible uniquement par root (640 : rw-r----- root:shadow).

Format exact avec 9 champs separes par : :

username:password_hash:lastchange:min:max:warn:inactive:expire:reserved

#	Champ	Description
1	Username	Nom de l'utilisateur (doit correspondre a `/etc/passwd`)
2	Password hash	Mot de passe hache. `!` ou `*` = compte verrouille. Vide = pas de mot de passe
3	Last change	Date du dernier changement de mot de passe (jours depuis le 1er janvier 1970)
4	Min	Nombre minimum de jours avant de pouvoir changer le mot de passe
5	Max	Nombre maximum de jours de validite du mot de passe
6	Warn	Nombre de jours d'avertissement avant expiration
7	Inactive	Nombre de jours apres expiration avant desactivation du compte
8	Expire	Date d'expiration du compte (jours depuis le 1er janvier 1970)
9	Reserved	Champ reserve pour usage futur

Algorithmes de hachage (prefixe du hash)

Prefixe	Algorithme	Securite
$1$	MD5	Faible — obsolete, facile a casser
$5$	SHA-256	Correct
$6$	SHA-512	Recommande (le plus courant actuellement)
$y$	yescrypt	Excellent (nouveau defaut sur les distributions modernes)
$2b$	bcrypt	Tres bon (utilise par certains systemes)

Forensique et securite

Si un attaquant obtient /etc/shadow, il peut tenter un brute force offline avec John the Ripper ou Hashcat
Commande pour verifier les comptes sans mot de passe : awk -F: '($2 == "" || $2 == "!") {print $1}' /etc/shadow
Verifier les permissions : ls -la /etc/shadow — doit etre -rw-r----- ou -rw-------

/etc/hosts — Table de resolution locale (prioritaire sur le DNS) :

127.0.0.1 localhost
192.168.1.10 dc.corp.local

Un attaquant peut modifier ce fichier pour rediriger du trafic vers un serveur malveillant.

/etc/resolv.conf — Serveurs DNS utilises :

nameserver 192.168.1.10
nameserver 8.8.8.8

Un changement non autorise des serveurs DNS est un signe de compromission (DNS hijacking).

Les logs sont la mine d'or de l'analyste SOC. Linux utilise deux systemes de journalisation :

rsyslog / syslog-ng — systeme traditionnel, ecrit dans des fichiers texte dans /var/log/
systemd-journald — systeme moderne, stocke des logs binaires interroges avec journalctl

Fichiers de logs critiques

Fichier	Contenu	Interet SOC
`/var/log/syslog`	Logs systeme generaux (Debian/Ubuntu)	Vue d'ensemble de l'activite systeme
`/var/log/messages`	Logs systeme generaux (CentOS/RHEL)	Equivalent de syslog sur RHEL
`/var/log/auth.log`	Tentatives de connexion, sudo, SSH (Debian/Ubuntu)	Detection de brute force, acces non autorises
`/var/log/secure`	Equivalent de auth.log (CentOS/RHEL)	Memes alertes sur RHEL
`/var/log/kern.log`	Messages du kernel	Detection de modules malveillants, erreurs hardware
`/var/log/boot.log`	Messages de demarrage	Services lances au boot
`/var/log/cron.log`	Execution des taches planifiees (cron)	Detection de cron jobs malveillants
`/var/log/apache2/`	Logs du serveur web Apache	Analyse des attaques web (SQLi, XSS, scans)
`/var/log/mail.log`	Logs du serveur de messagerie	Detection de spam, phishing
`/var/log/faillog`	Tentatives de connexion echouees	Brute force (commande `faillog`)
`/var/log/lastlog`	Dernieres connexions de chaque utilisateur	Commande `lastlog`
`/var/log/wtmp`	Historique des sessions (binaire)	Commande `last`
`/var/log/btmp`	Tentatives de connexion echouees (binaire)	Commande `lastb`

journalctl — Le journal systemd

journalctl est l'outil de consultation des logs de systemd-journald, present sur toutes les distributions modernes.

Commande	Description
`journalctl`	Affiche tous les logs du journal
`journalctl -f`	Suivi en temps reel (equivalent de `tail -f`)
`journalctl -u sshd`	Logs d'un service specifique (ici SSH)
`journalctl -u apache2 --since "1 hour ago"`	Logs d'Apache de la derniere heure
`journalctl --since "2026-02-22" --until "2026-02-23"`	Logs d'une periode specifique
`journalctl -p err`	Uniquement les erreurs et au-dessus
`journalctl _UID=1001`	Logs d'un utilisateur specifique (par UID)
`journalctl -b`	Logs depuis le dernier demarrage
`journalctl -b -1`	Logs du demarrage precedent
`journalctl --disk-usage`	Espace disque utilise par les logs

Commandes d'investigation SOC

tail -f /var/log/auth.log — Surveillance en temps reel des authentifications
grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -rn — Top IP des tentatives echouees
last -a — Dernieres sessions avec adresse source
lastb — Tentatives de connexion echouees (necessite root)
journalctl -u sshd --since "1 hour ago" | grep -i "failed" — Echecs SSH recents
journalctl -p warning..emerg --since today — Toutes les alertes critiques du jour

🔬 4.10 — Lab : Terminal Linux simule

Pratique les commandes Linux essentielles pour un analyste SOC. Tape les commandes dans le terminal ci-dessous pour explorer un systeme Linux simule.

Commandes disponibles

Essaie : ls, ls -la, ls /etc, ls /var/log, pwd, cd /var/log, cat /etc/passwd, cat /etc/hosts, cat /etc/resolv.conf, head /var/log/auth.log, grep "Failed" /var/log/auth.log, chmod 755 script.sh, ps aux, top, netstat -tulnp, ss -tulnp, ip addr, whoami, id, uname -a, find /tmp -perm -4000, last, help

bash — Linux Terminal

Linux soc-workstation 5.15.0-91-generic (Ubuntu 22.04 LTS)

Last login: Sat Feb 22 08:00:15 2026 from 192.168.1.5

analyst@soc:~$

Investigation : peux-tu trouver les anomalies ?

Ce systeme Linux a ete compromis ! Utilise les commandes pour trouver :

Un compte utilisateur suspect avec UID 0 (droits root)
Une redirection DNS malveillante dans /etc/hosts
Des tentatives de brute force SSH suivies d'une connexion reussie
Deux processus malveillants (un cryptominer et un reverse shell)
Un port suspect en ecoute (4444)
Des fichiers SUID suspects dans /tmp
Une connexion root suspecte depuis une IP externe a 3h du matin

🔎 4.11 — Analyse des logs Linux pour la sécurité

En forensique et monitoring, les fichiers de logs Linux sont des sources de preuves essentielles pour reconstituer une attaque ou détecter une intrusion.

Fichier de log	Contenu	Usage sécurité
`/var/log/auth.log` (Debian/Ubuntu)	Authentifications, sudo, SSH	Détecter les tentatives de brute-force SSH, les élévations de privilèges suspectes
`/var/log/secure` (RHEL/CentOS)	Même contenu qu'auth.log	Équivalent RedHat d'auth.log
`/var/log/syslog`	Messages système généraux	Détecter les erreurs critiques, les redémarrages suspects de services
`/var/log/kern.log`	Messages du noyau	Détecter les modules noyau malveillants (rootkits), erreurs matérielles
`/var/log/cron`	Exécutions de tâches cron	Identifier les tâches cron malveillantes (persistence)
`/var/log/apache2/access.log`	Requêtes HTTP reçues	Détecter les scans, injections SQL, directory traversal
`/var/log/lastlog`	Dernière connexion par utilisateur	Identifier les comptes jamais utilisés qui se connectent soudainement
`/var/log/btmp`	Tentatives de connexion échouées	Détecter les attaques brute-force (lu avec `lastb`)
`/var/log/wtmp`	Historique des connexions/déconnexions	Reconstituer la timeline d'activité (lu avec `last`)

Commandes d'investigation essentielles

Commande	Usage
`last`	Afficher l'historique des connexions (lit `/var/log/wtmp`)
`lastb`	Afficher les connexions échouées (lit `/var/log/btmp`)
`lastlog`	Dernière connexion de chaque utilisateur
`journalctl`	Interroger le journal systemd (filtrage par service, date, priorité)
`journalctl -u sshd --since "1 hour ago"`	Logs SSH de la dernière heure
`ausearch -m USER_LOGIN`	Rechercher les événements de login dans les logs d'audit

Attention à la manipulation des logs

Un attaquant sophistiqué peut effacer ou modifier les logs locaux. C'est pourquoi la centralisation des logs (syslog-ng, rsyslog vers un serveur distant) est essentielle : même si l'attaquant efface les logs locaux, les copies distantes sont préservées.

Linux Overview