Maîtrise du Terminal Bash

Le guide complet pour débutants en ligne de commande Linux

Pourquoi apprendre le terminal ?

Qu'est-ce qu'un terminal ?

Un terminal (ou console) est une interface textuelle qui permet d'interagir avec un système d'exploitation en tapant des commandes. Contrairement aux interfaces graphiques (GUI), il offre un contrôle précis et puissant sur le système.

Sous Linux, le terminal utilise généralement le shell Bash (Bourne Again SHell), qui est un interpréteur de commandes avancé.

Pourquoi c'est essentiel pour le hacking ?

Le terminal est l'outil principal des hackers car il permet d'accéder à toutes les fonctionnalités du système, d'automatiser des tâches, d'analyser des réseaux, et d'exécuter des scripts puissants.

La plupart des outils de cybersécurité (comme Nmap, Metasploit, Wireshark) s'utilisent en ligne de commande. Maîtriser Bash est donc une compétence fondamentale.

Conseil de sécurité

Soyez prudent avec les commandes que vous exécutez, surtout avec sudo. Une mauvaise commande peut endommager votre système ou vos données.

Comment ouvrir un terminal ?

Bon à savoir

Vous pouvez personnaliser votre terminal (couleurs, police, alias) pour le rendre plus agréable à utiliser. Le fichier de configuration est généralement ~/.bashrc.

10 Exercices pour maîtriser Bash

Exercice 1: Navigation et permissions

Objectif : Maîtriser la création d'arborescence et gestion des permissions.

Contexte :

Vous devez créer une structure de projet avec des permissions adaptées :

mon_projet/
├── docs/               (permissions: 755)
│   ├── rapport.txt     (permissions: 644)
│   └── images/         (permissions: 755)
├── src/                (permissions: 755)
│   ├── main.sh         (permissions: 755 - exécutable)
│   └── utils/          (permissions: 755)
└── logs/               (permissions: 755)

Étape 1: Création de l'arborescence

Créez la structure de dossiers et fichiers :

Indice : Utilisez mkdir -p et touch

# Création récursive des dossiers
mkdir mon_projet
cd mon_projet
mkdir -p docs/images src/utils logs
# Création des fichiers
touch docs/rapport.txt src/main.sh

# Vérification
tree mon_projet

Étape 2: Modification des permissions

Appliquez les permissions correctes :

Rappel : 755 (rwxr-xr-x) pour dossiers, 644 (rw-r--r--) pour fichiers normaux, 755 pour scripts exécutables

# Permissions pour les dossiers (755)
find mon_projet -type d -exec chmod 755 {} \;

# Permissions pour les fichiers normaux (644)
find mon_projet -type f -exec chmod 644 {} \;

# Permission spéciale pour le script (755)
chmod 755 mon_projet/src/main.sh

# Vérification finale
ls -lR mon_projet

Étape 3: Vérification et tests

Testez votre structure :

  • Essayez de créer un fichier dans docs/images/
  • Tentez d'exécuter main.sh avec ./mon_projet/src/main.sh
  • Vérifiez que vous ne pouvez pas modifier rapport.txt sans droits en écriture

Validation :

Pour valider l'exercice, exécutez ces commandes de vérification :

# Vérification de l'arborescence
[ -d "mon_projet/docs/images" ] && echo "OK - docs/images existe" || echo "ERREUR"
[ -f "mon_projet/src/main.sh" ] && echo "OK - main.sh existe" || echo "ERREUR"

# Vérification des permissions
[ $(stat -c "%a" "mon_projet/src/main.sh") -eq 755 ] && echo "OK - main.sh a 755" || echo "ERREUR"
[ $(stat -c "%a" "mon_projet/docs/rapport.txt") -eq 644 ] && echo "OK - rapport.txt a 644" || echo "ERREUR"

Exercice 2: Création de fichiers et répertoires

Énoncé : Créez une structure de répertoires et des fichiers dans votre home directory.

Objectif : Maîtriser la création et gestion des fichiers/répertoires.

Commandes à utiliser :

mkdir mon_projet                     # Crée un répertoire
mkdir -p mon_projet/{docs,src,tests} # Crée une arborescence
touch mon_projet/src/main.sh         # Crée un fichier vide
echo "#!/bin/bash" > mon_projet/src/main.sh  # Écrit dans le fichier
rmdir mon_projet/tests               # Supprime un répertoire vide
rm -r mon_projet/docs                # Supprime récursivement

Astuce : mkdir -p crée tous les répertoires parents nécessaires.

Exercice 3: Visualisation de fichiers

Énoncé : Affichez le contenu de différents fichiers système.

Objectif : Apprendre à lire des fichiers avec différentes commandes.

Commandes à utiliser :

cat /etc/passwd              # Affiche tout le fichier
less /etc/passwd             # Affiche page par page (quitter avec q)
head -n 5 /etc/passwd        # Affiche les 5 premières lignes
tail -n 5 /etc/passwd        # Affiche les 5 dernières lignes
wc -l /etc/passwd            # Compte le nombre de lignes

