# Commandes Utiles

Voici une liste de commandes courantes utilisées dans l'administration Linux. Chaque commande est accompagnée de ses options les plus fréquemment utilisées et d'explications détaillées.

## **1. Commandes de base pour la navigation dans le système de fichiers**

* **pwd** : Affiche le chemin complet du répertoire courant (Print Working Directory).

  ```bash
  pwd
  ```
* **ls** : Liste les fichiers et dossiers dans le répertoire courant.

  ```bash
  ls
  ```

  * **ls -t :** Trie les fichiers par date de modification, du plus récent au plus ancien.

    ```bash
    ls -t
    ```
  * **ls -S** : Trie les fichiers par taille, du plus grand au plus petit.

    ```bash
    ls -S
    ```
  * **ls -l** : Affiche les détails de chaque fichier (permissions, propriétaire, taille, date).

    ```bash
    ls -l
    ```
  * **ls -R :** Affiche les fichiers dans les sous-répertoires de manière récursive.

    ```bash
    ls -R
    ```

{% hint style="warning" %}
Récursif : C'est à dire non seulement les fichiers et répertoires dans le répertoire courant, mais aussi tout le contenu des sous-répertoires, et ainsi de suite.
{% endhint %}

* **ls -a** : Montre également les fichiers cachés (les fichiers dont le nom commence par un point).

  ```bash
  ls -a
  ```
* **ls -h** : Affiche les tailles des fichiers de manière lisible (Ko, Mo, Go).

  ```bash
  ls -h
  ```

{% hint style="info" %}
Les différentes options peuvent êtres associées. Par exemple `ls -alh`

**Exemple de sortie :**

```bash
drwxr-xr-x  3 user group  4.0K Oct 24 10:30 .
drwxr-xr-x  5 user group  4.0K Oct 22 15:20 ..
-rw-r--r--  1 user group  1.5M Oct 20 09:00 file1.txt
-rw-r--r--  1 user group  200K Oct 21 12:45 file2.log
-rw-------  1 user group  512 Oct 23 08:15 .hidden_file
```

**Détails de la sortie :**