Astuce : less est idéal pour les longs fichiers (flèches pour naviguer, / pour chercher).

Exercice 4: Redirections et pipes

Énoncé : Utilisez les redirections pour manipuler les entrées/sorties des commandes.

Objectif : Comprendre les flux standards et les pipes.

Commandes à utiliser :

ls -l > liste_fichiers.txt    # Redirige la sortie vers un fichier
echo "bonjour" >> liste_fichiers.txt  # Ajoute à la fin du fichier
grep "root" /etc/passwd > root_info.txt  # Filtre et redirige
ls -l | grep ".txt"          # Pipe: utilise la sortie d'une commande comme entrée
ls -l | tee liste.txt        # Affiche ET enregistre dans un fichier

Astuce : > écrase le fichier, >> ajoute à la fin.

Exercice 5: Recherche avec grep

Énoncé : Recherchez des motifs dans des fichiers et dans la sortie d'autres commandes.

Objectif : Maîtriser grep pour filtrer efficacement du texte.

Commandes à utiliser :

grep "bash" /etc/passwd           # Recherche simple
grep -i "BASH" /etc/passwd        # Insensible à la casse
grep -v "nologin" /etc/passwd     # Inverser la recherche
grep -r "error" /var/log          # Recherche récursive
ps aux | grep "chrome"            # Recherche dans la sortie d'une commande
grep -E "^[a-z]+:" /etc/passwd    # Expressions régulières

Astuce : -E active les expressions régulières étendues (plus puissantes).

Exercice 6: Gestion des permissions

Énoncé : Modifiez les permissions de fichiers et comprenez le système de droits Unix.

Objectif : Comprendre chmod, chown et les permissions.

Commandes à utiliser :

ls -l                    # Voir les permissions
chmod +x script.sh       # Ajoute le droit d'exécution
chmod 755 script.sh      # rwxr-xr-x (user:rwx, group:r-x, others:r-x)
chmod u=rw,g=r,o= fichier  # Notation symbolique
chown user:group fichier # Change propriétaire et groupe
sudo chown root fichier  # Nécessite les droits root

Astuce : Les permissions sont en octal (4:lecture, 2:écriture, 1:exécution).

Exercice 7: Historique et complétion

Énoncé : Utilisez efficacement l'historique des commandes et les raccourcis clavier.

Objectif : Gagner en productivité avec les raccourcis Bash.

Commandes à utiliser :

history                # Affiche l'historique
!42                    # Exécute la commande n°42
!!                     # Répète la dernière commande
!ls                    # Répète la dernière commande ls
Ctrl+R                 # Recherche dans l'historique
Ctrl+A / Ctrl+E        # Début/Fin de ligne
Ctrl+U / Ctrl+K        # Couper avant/après le curseur
Ctrl+Y                 # Coller le texte coupé
Alt+.                  # Insère le dernier argument

Astuce : history | grep "apt" pour trouver des commandes spécifiques.

Exercice 8: Variables d'environnement

Énoncé : Manipulez les variables d'environnement et comprenez leur utilité.

Objectif : Comprendre le rôle des variables et le PATH.

Commandes à utiliser :

echo $HOME            # Affiche une variable
export MA_VAR="valeur" # Crée une variable
env                   # Liste toutes les variables
echo $PATH            # Affiche le PATH
export PATH=$PATH:/nouveau/chemin  # Ajoute au PATH
unset MA_VAR          # Supprime une variable

Astuce : Les modifications du PATH dans le terminal sont temporaires. Pour les rendre permanentes, ajoutez-les à ~/.bashrc.

Exercice 9: Processus et jobs

Énoncé : Gérez les processus en cours d'exécution sur votre système.

Objectif : Comprendre la gestion des processus avec ps, top, kill.

Commandes à utiliser :

ps                     # Liste des processus
ps aux                 # Liste détaillée
top                    # Tableau de bord interactif
htop                   # Version améliorée (à installer)
kill 1234              # Termine le processus 1234
kill -9 1234           # Force la terminaison
Ctrl+Z                 # Met en pause un processus
bg                     # Reprend en arrière-plan
fg                     # Ramène au premier plan
jobs                   # Liste les jobs

Astuce : pkill et killall permettent de tuer des processus par nom.

Exercice 10: Script Bash simple

Énoncé : Créez un script Bash qui affiche des informations système.

Objectif : Écrire et exécuter un premier script Bash.

Commandes à utiliser :

#!/bin/bash
# Mon premier script
echo "Bonjour $USER!"
echo "Date: $(date)"
echo "Uptime: $(uptime)"
echo "Utilisation disque:"
df -h | grep -v "tmpfs"
echo "Processus en cours:"
ps aux | wc -l

Pour exécuter :

chmod +x script.sh  # Rend exécutable
./script.sh         # Exécute le script

Astuce : La première ligne (#!/bin/bash) est le shebang qui indique l'interpréteur à utiliser.

Cheat Sheet des Commandes Bash

Fichiers & Répertoires

  • ls - Lister les fichiers
  • ls -l - Lister avec détails
  • ls -a - Afficher fichiers cachés
  • cd - Changer de répertoire
  • pwd - Afficher le répertoire courant
  • mkdir - Créer un répertoire
  • rmdir - Supprimer répertoire vide
  • rm -r - Supprimer récursivement
  • cp - Copier
  • mv - Déplacer/renommer
  • touch - Créer fichier vide

Visualisation & Recherche

  • cat - Afficher fichier
  • less - Afficher page par page
  • head - Premières lignes
  • tail - Dernières lignes
  • tail -f - Suivre en temps réel
  • grep - Rechercher du texte
  • find - Rechercher fichiers
  • locate - Recherche rapide
  • wc - Compter lignes/mots
  • diff - Comparer fichiers

Permissions

  • chmod - Modifier permissions
  • chown - Modifier propriétaire
  • chgrp - Modifier groupe
  • umask - Permissions par défaut
  • sudo - Exécuter en root
  • su - Changer d'utilisateur
  • passwd - Changer mot de passe

Processus

  • ps - Lister processus
  • top - Moniteur interactif
  • htop - Version améliorée
  • kill - Terminer processus
  • killall - Terminer par nom
  • pkill - Terminer par motif
  • bg - Mettre en arrière-plan
  • fg - Ramener au premier plan
  • jobs - Lister les jobs

Réseau

  • ifconfig - Config réseau
  • ip - Version moderne
  • ping - Tester connexion
  • netstat - Statistiques réseau
  • ss - Sockets en écoute
  • traceroute - Tracer route
  • dig - Requêtes DNS
  • nslookup - Recherche DNS
  • wget - Téléchargement
  • curl - Transfert URL

Divers

  • man - Manuel
  • --help - Aide rapide
  • history - Historique
  • alias - Créer alias
  • unalias - Supprimer alias
  • echo - Afficher texte
  • date - Date/heure
  • tar - Archivage
  • zip/unzip - Compression
  • df - Espace disque
  • du - Utilisation espace

Télécharger cette Cheat Sheet

Vous pouvez sauvegarder cette page (Ctrl+S) ou imprimer (Ctrl+P) pour avoir cette cheat sheet toujours à portée de main.

Concepts Fondamentaux de Linux

Système de fichiers Linux

Linux utilise une structure arborescente unifiée, avec / comme racine. Principaux répertoires :

  • /bin - Commandes essentielles
  • /etc - Fichiers de configuration
  • /home - Répertoires utilisateurs
  • /var - Fichiers variables (logs)
  • /tmp - Fichiers temporaires
  • /usr - Programmes utilisateurs
  • /root - Home de root
  • /dev - Périphériques

Système de permissions

Chaque fichier a des permissions pour :

  • Propriétaire (user)
  • Groupe (group)
  • Autres (others)

Types de permissions :

  • r (4) - Lecture
  • w (2) - Écriture
  • x (1) - Exécution

Exemple : chmod 755 = rwxr-xr-x

Utilisateurs et Privilèges

Fichiers importants :

  • /etc/passwd - Comptes utilisateurs
  • /etc/shadow - Mots de passe hashés
  • /etc/group - Groupes
  • /etc/sudoers - Droits sudo

Commandes :

  • useradd - Ajouter utilisateur
  • usermod - Modifier utilisateur
  • userdel - Supprimer utilisateur
  • groupadd - Ajouter groupe
  • passwd - Changer mot de passe

SUID/GUID

Bit spécial qui permet d'exécuter un programme avec les droits de son propriétaire (SUID) ou de son groupe (GUID).

Exemple :

-rwsr-xr-x 1 root root 30800 Aug 21  2020 /usr/bin/passwd

Le s indique que le SUID est activé. Risque de sécurité si mal configuré.

Sudo

Commande qui permet d'exécuter des commandes avec les privilèges d'un autre utilisateur (par défaut root).

Exemples :

sudo apt update          # Exécute en tant que root
sudo -u user command    # Exécute en tant qu'un autre utilisateur
sudo -i                 # Ouvre un shell root

Configuré dans /etc/sudoers (toujours utiliser visudo pour éditer).

Variables d'Environnement

Variables globales qui influencent le comportement des processus. Essentielles pour le fonctionnement du système.

Variables importantes :

  • PATH - Chemins pour les commandes
  • HOME - Répertoire home
  • USER - Nom d'utilisateur
  • SHELL - Shell par défaut
  • PS1 - Prompt du shell

Commandes :

  • env - Afficher toutes les variables
  • echo $VAR - Afficher une variable
  • export VAR=valeur - Définir
  • unset VAR - Supprimer

Redirections et Pipes

Mécanismes pour manipuler les flux d'entrée/sortie des commandes.

Symbole Description Exemple
> Redirige la sortie vers un fichier (écrase) ls > fichiers.txt
>> Ajoute la sortie à un fichier echo "test" >> fichier.txt
< Redirige un fichier vers l'entrée sort < fichier.txt
| Pipe (passe la sortie à une autre commande) ls -l | grep ".txt"