* **`drwxr-xr-x`** : Représente les permissions. Le premier caractère `d` indique qu'il s'agit d'un répertoire. Les autres caractères montrent les permissions pour le propriétaire, le groupe et les autres utilisateurs.
  * **`d`** : Répertoire
  * **`rwx`** : Permissions du propriétaire (lecture, écriture, exécution)
  * **`r-x`** : Permissions du groupe (lecture, pas d'écriture, exécution)
  * **`r-x`** : Permissions des autres utilisateurs (lecture, pas d'écriture, exécution)
* **`3`** : Nombre de liens (ou sous-répertoires) dans le répertoire.
* **`user`** : Nom de l'utilisateur propriétaire du fichier.
* **`group`** : Nom du groupe associé au fichier.
* **`4.0K`, `1.5M`, `200K`, `512`** : Tailles des fichiers en format lisible.
* **`Oct 24 10:30`** : Date et heure de la dernière modification.
* **`.`** et **`..`** : `.` représente le répertoire courant, tandis que `..` représente le répertoire parent.
* **`file1.txt`, `file2.log`, `.hidden_file`** : Noms des fichiers et répertoires listés. Notez que `.hidden_file` est un fichier caché en raison du point (`.`) au début de son nom.

Cette commande est très utile pour avoir un aperçu détaillé des fichiers dans un répertoire, y compris les fichiers cachés et les tailles facilement compréhensibles.
{% endhint %}

* **cd \[chemin]** : Change le répertoire courant vers celui spécifié.

  ```bash
  cd [chemin]
  ```

  * Exemple : Change de répertoire vers /home/utilisateur.

    ```bash
    cd /home/utilisateur
    ```
  * Astuce : **cd ..** te fait remonter d’un répertoire.

    ```bash
    cd ..
    ```
* **cp \[source] \[destination]** : Copie des fichiers ou des dossiers.

  ```bash
  cp [source] [destination]
  ```

  * Exemple : Copie fichier1.txt vers fichier2.txt.

    ```bash
    cp fichier1.txt fichier2.txt
    ```
  * **cp -r** : Copie un dossier récursivement (avec son contenu).

    ```bash
    cp -r dossier1/ dossier2/
    ```
* **mv \[source] \[destination]** : Déplace ou renomme des fichiers ou des dossiers.

  ```bash
  mv [source] [destination]
  ```

  * Exemple : Déplace un fichier.

    ```bash
    mv fichier.txt /chemin/destination
    ```
  * Pour renommer un fichier : **mv ancien\_nom.txt nouveau\_nom.txt**.

    ```bash
    mv ancien_nom.txt nouveau_nom.txt
    ```
* **rm \[fichier]** : Supprime des fichiers.

  ```bash
  rm [fichier]
  ```

  * Exemple : Supprime le fichier spécifié.

    ```bash
    rm fichier.txt
    ```
  * **rm -r** : Supprime un dossier et son contenu récursivement.

    ```bash
    rm -r dossier/
    ```

{% hint style="danger" %}
**Attention :** Cette action est irréversible.
{% endhint %}

## **2. Commandes pour la gestion des fichiers**

* **cat \[fichier]** : Affiche le contenu d'un fichier dans le terminal.

  ```bash
  cat [fichier]
  ```
* **touch \[fichier]** : Crée un fichier vide ou modifie la date de dernier accès du fichier.

  ```bash
  touch [fichier]
  ```
* **mkdir \[nom\_dossier]** : Crée un nouveau répertoire.

  ```bash
  mkdir [nom_dossier]
  ```
* **mkdir -p \[chemin]** : Crée un répertoire ainsi que tous les sous-répertoires nécessaires dans le chemin spécifié.

  ```bash
  mkdir -p [chemin]
  ```

  * Exemple : Crée un répertoire et tous les sous-répertoires nécessaires.

    ```bash
    mkdir -p /chemin/vers/nouveau/dossier
    ```

{% hint style="info" %}
**Option `-p`** : Si un ou plusieurs des répertoires du chemin n'existent pas, cette option les crée également.
{% endhint %}

* **rmdir \[nom\_dossier]** : Supprime un répertoire vide.

  ```bash
  rmdir [nom_dossier]
  ```

## **3. Commandes pour la gestion des droits**

### **3.1 `chmod`**

chmod \[permissions] \[fichier] : Change les permissions d’un fichier ou dossier.

```bash
chmod [permissions] [fichier] 
```

{% hint style="info" %}
Chmod ( change mode ) peut être utilisé de deux manières : **symbolique** ou **numérique**.
{% endhint %}

#### Mode numérique

{% hint style="info" %}
Il Utilise des chiffres pour représenter les permissions.

* `4` : lecture (`r`)
* `2` : écriture (`w`)
* `1` : exécution (`x`)

Les permissions sont additionnées pour chaque type d'utilisateur :

* Propriétaire : premier chiffre

* Groupe : deuxième chiffre

* Autres : troisième chiffre
  {% endhint %}

* Exemple : Change les permissions d'un fichier.

  ```bash
  chmod 755 fichier.txt
  ```

* Explication :

  ```bash
  7
  ```

  \= lecture (4) + écriture (2) + exécution (1),

  ```bash
  5
  ```

  \= lecture (4) + exécution (1).

#### Mode symbolique

{% hint style="info" %}
Utilise des lettres pour représenter les utilisateurs et les permissions.

* `u` : utilisateur (propriétaire)

* `g` : groupe

* `o` : autres

* `a` : tous (utilisateur, groupe et autres)

* `r` : lecture

* `w` : écriture

* `x` : exécution
  {% endhint %}

* Exemple

```bash
chmod u+x fichier.txt  # Ajoute la permission d'exécution pour le propriétaire
chmod g-w fichier.txt  # Retire la permission d'écriture pour le groupe
chmod a=r fichier.txt   # Définit la permission de lecture uniquement pour tous
```

### **3.2 `chown`**

chown \[utilisateur]:\[groupe] \[fichier] : Change le propriétaire d’un fichier ou dossier.

```bash
chown [utilisateur]:[groupe] [fichier]
```

* Exemple : Change le propriétaire d'un fichier.

  ```bash
  chown imad fichier.txt  # Change le propriétaire à 'imad'
  ```
* Exemple : Change le propriétaire et le groupe d'un fichier.

```bash
chown imad:staff fichier.txt  # Change le propriétaire à 'imad' et le groupe à 'staff'
```

{% hint style="info" %}
L'option `-R` avec la commande `chown` signifie "récursif". Elle permet de changer le propriétaire et/ou le groupe d'un fichier ou d'un répertoire ainsi que de tous les fichiers et sous-répertoires qu'il contient.

#### Syntaxe

```bash
chown -R [nouveau_propriétaire][:nouveau_groupe] répertoire
```

#### Exemple d'utilisation

**Changer le propriétaire récursivement** : Supposons que vous ayez un répertoire appelé `mon_dossier` qui contient plusieurs fichiers et sous-répertoires. Pour changer le propriétaire de `mon_dossier` et de tout son contenu à `imad`, vous pouvez utiliser la commande suivante :

```
chown -R imad mon_dossier
```

**Changer le propriétaire et le groupe récursivement** : Si vous souhaitez également changer le groupe en même temps, par exemple, à `developpeurs` ,vous pouvez exécuter :

```bash
chown -R imad:developpeurs mon_dossier
```

{% endhint %}

## **4. Commandes de gestion des processus**

* **ps** : Affiche les processus en cours.

  ```bash
  ps aux
  ```
* **top** : Affiche en temps réel les processus actifs, ainsi que leur utilisation des ressources.

  ```bash
  top
  ```
* **kill \[PID]** : Termine un processus spécifié par son PID (Process ID).

  ```bash
  kill [PID]
  ```

  * Exemple :

    ```bash
    kill 1234
    ```

    pour terminer le processus ayant le PID 1234.
  * Pour forcer l'arrêt :

    ```bash
    kill -9 [PID]
    ```

## **5. Commandes réseau**

* **nc \[adresse] \[port]** : nc ou Netcat ouvre une connexion vers un hôte à une adresse IP ou un nom de domaine et un port spécifiés.

  ```bash
  nc 192.168.1.1 80
  ```
* Cette commande peut également être utilisée pour écouter un port sur votre machine :

  ```bash
  nc -l -p [port]
  ```
* **ip route show** : Affiche la table de routage actuelle du système.

  ```bash
  ip route show
  ```
* **ip route add default via \[adresse\_gw]** : Définit une passerelle par défaut pour le routage du trafic sortant.

  ```bash
  ip route add default via 192.168.1.254
  ```
* Pour supprimer une passerelle par défaut existante, utilisez :

  ```bash
  ip route del default
  ```
* **ping \[adresse]** : Vérifie la connectivité réseau vers un hôte en envoyant des paquets ICMP.

  ```bash
  ping [adresse]
  ```
* **ip a** : Affiche les interfaces réseau et leurs configurations ( adresse IP, masque, etc,)

  ```bash
  ip a
  ```
* **ss** : ss est le nouveau netstat qui est dépriécié sur certaines distribs linux. Il Affiche des informations sur les sockets et les connexions réseau.

  ```bash
  ss -tuln
  ```

{% hint style="info" %}
Cette commande liste toutes les connexions TCP et UDP en cours, ainsi que les ports d'écoute.
{% endhint %}

* **traceroute \[domaine]** : Affiche le chemin que prennent les paquets pour atteindre une destination.

  ```bash
  traceroute [domaine]
  ```
* **nslookup \[domaine]** : Interroge un serveur DNS pour obtenir l’adresse IP d’un domaine.

  ```bash
  nslookup [domaine]
  ```

## **6. Manipulation des fichiers compressés**

* **tar -czvf archive.tar.gz /chemin/dossier** : Compresse un dossier en une archive .tar.gz.

  ```bash
  tar -czvf archive.tar.gz /chemin/dossier
  ```

  * **-c** : Créer une archive.
  * **-z** : Compresser avec gzip.
  * **-v** : Mode verbeux (affiche les fichiers traités).
  * **-f** : Nom du fichier archive.
* **tar -xzvf archive.tar.gz** : Décompresse une archive .tar.gz.

  ```bash
  tar -xzvf archive.tar.gz
  ```
* **Décompression avec `unzip` :**
  * **unzip \[archive.zip]** : Permet d'extraire le contenu d'un fichier ZIP.

    ```bash
    unzip archive.zip
    ```
  * Cette commande va décompresser le fichier `archive.zip` dans le répertoire courant.
  * Pour extraire vers un répertoire spécifique, on peut utiliser l'option **-d** :

    ```bash
    unzip archive.zip -d /chemin/vers/dossier
    ```
* **Compression avec `zip` :**
  * **zip \[archive.zip] \[fichiers]** : Crée un fichier ZIP à partir de fichiers ou de répertoires spécifiés.

    ```bash
    zip archive.zip fichier1.txt fichier2.txt
    ```
  * Cette commande va créer un fichier ZIP nommé `archive.zip` contenant `fichier1.txt` et `fichier2.txt`.
  * Pour zipper un dossier entier, on utilise l'option **-r** :

    ```bash
    zip -r archive.zip dossier/
    ```

## **7. Utilisation de `su` et `sudo`**

* **su \[utilisateur]** : Permet de se connecter en tant qu’autre utilisateur (par défaut root). Il demande le mot de passe de l'utilisateur cible.

  ```bash
  su [utilisateur]
  ```

  * Exemple :

    ```bash
    su - utilisateur
    ```

    pour passer à l'utilisateur spécifié avec son environnement.
* **sudo \[commande]** : Exécute une commande avec les privilèges d’un autre utilisateur, généralement root, sans changer de session. Il demande le mot de passe de l'utilisateur qui exécute la commande.

  ```bash
  sudo [commande]
  ```

  * Exemple :

    ```bash
    sudo apt update
    ```

    pour mettre à jour la liste des paquets en tant que super utilisateur.

## 8. Commande pour gestion des disques <a href="#bkmrk-gestion-disques" id="bkmrk-gestion-disques"></a>

La gestion des disques permet de surveiller l'espace disque, visualiser les partitions, et diagnostiquer les problèmes de stockage. Ci-dessous, des commandes utiles avec des exemples pratiques pour mieux comprendre leur utilité.

### **1. Utilisation de `du`**

* **du -h**

{% hint style="info" %}
**But :** Afficher la taille de tous les dossiers et sous-dossiers dans le répertoire courant.
{% endhint %}

Par exemple, dans un dossier contenant des dossiers imbriqués :

```bash
mon_dossier/
├── Documents
│   ├── Photos
│   └── Textes
├── Téléchargements
└── Musique
```

En utilisant `du -h` dans ce dossier, vous verrez la taille de chaque sous-dossier, y compris ceux imbriqués :

```bash
du -h mon_dossier/
```

```bash
4.0K    mon_dossier/Documents/Textes
5.0M    mon_dossier/Documents/Photos
6.0M    mon_dossier/Documents
20M     mon_dossier/Téléchargements
2.0G    mon_dossier/Musique
2.3G    mon_dossier
```

**Résumé :** `du -h` montre la taille de chaque dossier, sous-dossier, et fichier jusqu'à la fin de l’arborescence.

* **du -h --max-depth=1**

{% hint style="info" %}
**But :** Afficher la taille de chaque dossier de premier niveau uniquement dans le répertoire courant, sans aller plus profondément.
{% endhint %}

Avec la même structure de dossier, si vous utilisez `du -h --max-depth=1`, vous verrez uniquement la taille des dossiers de premier niveau :

```bash
du -h --max-depth=1 mon_dossier/
```

```
6.0M    mon_dossier/Documents
20M     mon_dossier/Téléchargements
2.0G    mon_dossier/Musique
2.3G    mon_dossier
```

{% hint style="success" %}
**Résumé :** `du -h --max-depth=1` affiche la taille des dossiers de premier niveau uniquement, sans parcourir les sous-dossiers. Idéal pour un aperçu rapide des dossiers principaux.
{% endhint %}

* **du -sh :**

{% hint style="info" %}
**But :** Afficher la taille totale d’un répertoire, sans détails sur les sous-dossiers ou fichiers individuels. L’option `-s` (summary) résume la taille totale, et `-h` rend l'affichage lisible avec des unités (Ko, Mo, Go).
{% endhint %}

```bash
du -sh /chemin/vers/dossier
```

```
2.3G    /chemin/vers/dossier
```

**Exemple :** Si vous êtes dans le dossier `/home/user/Downloads` et exécutez `du -sh`, vous obtiendrez la taille totale utilisée par le contenu de `Downloads` sans détails sur chaque sous-dossier :

```bash
du -sh
500M    .
```

**Résumé :** `du -sh` est utile pour une vérification rapide de la taille globale d’un dossier sans entrer dans les détails. Cela permet de visualiser la place occupée par le dossier en entier.

### **2. Utilisation de `df`**

* **df -h**

{% hint style="info" %}
**But :** Afficher l'espace disque utilisé et disponible pour chaque système de fichiers, avec des unités lisibles (Go, Mo).
{% endhint %}

```bash
df -h
```

```bash
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        40G   20G   18G  53% /
tmpfs           798M     0  798M   0% /dev/shm
/dev/sdb1       100G   55G   45G  56% /mnt/data
```

### **3. Utilisation de `lsblk`**

* **lsblk**

{% hint style="info" %}
**But :** Afficher une arborescence des périphériques de stockage, leurs partitions, et points de montage.
{% endhint %}

```bash
lsblk
```

```bash
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0    40G  0 disk 
└─sda1   8:1    0    40G  0 part /
sdb      8:16   0   100G  0 disk 
└─sdb1   8:17   0   100G  0 part /mnt/data
```

### **4. Utilisation de `mount` et `umount`**

* **mount**

{% hint style="info" %}
**But :** Afficher les systèmes de fichiers actuellement montés ou monter un périphérique sur un répertoire spécifique. Utilisez `mount` suivi du périphérique et du point de montage pour monter un disque.
{% endhint %}

```bash
sudo mount /dev/sdb1 /mnt/data
mount: /mnt/data: mounted filesystem ext4. # sortie de la commande en haut
```

* **umount**

{% hint style="info" %}
**But :** Démonter un périphérique, le rendant inaccessible depuis le système.
{% endhint %}

```bash
sudo umount /mnt/data
umount: /mnt/data: successfully unmounted. #sortie de la commande en haut
```

### **5. Utilisation de `blkid`**

{% hint style="info" %}
**But :** La commande `blkid` permet d'identifier les périphériques de stockage en affichant leurs informations, comme le type de système de fichiers et l'UUID (Universally Unique Identifier). L’UUID est un identifiant unique assigné à chaque partition de disque, permettant de référencer un périphérique indépendamment de son nom de fichier (par exemple, `/dev/sda1`).
{% endhint %}

```bash
blkid
```

```
/dev/sda1: UUID="e6b05e9c-55a4-4a78-8b4c-1e25a8a3f9c4" TYPE="ext4" PARTUUID="0e8b3c9d-01"
/dev/sdb1: UUID="d9f8d47b-7db1-4b7c-9e0f-0d9c5d8a6d5a" TYPE="ext4" PARTUUID="0e8b3c9d-02"
```

{% hint style="success" %}
**Explication :** Chaque périphérique listé montre plusieurs attributs :

* **UUID :** Un identifiant unique pour chaque partition. Par exemple, `e6b05e9c-55a4-4a78-8b4c-1e25a8a3f9c4`. Utiliser l’UUID au lieu de noms de périphériques (comme `/dev/sda1`) est particulièrement utile dans les fichiers de configuration (comme `/etc/fstab`), car cet identifiant reste constant même si le nom du périphérique change.
* **TYPE :** Type de système de fichiers de la partition, ici `ext4`.
* **PARTUUID :** Un autre identifiant unique, généralement utilisé pour les partitions sur des tables de partition GPT.
  {% endhint %}

**Résumé :** `blkid` est essentiel pour identifier les périphériques de stockage et leurs systèmes de fichiers, surtout lors de la configuration de montages permanents avec des UUID pour garantir une compatibilité entre redémarrages.

{% hint style="warning" %}
**Fichier `/etc/fstab`**

**But :** Le fichier `/etc/fstab` est utilisé pour définir les systèmes de fichiers à monter automatiquement au démarrage, avec leurs options de montage. Chaque ligne dans `fstab` correspond à un périphérique ou une partition à monter.

Un exemple d’entrée dans `/etc/fstab` :

```
UUID=e6b05e9c-55a4-4a78-8b4c-1e25a8a3f9c4 /mnt/data ext4 defaults 0 2
```

**Explication des colonnes :**

* **Périphérique :** Généralement spécifié avec l’UUID du périphérique, pour garantir un montage stable même si le nom du périphérique (comme `/dev/sda1`) change. Ici, `UUID=e6b05e9c-55a4-4a78-8b4c-1e25a8a3f9c4`.
* **Point de montage :** Le répertoire où le système de fichiers sera monté. Dans cet exemple, `/mnt/data`.
* **Type :** Le type de système de fichiers. Par exemple, `ext4` pour Linux.
* **Options de montage :** Ici `defaults` (lecture/écriture, auto, etc.), mais plusieurs options sont possibles, comme `ro` pour lecture seule.
* **Dump :** Habituellement 0, il indique si le système de fichiers doit être sauvegardé par la commande `dump`.
* **Pass :** Contrôle l’ordre de vérification des disques au démarrage. `0` signifie sans vérification, `1` pour la racine, et `2` pour les autres disques.

**Résumé :** `/etc/fstab` est un fichier clé pour la gestion automatique des montages des systèmes de fichiers. En spécifiant les UUID et les options adaptées, il garantit que les partitions sont toujours montées correctement au démarrage, simplifiant la gestion des disques.
{% endhint %}

## 9. Téléchargement et Interaction Web avec `curl` et `wget` <a href="#bkmrk-curl-wget" id="bkmrk-curl-wget"></a>

{% hint style="info" %}
Les commandes `curl` et `wget` permettent de télécharger des fichiers, d’interagir avec des serveurs web et d’effectuer des requêtes HTTP, mais elles sont adaptées à des usages différents. `curl` est particulièrement polyvalent, prenant en charge de nombreuses méthodes HTTP (GET, POST, PUT, DELETE, etc.) pour interagir de façon dynamique avec des API ou des services web. En revanche, `wget` est optimisé pour le téléchargement fiable de fichiers, y compris la récupération de sites entiers.
{% endhint %}

### **1. `curl`**

`curl` est un outil polyvalent pour transférer des données via de nombreux protocoles (HTTP, FTP, etc.), souvent utilisé pour télécharger des fichiers ou interagir avec des APIs.

{% hint style="success" %}
**Options principales de `curl` :**

* `-O` : Télécharge un fichier et le sauvegarde avec son nom d'origine (sans modification).
* `-o [nom]` : Télécharge un fichier et le renomme selon le nom spécifié.
* `-s` : "Silent mode" - Ne montre pas la barre de progression ni les messages de téléchargement. Idéal dans des scripts où l’on souhaite éviter les sorties visibles.
* `-S` : Affiche les messages d'erreur même en mode silencieux (utilisé avec `-s`).
* `-L` : Suit les redirections HTTP. Souvent nécessaire lorsque l'URL redirige vers un lien final (utile pour les sites avec des redirections intermédiaires).
* `-I` : Effectue une requête HTTP HEAD pour afficher uniquement les en-têtes HTTP, sans télécharger le contenu. Pratique pour vérifier la disponibilité d’un lien.
* `-sSL` : Combine plusieurs options : mode silencieux, suivi des redirections et affichage des erreurs en cas de problème. Très utilisé dans les scripts pour éviter les interruptions inattendues.
  {% endhint %}

**Exemples de commandes `curl` :**

```bash
curl -O http://exemple.com/fichier.txt
```

**Explication :** Télécharge `fichier.txt` dans le répertoire courant en conservant son nom d'origine.

```bash
curl -o monfichier.txt http://exemple.com/fichier.txt
```

**Explication :** Télécharge `fichier.txt` et le renomme en `monfichier.txt`.

```bash
curl -I http://exemple.com
```

**Explication :** Affiche les en-têtes HTTP du site pour vérifier sa disponibilité ou d'autres informations comme la type de serveur web ( apche, nginx ou autres ).

**Exemple de sortie de curl -I**

```bash
HTTP/1.1 200 OK
Date: Thu, 25 Oct 2024 12:34:56 GMT
Server: Apache/2.4.41 (Ubuntu)
Last-Modified: Tue, 15 Jan 2024 15:42:00 GMT
ETag: "3e9-5a4e7cb7e5c6d"
Accept-Ranges: bytes
Content-Length: 1000
Content-Type: text/html; charset=UTF-8
```

### **2. `wget`**

{% hint style="info" %}
`wget` est conçu pour des téléchargements robustes, avec la possibilité de reprendre un téléchargement interrompu. Il est idéal pour des téléchargements en masse et récursifs.
{% endhint %}

{% hint style="success" %}
**Options principales de `wget` :**

* `-O [nom]` : Télécharge un fichier et le renomme selon le nom spécifié, remplaçant l'option par défaut qui utilise le nom original.
* `-O [nom]` : Télécharge un fichier et le renomme selon le nom spécifié, remplaçant l'option par défaut qui utilise le nom original.
* `-c` : Reprend le téléchargement d'un fichier si l’opération précédente a été interrompue, utile pour des fichiers volumineux.
* `-r` : Téléchargement récursif de plusieurs fichiers ou d’un site complet, pratique pour copier des sites ou des dossiers entiers en ligne.
* `-l [profondeur]` : Limite la profondeur du téléchargement récursif (par défaut, wget suit les liens vers d'autres fichiers indéfiniment sans cette option).
  {% endhint %}

**Exemples de commandes `wget` :**

```bash
wget http://exemple.com/fichier.txt
```

**Explication :** Télécharge `fichier.txt` dans le répertoire courant avec son nom original.

```bash
wget -O monfichier.txt http://exemple.com/fichier.txt
```

**Explication :** Télécharge `fichier.txt` et le renomme en `monfichier.txt`.

```bash
wget -c http://exemple.com/fichier.txt
```

**Explication :** Reprend le téléchargement de `fichier.txt` s’il a été interrompu.

```bash
wget -r -l 1 http://exemple.com
```

**Explication :** Télécharge le site `exemple.com` de manière récursive avec une profondeur d'un seul niveau, utile pour copier des pages liées en un clic.

**Résumé :**

`curl` est plus adapté pour les requêtes API et les téléchargements simples, tandis que `wget` excelle dans les téléchargements en masse et avec reprise automatique. Ensemble, ces commandes fournissent des options puissantes pour interagir avec les serveurs web et gérer les transferts de données de manière flexible.

## 10. OpenSSL <a href="#bkmrk-openssl" id="bkmrk-openssl"></a>

{% hint style="success" %}
OpenSSL est un outil en ligne de commande (et une bibliothèque) qui permet, entre autres :

* de générer des **clés privées / publiques**, paramètres cryptographiques.
* de **créer, signer et gérer des certificats X.509** (pour TLS/SSL).
* de **chiffrer / déchiffrer** des données, des fichiers ; faire des opérations de cryptographie symétrique ou asymétrique.
* de **générer des hachés (hashes), des condensés (digests)**, des codes d'authentification, signatures…
* de **tester des connexions SSL/TLS** vers des serveurs (client SSL/TLS).
* de **convertir entre différents formats de certificats** (PEM, DER, PKCS#12, etc.).

Bref — OpenSSL permet de faire presque tout ce qui touche à la cryptographie, certificats, SSL/TLS, chiffrement, clés, etc.
{% endhint %}

### **1. Commandes générales**

#### 📌 Version

```bash
openssl version -a
```

#### 📌 Liste globale des commandes

```bash
openssl help
```

***

### &#x20;**2. Génération de clés**

#### Clé RSA 2048 bits

```bash
openssl genrsa -out private.key 2048
```

#### Clé RSA 4096 bits

```bash
openssl genrsa -out private.key 4096
```

#### Clé EC (Elliptic Curve)

```bash
openssl ecparam -name prime256v1 -genkey -out private.key
```

***

### &#x20;**3. Certificats & CSR**

#### Créer une CSR + clé privée

```bash
openssl req -newkey rsa:2048 -keyout private.key -out cert.csr
```

#### Créer un certificat auto-signé (1 an)

```bash
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes
```

#### Créer une CA (Certificate Authority) locale

Génère une **clé CA** puis un **certificat CA auto-signé**. Tu utiliseras ensuite cette CA pour signer d’autres certificats (serveur, client…).

```bash
# Clé privée de la CA (protège-la)
openssl genrsa -out ca.key 4096

# Certificat de CA (auto-signé)
openssl req -x509 -new -key ca.key -sha256 -days 3650 -out ca.crt
```

{% hint style="info" %}
Pour éviter les questions interactives, ajoute `-subj "/C=FR/O=MonOrg/CN=Mon-CA"` à la commande `openssl req`.
{% endhint %}

#### Signer un certificat avec une CA

**1) Générer la clé + CSR du serveur**

```bash
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr
```

{% hint style="warning" %}
Pour TLS moderne, le **SAN** (Subject Alternative Name) est souvent obligatoire.
{% endhint %}

**2) Signer la CSR (certificat serveur)**

Sans SAN (simple) :

```bash
openssl x509 -req \
  -in server.csr \
  -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out server.crt -days 825 -sha256
```

Avec SAN (recommandé) :

```bash
# Fichier d'extensions minimal (exemple)
cat > v3.ext <<'EOF'
[ v3_req ]
basicConstraints=CA:FALSE
keyUsage=digitalSignature,keyEncipherment
extendedKeyUsage=serverAuth
subjectAltName=@alt_names

[ alt_names ]
DNS.1=example.com
IP.1=192.168.1.10
EOF

openssl x509 -req \
  -in server.csr \
  -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out server.crt -days 825 -sha256 \
  -extfile v3.ext -extensions v3_req
```

{% hint style="success" %}
Pour que les clients fassent confiance au certificat signé, installe `ca.crt` dans leur magasin de confiance (trust store).
{% endhint %}

#### Lire un certificat

```bash
openssl x509 -in cert.pem -text -noout
```

***

### &#x20;**4. Conversion de certificats**

#### PEM → DER

```bash
openssl x509 -in cert.pem -outform der -out cert.der
```

#### DER → PEM

```bash
openssl x509 -in cert.der -inform der -out cert.pem
```

#### PEM → PFX (PKCS#12)

```bash
openssl pkcs12 -export -out cert.pfx -inkey key.pem -in cert.pem
```

***

### &#x20;**5. Chiffrement de fichiers**

#### Chiffrer

```bash
openssl enc -aes-256-cbc -salt -in fichier.txt -out fichier.enc
```

#### Déchiffrer

```bash
openssl enc -aes-256-cbc -d -in fichier.enc -out fichier.txt
```

***

### **6. Hash & intégrité**

#### SHA-256

```bash
openssl dgst -sha256 fichier.txt
```

#### SHA-512

```bash
openssl dgst -sha512 fichier.txt
```

***

### &#x20;**7. `openssl rand` — Générer des données aléatoires**

#### 📌 Aléatoire en Base64 (très utilisé pour les mots de passe)

**16 octets (≈ 24 caractères Base64)**

```bash
openssl rand -base64 16
```

**32 octets (≈ 44 caractères Base64) – recommandé**

```bash
openssl rand -base64 32
```

**64 octets (≈ 88 caractères Base64)**

```bash
openssl rand -base64 64
```

#### 📌 Aléatoire en hexadécimal

```bash
openssl rand -hex 32
```

#### 📌 Aléatoire brut (binaire)

```bash
openssl rand 32 > random.bin
```

#### ✔️ À quoi ça sert ?

* génération de mots de passe forts
* génération de clés symétriques (AES)
* génération de tokens API
* création de secrets pour scripts ou déploiements

***

### &#x20;**8. `openssl passwd` — Générer des hashes de mot de passe**

`openssl passwd` génère un **hash de mot de passe au format UNIX crypt(3)**, utilisé dans `/etc/shadow`.

#### 📌 SHA-512 (recommandé)

```bash
openssl passwd -6 monmotdepasse
```

#### 📌 SHA-256

```bash
openssl passwd -5 monmotdepasse
```

#### 📌 MD5 (ancien, éviter)

```bash
openssl passwd -1 monmotdepasse
```

#### 📌 Demander le mot de passe sans le taper en clair

```bash
openssl passwd -6
```

(puis tapez le mot de passe)

#### 📌 Ajouter un sel personnalisé

```bash
openssl passwd -6 -salt SALT123 monmotdepasse
```

#### ✔️ Usage typique

* scripts d’automatisation (Ansible, cloud-init, Docker…)
* création d’entrées pour `/etc/shadow`
* générer un mot de passe chiffré pour un utilisateur Linux

***

### &#x20;**9. Diagnostic TLS**

Tester une connexion HTTPS

```bash
openssl s_client -connect example.com:443
```

Afficher uniquement le certificat serveur

```bash
openssl s_client -connect example.com:443 -showcerts
```

***

### **10. Résumé rapide (cheat-sheet)**

| Besoin                 | Commande                                                                                                 |
| ---------------------- | -------------------------------------------------------------------------------------------------------- |
| Mot de passe aléatoire | `openssl rand -base64 32`                                                                                |
| Hash pour /etc/shadow  | `openssl passwd -6`                                                                                      |
| Clé privée RSA         | `openssl genrsa -out key.pem 4096`                                                                       |
| CSR                    | `openssl req -new -key key.pem -out req.csr`                                                             |
| Certificat auto-signé  | `openssl req -x509 -new -key key.pem -out cert.pem -days 365`                                            |
| Créer une CA           | `openssl genrsa -out ca.key 4096 && openssl req -x509 -new -key ca.key -out ca.crt -days 3650 -sha256`   |
| Signer une CSR (CA)    | `openssl x509 -req -in req.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out cert.pem -days 825 -sha256` |
| Chiffrer un fichier    | `openssl enc -aes-256-cbc -salt -in in.txt -out out.enc`                                                 |
| Lire un certificat     | `openssl x509 -in cert.pem -text -noout`                                                                 |

## 11. Redirections shell : stdout, stderr, /dev/null

Les redirections permettent de contrôler où vont la sortie normale (stdout) et les messages d'erreur (stderr) d'une commande.

#### Rappel des descripteurs de fichiers standards

| Numéro | Nom        | Description                       | Symbole courant |
| ------ | ---------- | --------------------------------- | --------------- |
| 0      | stdin      | Entrée standard (clavier, pipe…)  | `<`             |
| **1**  | **stdout** | Sortie normale (résultat attendu) | `>` `>>`        |
| **2**  | **stderr** | Messages d'erreur et warnings     | `2>`            |

#### Les redirections les plus utilisées

| Objectif                                           | Commande recommandée                  | Explication                                                            |
| -------------------------------------------------- | ------------------------------------- | ---------------------------------------------------------------------- |
| Cacher **tout** (sortie + erreurs)                 | `commande > /dev/null 2>&1`           | Méthode classique – la plus répandue                                   |
| Cacher **tout** (syntaxe bash/zsh moderne)         | `commande &> /dev/null`               | Plus court, très apprécié (bash 4+ et zsh)                             |
| Cacher **uniquement les erreurs**                  | `commande 2>/dev/null`                | Garde la sortie normale visible sur le terminal                        |
| Fusionner **erreurs** dans la sortie normale       | `commande 2>&1`                       | Très utile avec `grep`, `tee`, `less`, pipes en général                |
| Envoyer la **sortie normale** vers le canal erreur | `commande >&2` ou `commande 1>&2`     | Rare, mais utile dans les scripts pour marquer une sortie comme erreur |
| Séparer proprement les deux flux                   | `commande > output.log 2> errors.log` | Idéal pour les logs séparés                                            |

#### Mémo ultra-rapide (à retenir pour toujours)

```bash
> /dev/null 2>&1     → Silence total (la référence)
&> /dev/null         → Silence total (version courte moderne)

2>/dev/null          → "J'en ai marre des Permission denied / No such file..."
2>&1                 → "Les erreurs deviennent de la sortie normale"
>&2                  → "La sortie normale devient une erreur"
```