add gscan2pdf : 2026-03-13 12:45:33

vault backup: 2026-03-13 09:01:21
vault backup: 2026-03-12 21:19:17
2026-03-13 12:45:33 +01:00 · 2026-03-13 09:01:21 +01:00 · 2026-03-12 21:19:17 +01:00 · 2026-03-12 20:49:17 +01:00 · 2026-03-11 18:41:56 +01:00 · 2026-03-11 18:28:18 +01:00
56 changed files with 7385 additions and 202 deletions
--- a/.trash/FreeOTP+.md
+++ b/.trash/FreeOTP+.md
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@
 .obsidian/workspace-mobile.json
 # Ignorer les fichiers système
 .DS_Store
 .trash
--- a/.obsidian/app.json
+++ b/.obsidian/app.json
@@ -7,5 +7,11 @@
  "attachmentFolderPath": "static",
  "showUnsupportedFiles": true,
  "trashOption": "local",
-  "useMarkdownLinks": true
+  "useMarkdownLinks": true,
  "pdfExportSettings": {
    "pageSize": "Letter",
    "landscape": false,
    "margin": "0",
    "downscalePercent": 100
  }
 }
--- a/.obsidian/community-plugins.json
+++ b/.obsidian/community-plugins.json
@@ -4,5 +4,6 @@
  "dataview",
  "find-unlinked-files",
  "obsidian-importer",
-  "obsidian-linter"
+  "obsidian-linter",
  "auto-note-mover"
 ]
--- a/.obsidian/graph.json
+++ b/.obsidian/graph.json
@@ -46,6 +46,6 @@
  "repelStrength": 10,
  "linkStrength": 1,
  "linkDistance": 250,
-  "scale": 1,
+  "scale": 0.9999999999999991,
  "close": true
 }
--- a/.obsidian/plugins/auto-note-mover/main.js
+++ b/.obsidian/plugins/auto-note-mover/main.js
--- a/.obsidian/plugins/auto-note-mover/manifest.json
+++ b/.obsidian/plugins/auto-note-mover/manifest.json
@@ -0,0 +1,10 @@
 {
 	"id": "auto-note-mover",
 	"name": "Auto Note Mover",
 	"version": "1.2.0",
 	"minAppVersion": "0.12.0",
 	"description": "Auto Note Mover will automatically move the active notes to their respective folders according to the rules.",
 	"author": "faru",
 	"authorUrl": "https://github.com/farux/",
 	"isDesktopOnly": false
 }
--- a/.trash/Android.md
+++ b/.trash/Android.md
@@ -1,14 +0,0 @@
 ---
 tags:
 title: Android avec S'informer sur La Tech
 theme:
  - "[[Android]]"
 article_etat:
  - publié
 description:
 auteur: "[[Cédrix]]"
 date_create: 2026-02-20
 page_type:
  - theme_home
 ---
 ![[view-articles.base]]
--- a/.trash/Edito.md
+++ b/.trash/Edito.md
@@ -1,19 +0,0 @@
 ---
 title: Edito
 type:
 category:
 status:
 tags: []
 description:
 page_type:
  - article
 theme:
  - "[[Edito]]"
 date_create: 2026-02-20
 article_etat:
  - brouillon
 lastmod: 2026-02-21 12:12
 date: 2026-02-20 21:38
 ---
 ![[view-articles.base]]
--- a/.trash/S'informer.md
+++ b/.trash/S'informer.md
--- a/.trash/Untitled.canvas
+++ b/.trash/Untitled.canvas
--- a/.trash/[[android.md
+++ b/.trash/[[android.md
--- a/.trash/[[android_freeotp_application_fdroid]].md
+++ b/.trash/[[android_freeotp_application_fdroid]].md
--- a/.trash/contact.html
+++ b/.trash/contact.html
@@ -1,48 +0,0 @@
 <div id="contact-area">
    <div id="step1">
        <input type="email" id="email" placeholder="Votre email" required><br>
        <textarea id="message" placeholder="Votre message (10 caractères min.)"></textarea><br>
        <button onclick="sendCode()">Recevoir un code de validation</button>
    </div>
    <div id="step2" style="display:none;">
        <p>Un code a été envoyé à votre adresse. Entrez-le ci-dessous :</p>
        <input type="text" id="verify_code" placeholder="Code à 6 chiffres">
        <button onclick="verifyAndSend()">Valider l'envoi définitif</button>
    </div>
 </div>
 <script>
 let currentToken = "";
 async function sendCode() {
    const fd = new FormData();
    fd.append('step', 'send_code');
    fd.append('email', document.getElementById('email').value);
    fd.append('message', document.getElementById('message').value);
    const res = await fetch('/contact-verify.php', { method: 'POST', body: fd });
    const data = await res.json();
    if (data.status === 'success') {
        currentToken = data.token;
        document.getElementById('step1').style.display = 'none';
        document.getElementById('step2').style.display = 'block';
    } else {
        alert(data.message);
    }
 }
 async function verifyAndSend() {
    const fd = new FormData();
    fd.append('step', 'verify_code');
    fd.append('token', currentToken);
    fd.append('code', document.getElementById('verify_code').value);
    const res = await fetch('/contact-verify.php', { method: 'POST', body: fd });
    const data = await res.json();
    alert(data.message);
    if (data.status === 'success') location.reload();
 }
 </script>
--- a/.trash/orphaned
+++ b/.trash/orphaned
@@ -1,6 +0,0 @@
 - [[Android, où sont stockés les fichiers.md]]
 - [[publier son jardin numérique.md]]
 - [[HUGO - Générateur de sites statiques.md]]
 - [[AnyDesk, Installation et Configuration sous Linux.md]]
 - [[android_application_yivi.md]]
 - [[GIT - Corriger un dossier un suivi par erreur.md]]
--- a/.trash/orphaned
+++ b/.trash/orphaned
@@ -1,6 +0,0 @@
 - [[Android, où sont stockés les fichiers.md]]
 - [[publier son jardin numérique.md]]
 - [[HUGO - Générateur de sites statiques.md]]
 - [[AnyDesk, Installation et Configuration sous Linux.md]]
 - [[android_application_yivi.md]]
 - [[GIT - Corriger un dossier un suivi par erreur.md]]
--- a/.trash/scripts/send-mail.php
+++ b/.trash/scripts/send-mail.php
@@ -1,79 +0,0 @@
 <?php
 session_start();
 $log_dir = "/tmp/contact_auth/";
 if (!is_dir($log_dir)) mkdir($log_dir, 0700);
 header('Content-Type: application/json');
 // --- CONFIGURATION ---
 $to_admin = "votre-email@abonnel.fr";
 $from_server = "webmaster@abonnel.fr";
 $step = $_POST['step'] ?? '';
 // --- ACTION 1 : GÉNÉRATION ET ENVOI DU CODE ---
 if ($step === 'send_code') {
    $email = filter_var($_POST['email'] ?? '', FILTER_VALIDATE_EMAIL);
    $message = trim($_POST['message'] ?? '');
    if (!$email || strlen($message) < 10) {
        echo json_encode(["status" => "error", "message" => "Données invalides."]);
        exit;
    }
    // Génération du code
    $code = rand(100000, 999999);
    $token = md5($email . time());
    // Stockage temporaire (Valide 1h)
    $auth_data = [
        'code' => $code,
        'email' => $email,
        'message' => $message,
        'expires' => time() + 3600
    ];
    file_put_contents($log_dir . $token, json_encode($auth_data));
    // Envoi du code à l'utilisateur
    $subject = "Votre code de vérification - abonnel.fr";
    $body = "Votre code de validation est : $code\nCe code expire dans 1 heure.";
    if (mail($email, $subject, $body, "From: $from_server")) {
        echo json_encode(["status" => "success", "token" => $token]);
    } else {
        echo json_encode(["status" => "error", "message" => "Erreur d'envoi du code."]);
    }
 }
 // --- ACTION 2 : VÉRIFICATION ET ENVOI FINAL ---
 if ($step === 'verify_code') {
    $token = $_POST['token'] ?? '';
    $user_code = $_POST['code'] ?? '';
    $file = $log_dir . $token;
    if (!file_exists($file)) {
        echo json_encode(["status" => "error", "message" => "Session expirée."]);
        exit;
    }
    $data = json_decode(file_get_contents($file), true);
    if (time() > $data['expires']) {
        unlink($file);
        echo json_encode(["status" => "error", "message" => "Code expiré."]);
        exit;
    }
    if ($user_code == $data['code']) {
        // Envoi final à VOUS
        $final_subject = "[Validé] Contact de " . $data['email'];
        $final_body = "Message de : " . $data['email'] . "\n\n" . $data['message'];
        mail($to_admin, $final_subject, $final_body, "From: $from_server\r\nReply-To: " . $data['email']);
        unlink($file); // Supprime le ticket après succès
        echo json_encode(["status" => "success", "message" => "Message envoyé avec succès !"]);
    } else {
        echo json_encode(["status" => "error", "message" => "Code incorrect."]);
    }
 }
--- a/.trash/view-articles-android.base
+++ b/.trash/view-articles-android.base
@@ -1,18 +0,0 @@
 views:
  - type: cards
    name: "View : Les thèmes"
    filters:
      and:
        - '!file.hasTag("#draft")'
        - "!title.isEmpty()"
        - file.folder.contains("notes")
        - type == "article"
        - theme == "android"
    order:
      - title
      - description
    sort:
      - property: file.mtime
        direction: DESC
    imageAspectRatio: 1
    cardSize: 800
--- a/articles/.obsidian/app.json
+++ b/articles/.obsidian/app.json
@@ -0,0 +1 @@
 {}
--- a/articles/.obsidian/appearance.json
+++ b/articles/.obsidian/appearance.json
@@ -0,0 +1 @@
 {}
--- a/articles/.obsidian/core-plugins.json
+++ b/articles/.obsidian/core-plugins.json
@@ -0,0 +1,33 @@
 {
  "file-explorer": true,
  "global-search": true,
  "switcher": true,
  "graph": true,
  "backlink": true,
  "canvas": true,
  "outgoing-link": true,
  "tag-pane": true,
  "footnotes": false,
  "properties": true,
  "page-preview": true,
  "daily-notes": true,
  "templates": true,
  "note-composer": true,
  "command-palette": true,
  "slash-command": false,
  "editor-status": true,
  "bookmarks": true,
  "markdown-importer": false,
  "zk-prefixer": false,
  "random-note": false,
  "outline": true,
  "word-count": true,
  "slides": false,
  "audio-recorder": false,
  "workspaces": false,
  "file-recovery": true,
  "publish": false,
  "sync": true,
  "bases": true,
  "webviewer": false
 }
--- a/articles/.obsidian/workspace.json
+++ b/articles/.obsidian/workspace.json
@@ -0,0 +1,190 @@
 {
  "main": {
    "id": "10b0398f978f5417",
    "type": "split",
    "children": [
      {
        "id": "49fa4628aa15542a",
        "type": "tabs",
        "children": [
          {
            "id": "b8fe60e8778def2c",
            "type": "leaf",
            "state": {
              "type": "markdown",
              "state": {
                "file": "2026/guide d'installation linux mint depuis windows.md",
                "mode": "source",
                "source": false
              },
              "icon": "lucide-file",
              "title": "guide d'installation linux mint depuis windows"
            }
          }
        ]
      }
    ],
    "direction": "vertical"
  },
  "left": {
    "id": "c0a0c15166f3131e",
    "type": "split",
    "children": [
      {
        "id": "00aa4d697e32d525",
        "type": "tabs",
        "children": [
          {
            "id": "a13022d3262080f1",
            "type": "leaf",
            "state": {
              "type": "file-explorer",
              "state": {
                "sortOrder": "alphabetical",
                "autoReveal": false
              },
              "icon": "lucide-folder-closed",
              "title": "Explorateur de fichiers"
            }
          },
          {
            "id": "df5bb0bd9ed0c0f9",
            "type": "leaf",
            "state": {
              "type": "search",
              "state": {
                "query": "",
                "matchingCase": false,
                "explainSearch": false,
                "collapseAll": false,
                "extraContext": false,
                "sortOrder": "alphabetical"
              },
              "icon": "lucide-search",
              "title": "Rechercher"
            }
          },
          {
            "id": "b471639635163f75",
            "type": "leaf",
            "state": {
              "type": "bookmarks",
              "state": {},
              "icon": "lucide-bookmark",
              "title": "Signets"
            }
          }
        ]
      }
    ],
    "direction": "horizontal",
    "width": 300
  },
  "right": {
    "id": "5de25b4b975b6020",
    "type": "split",
    "children": [
      {
        "id": "eeae21d54e279a2d",
        "type": "tabs",
        "children": [
          {
            "id": "3aa5dded2290baf4",
            "type": "leaf",
            "state": {
              "type": "backlink",
              "state": {
                "file": "2026/guide d'installation linux mint depuis windows.md",
                "collapseAll": false,
                "extraContext": false,
                "sortOrder": "alphabetical",
                "showSearch": false,
                "searchQuery": "",
                "backlinkCollapsed": false,
                "unlinkedCollapsed": true
              },
              "icon": "links-coming-in",
              "title": "Rétrolien pour guide d'installation linux mint depuis windows"
            }
          },
          {
            "id": "fe09606ba257f17c",
            "type": "leaf",
            "state": {
              "type": "outgoing-link",
              "state": {
                "file": "2026/guide d'installation linux mint depuis windows.md",
                "linksCollapsed": false,
                "unlinkedCollapsed": true
              },
              "icon": "links-going-out",
              "title": "Liens sortants de guide d'installation linux mint depuis windows"
            }
          },
          {
            "id": "ba4c303083e4542d",
            "type": "leaf",
            "state": {
              "type": "tag",
              "state": {
                "sortOrder": "frequency",
                "useHierarchy": true,
                "showSearch": false,
                "searchQuery": ""
              },
              "icon": "lucide-tags",
              "title": "Mots-clés"
            }
          },
          {
            "id": "f3cc63b394e3c62f",
            "type": "leaf",
            "state": {
              "type": "all-properties",
              "state": {
                "sortOrder": "frequency",
                "showSearch": false,
                "searchQuery": ""
              },
              "icon": "lucide-archive",
              "title": "Toutes les propriétés"
            }
          },
          {
            "id": "060c0fe3bbc47132",
            "type": "leaf",
            "state": {
              "type": "outline",
              "state": {
                "file": "2026/guide d'installation linux mint depuis windows.md",
                "followCursor": false,
                "showSearch": false,
                "searchQuery": ""
              },
              "icon": "lucide-list",
              "title": "Plan de guide d'installation linux mint depuis windows"
            }
          }
        ]
      }
    ],
    "direction": "horizontal",
    "width": 300,
    "collapsed": true
  },
  "left-ribbon": {
    "hiddenItems": {
      "switcher:Ouvrir le sélecteur rapide": false,
      "graph:Ouvrir la vue graphique": false,
      "canvas:Créer une nouvelle toile": false,
      "daily-notes:Ouvrir la note quotidienne": false,
      "templates:Insérer le modèle": false,
      "command-palette:Ouvrir la palette de commandes": false,
      "bases:Créer une nouvelle base": false
    }
  },
  "active": "b8fe60e8778def2c",
  "lastOpenFiles": [
    "2026/guide d'installation linux mint depuis windows.md"
  ]
 }
--- a/articles/2026/Brother
+++ b/articles/2026/Brother
@@ -0,0 +1,78 @@
 ---
 title: "Brother DS-940DW : interface de gestion Web"
 description: Pour accéder à l'interface de gestion Web (Web Based Management) du Brother DS-940DW
 tags: []
 date: 2026-02-27 10:10
 lastmod: 2026-02-27 14:01
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Brother DS-940DW : interface de gestion Web
 Pour accéder à l'interface de gestion Web (Web Based Management) du **Brother DS-940DW**, il faut d'abord comprendre que cette interface n'est accessible que via le **réseau** (Wi-Fi), et non via le câble USB (qui sert uniquement au transfert de données et à l'alimentation).
 ## 1. Basculer en mode Wi-Fi
 Le DS-940DW possède un commutateur physique. Assurez-vous que le bouton sur le côté de l'appareil est positionné sur l'icône **Wi-Fi**.
 ## 2. Connecter le scanner à votre réseau
 Si le scanner n'est pas encore sur votre Wi-Fi, vous avez deux options :
 - **Mode WPS :** Appuyez sur le bouton Wi-Fi du scanner jusqu'à ce qu'il clignote, puis appuyez sur le bouton WPS de votre box internet.
 - **Mode Wi-Fi Direct (Le plus simple pour la configuration initiale) :**
    1. Cherchez les réseaux Wi-Fi disponibles sur votre ordinateur.
    2. Connectez-vous au réseau nommé `DIRECT-xxxxx_DS-940DW`.
    3. Le mot de passe par défaut est souvent affiché sur une étiquette à l'arrière de l'appareil.
 ## 3. Accéder à l'interface Web
 Une fois que vous êtes sur le même réseau que le scanner (ou connecté en direct) :
 1. Ouvrez votre navigateur (Firefox ou Chrome).
 2. Dans la barre d'adresse, tapez l'adresse IP du scanner.
    - Si vous êtes en Wi-Fi Direct, c'est généralement : `http://192.168.118.1`
    - Si vous êtes sur votre réseau domestique, vous devrez trouver l'IP via l'interface de votre box ou en tapant `arp -a` dans votre terminal.
 3. **Identifiants par défaut :**
    - **Utilisateur :** `admin`
    - **Mot de passe :** celui qui est affiché sur l'étiquette à l'arrière de l'appareil ou celui que vous avez configuré.
 ---
 ## 4. Et pour scanner ?
 L'interface Web sert à la configuration (Cloud, raccourcis, batterie), mais pour **numériser** vos documents, l'interface Web ne suffira pas. Vous aurez besoin du pilote Brother.
 Lorsque l'appareil est branché en USB sur l'ordinateur, ouvrez votre terminal et installez l'outil de numérisation standard :
 ```bash
 sudo apt update
 sudo apt install simple-scan sane-utils
 ```
 Brother propose également un outil d'installation automatique pour Linux ("Driver Install Tool") sur leur site de support officiel. Il configure généralement les règles `udev` nécessaires pour que le scanner soit reconnu sans être root.
 ---
 ### Une astuce pour le mode USB
 Si vous préférez rester en USB, sachez que ce modèle est compatible **SANE**. Si `Simple Scan` (Numériseur de documents) ne le voit pas en USB, essayez de l'ajouter au groupe `lp` :
 `sudo usermod -aG lp $USER` (puis redémarrez votre session).
--- a/articles/2026/Comprendre
+++ b/articles/2026/Comprendre
@@ -0,0 +1,108 @@
 ---
 title: Comprendre RemoveIPC
 description: "Comprendre le paramètre RemoveIPC dans logind.conf : pourquoi il provoque le crash de vos bases de données PostgreSQL ou Oracle et comment le configurer en production (DevOps)."
 tags: []
 date: 2026-03-10 08:09
 lastmod: 2026-03-10 08:14
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 **Par Cédrix** | _Date d'édition : 10 mars 2026_
 Dans l'écosystème Linux moderne, **systemd-logind** gère bien plus que de simples ouvertures de sessions. L'un de ses paramètres les plus discrets, mais potentiellement destructeurs, est `RemoveIPC`. Pour un ingénieur DevOps, comprendre ce réglage est crucial pour garantir la stabilité des bases de données et des applications haute performance.
 ## 1. Qu'est-ce que l'IPC (Inter-Process Communication) ?
 Avant de parler de suppression, rappelons ce que nous protégeons. L'IPC est un ensemble de mécanismes permettant à des processus distincts de partager des données. Les deux formes les plus courantes gérées par `RemoveIPC` sont :
 - **System V IPC :** Inclut les segments de mémoire partagée (`shm`), les files d'attente de messages (`msg`) et les sémaphores (`sem`).
 - **POSIX Shared Memory :** Une version plus moderne et normalisée du partage de mémoire.
 Ces ressources ne sont pas des fichiers sur le disque, mais des segments résidant directement en **RAM**.
 ## 2. Le rôle de `RemoveIPC`
 Le paramètre `RemoveIPC` se trouve dans le fichier `/etc/systemd/logind.conf`. Son rôle est binaire :
 ### Scénario A : `RemoveIPC=yes` (Défaut sur la majorité des distros)
 Lorsqu'un utilisateur se déconnecte et qu'il n'a **plus aucune session active**, systemd parcourt la table des segments IPC. S'il trouve des segments appartenant à cet utilisateur, il les supprime immédiatement pour libérer la mémoire.
 **L'intention :** Éviter les fuites de mémoire (memory leaks) causées par des applications mal codées qui oublient de nettoyer leurs ressources après fermeture.
 ### Scénario B : `RemoveIPC=no`
 Systemd ignore les segments IPC lors de la fermeture de session. La mémoire reste occupée jusqu'à ce qu'un processus les libère manuellement ou que le serveur redémarre.
 ---
 ## 3. Le "Piège" pour les Bases de Données
 C'est ici que le bât blesse pour les DevOps. Imaginons l'architecture suivante :
 1. Vous avez un serveur **PostgreSQL** qui tourne sous l'utilisateur système `postgres`.
 2. Le service démarre au boot et alloue un large segment de **Shared Memory** pour ses opérations.
 3. Un administrateur se connecte en SSH, fait un `sudo su - postgres` pour vérifier une configuration, puis quitte sa session.
 4. **Le drame :** Au moment où l'admin se déconnecte, `systemd-logind` voit que l'utilisateur `postgres` n'a plus de session active. Il déclenche `RemoveIPC` et supprime la mémoire partagée... alors que le service de base de données est toujours en train de l'utiliser !
 **Résultat :** Crash immédiat de la base de données avec des erreurs de type `Illegal storage access` ou `Bus error`.
 ---
 ## 4. Pourquoi est-ce le réglage par défaut ?
 On pourrait se demander pourquoi un paramètre aussi risqué est activé par défaut. La réponse tient en deux points :
 1. **Hygiène système :** Sur les serveurs multi-utilisateurs ou les environnements de développement, cela évite que la RAM ne soit saturée par des résidus de processus terminés.
 2. **Protection des utilisateurs système :** Par défaut, systemd est censé ignorer les utilisateurs dont l'UID est inférieur à 1000 (utilisateurs système). Cependant, selon la manière dont les sessions sont ouvertes (via `su`, `sudo` ou `polkit`), cette protection peut parfois être contournée, provoquant le crash.
 ---
 ## 5. Bonnes pratiques
 ### Vérifier l'état actuel
 Pour voir si des segments IPC sont actuellement utilisés sur votre machine :
 ```Bash
 ipcs -a
 ```
 ### Modifier la configuration
 Si vous gérez des serveurs de bases de données, il est souvent recommandé de désactiver cette option :
 1. Éditez le fichier : `sudo nano /etc/systemd/logind.conf`
 2. Décommettez ou ajoutez la ligne :
    ```toml
    [Login]
    RemoveIPC=no
    ```
 3. Redémarrez le démon (attention, cela peut impacter les sessions en cours) :
    ```Bash
    sudo systemctl restart systemd-logind
    ```
 ### Alternative : Utiliser `KillUserProcesses`
 Si votre but est de nettoyer les ressources, préférez parfois jouer avec `KillUserProcesses=yes`. Cela tuera tous les processus restants de l'utilisateur à la déconnexion, ce qui forcera souvent un nettoyage plus "propre" que la suppression brutale de segments de mémoire.
 ---
 **Sur un serveur haute dispo passez `RemoveIPC` à `no`.**
--- a/articles/2026/Comprendre
+++ b/articles/2026/Comprendre
@@ -0,0 +1,220 @@
 ---
 title: "Comprendre le Standard FHS : La boussole de l'administrateur Linux"
 description: 
 tags: []
 date: 2026-02-28 12:53
 lastmod: 2026-02-28 13:13
 type: 
 category: 
 status: 
 ---
 # Comprendre le Standard FHS : La boussole de l'administrateur Linux
 Si vous installez une Debian, une RedHat ou une Arch Linux, vous retrouverez toujours la même structure à la racine (`/`). Ce n'est pas un hasard, c'est le **FHS**. Son but ? Permettre aux logiciels et aux administrateurs de savoir exactement où chercher (ou stocker) une information.
 ## Les dossiers du Système (Le "Moteur")
 Ces répertoires sont essentiels pour que la machine puisse démarrer et fonctionner.
 - **`/boot`** : Contient tout ce qui est nécessaire au démarrage (le noyau Linux `vmlinuz`, le chargeur GRUB). Comme le disait Sabrine dans ton extrait, c'est vital pour le "Disaster Recovery".
 - **`/etc`** : **Le dossier le plus important pour un admin.** Il contient tous les fichiers de configuration du système et des services (Apache, SSH, réseau). C'est du texte pur, facile à sauvegarder.
 - **`/bin` et `/sbin`** : Les commandes de base (ls, cp, mkdir). `/sbin` est réservé aux commandes d'administration (système).
    > _Note : Sur les distributions modernes, ces dossiers sont souvent des liens symboliques vers `/usr/bin`._
 - **`/lib`** : Les bibliothèques partagées indispensables au démarrage des programmes situés dans `/bin` et `/sbin`.
 ## Les dossiers de Données et Utilisateurs
 - **`/home`** : Le territoire des utilisateurs. Chaque utilisateur y a son sous-dossier (`/home/toto`) pour ses documents et ses réglages personnels.
 - **`/root`** : Le "home" de l'administrateur (root). On le sépare des autres pour pouvoir monter `/home` sur une partition différente sans bloquer l'admin en cas de souci.
 - **`/usr`** : (**User System Resources**) C'est là que sont installés la majorité des programmes, des icônes et de la documentation. C'est souvent la partie la plus volumineuse du système.
 ## Les dossiers Variables et Temporaires
 C'est ici que ça bouge tout le temps.
 - **`/var`** : (**Variable**) C'est le cœur des données dynamiques.
    - `/var/log` : Les journaux du système (crucial pour le debug).
    - `/var/lib` : Les bases de données (MySQL, PostgreSQL).
    - `/var/www` : Souvent utilisé pour héberger les sites web.
 - **`/tmp`** : Fichiers temporaires. Ils sont souvent supprimés à chaque redémarrage.
 ## Les dossiers "Matériel" et Virtuels
 Linux traite tout comme un fichier, même votre matériel.
 - **`/dev`** : Contient les points d'entrée vers les périphériques (disques durs `/dev/sda`, terminaux `/dev/tty`).
 - **`/proc` et `/sys`** : Ce ne sont pas de "vrais" dossiers sur le disque. Ce sont des fenêtres sur le noyau et la RAM. Ils permettent de voir l'état du processeur ou des processus en temps réel.
 ---
 ## Le royaume de l'amovible (Automatique)
 Le répertoire `/media` est une introduction relativement récente dans le standard FHS. Il est géré par le système d'exploitation.
 - **Usage :** C'est le point de montage par défaut pour tous les médias **amovibles**.
 - **Fonctionnement :** Quand vous branchez une clé USB, un disque dur externe ou un CD-ROM, le système (via des outils comme `udisks` ou votre environnement de bureau GNOME/KDE) crée automatiquement un sous-dossier ici.
 - **Exemples :**
    - `/media/usb-disk`
    - `/media/cdrom`
    - `/media/prive/MA_CLE_USB` (sur certaines distributions qui séparent par utilisateur).
 > **L'avantage :** C'est "Plug and Play". L'utilisateur n'a pas besoin de taper de commandes pour accéder à ses fichiers.
 ---
 ## Le montage temporaire (Manuel)
 Le dossier `/mnt` (**Mount**) est historiquement le dossier de l'administrateur système.
 - **Usage :** Il est destiné aux montages **manuels et temporaires**.
 - **Fonctionnement :** Si vous devez monter une partition de secours pour réparer un système, ou accéder ponctuellement à un fichier image (`.iso`), c'est ici qu'on le fait. Contrairement à `/media`, le système ne crée rien tout seul dans `/mnt`.
 - **Exemple de commande :**
    `mount /dev/sdb1 /mnt`
 > **L'avantage :** Il est "propre". Il ne dépend d'aucun automatisme système, ce qui le rend fiable pour les opérations de maintenance ou de récupération de données.
 ---
 ## Et pour les montages permanents ?
 Petite précision cruciale pour ton infrastructure : si tu as un deuxième disque dur interne ou un partage réseau (NAS) qui doit être là **à chaque démarrage**, le FHS est un peu plus flou.
 Beaucoup d'administrateurs créent leur propre dossier à la racine (ex: `/data` ou `/nas`) ou utilisent des sous-dossiers dans `/mnt` (ex: `/mnt/backup`). Cependant, la tendance "propre" actuelle consiste à utiliser :
 - **`/srv`** si ce sont des données servies (comme vu précédemment).
 - **`/mnt/nom_du_partage`** pour les montages réseau statiques via le fichier `/etc/fstab`.
 ---
 On ne peut pas parler du standard **FHS** sans évoquer ces deux-là ! Si `/etc` et `/var` sont le cœur du système, `/opt` et `/srv` sont les dossiers du "sur-mesure" et du service pur.
 ##  Les logiciels "tout-en-un" (Add-on Packages)
 `/opt` se situe dans une zone grise intéressante : c'est du logiciel (statique), mais comme il n'est pas géré par le système de paquets officiel de ta distribution (APT, DNF), il est beaucoup plus difficile à réinstaller à l'identique. Le nom vient de **Optional**. Ces logiciels ne suivent pas la répartition classique de Linux (éparpiller leurs fichiers dans `/usr/bin`, `/usr/lib`, etc.).
 - **Le concept :** Chaque logiciel a son propre sous-répertoire contenant tout ce dont il a besoin (binaires, bibliothèques, configurations).
 - **Exemples typiques :** * `Google Chrome` se trouve souvent dans `/opt/google/chrome`.
    - Des outils comme `Discord`, `Zoom`, ou des suites de développement comme `Eclipse`.
 - **Pourquoi l'utiliser ?** Cela évite de polluer les dossiers système (`/usr`). Si vous supprimez le dossier dans `/opt`, vous supprimez proprement toute l'application.
 Dans une politique de sauvegarde sérieuse, `/opt` est souvent sauvegardé au même titre que `/etc` car il contient de "l'intelligence métier" difficile à reconstruire.
 ---
 ## Les données de services (Service Data)
 Introduit plus tard dans le FHS, le dossier **`/srv`** est destiné à stocker les données relatives aux services offerts par le serveur.
 - **Le concept :** Centraliser les données que votre serveur "sert" au monde extérieur.
 - **Exemples typiques :**
    - `/srv/www` : Pour les fichiers de votre site web (au lieu de `/var/www`).
    - `/srv/ftp` : Pour les fichiers accessibles via un serveur FTP.
    - `/srv/git` : Pour vos dépôts de code source.
 **Pourquoi l'utiliser ?** 
 Sans `/srv`, ton script de sauvegarde ressemble à une usine à gaz car `/var` un répertoire "fourre-tout" qui mélange le **précieux** (tes données) et le **jetable** (les fichiers temporaires) et il faut faire des choix :
 - Sauvegarder `/var/www` (Web)
 - Sauvegarder `/var/lib/pgsql` (Base de données)
 - Sauvegarder `/var/spool/mail` (Mails)
 - **Risque :** Tu oublies le nouveau dossier `/var/lib/mongodb` que ton collègue a installé hier. Résultat : **Perte de données.**
 Avec **`/srv`**, tu imposes une règle d'or à ton équipe :
 > _"Tout ce qui est produit pour un client va dans /srv"_.
 Ton script devient : `sauvegarder /srv`. Si un collègue ajoute un service, il le met dans `/srv/mongodb`. Ton backup le prendra **automatiquement** sans que tu n'aies à modifier une seule ligne de code.
 ## Les dossiers "Polluants" de `/var`
 - **`/var/cache`** : Comme son nom l'indique, c'est du cache. Par exemple, `/var/cache/apt` contient les paquets `.deb` déjà installés. Si ton serveur brûle, tu n'as pas besoin de ces fichiers, tu les retéléchargeras lors de la réinstallation.
 - **`/var/tmp`** : Ce sont des fichiers temporaires qui doivent survivre à un redémarrage (contrairement à `/tmp`), mais ils n'ont pas vocation à être sauvegardés.
 - **`/var/run` (ou `/run`)** : Ce dossier est vidé à chaque démarrage. Il contient les ID des processus en cours (`.pid`) et des sockets. Sauvegarder cela est totalement inutile, voire dangereux si tu tentes de les restaurer.
 - **`/var/lock`** : Contient des fichiers de verrouillage pour empêcher deux programmes d'utiliser le même périphérique. Inutile en sauvegarde.
 ---
 ## Pourquoi respecter le FHS ?
 Prenons l'exemple de **Frédéric**, qui déplace tout dans `/home`.
 Dans Linux, les logiciels ne se "devinent" pas, ils se fient à des chemins prévisibles codés en dur ou configurés par défaut.
 - **Le Monitoring (ex: Zabbix, Netdata) :** Il va surveiller `/var/lib/postgresql` pour mesurer la taille de la base. Si elle est dans `/home`, l'alerte de disque plein ne se déclenchera jamais.
 - **La Sécurité (ex: SELinux, AppArmor) :** Ce sont des systèmes de contrôle d'accès. Ils ont des règles strictes : _"Le processus Postgres n'a le droit de lire/écrire QUE dans /var/lib/pgsql"_. Si Frédéric déplace les données dans `/home`, SELinux va bloquer Postgres, croyant à une intrusion.
 - **Les Mises à jour :** Lors d'une montée de version, le gestionnaire de paquets (`apt` ou `dnf`) va chercher les fichiers de configuration dans `/etc`. S'ils sont ailleurs, il créera de nouveaux fichiers par défaut et votre service ne redémarrera pas avec vos réglages.
 Imaginez que Frédéric quitte l'entreprise. Vous arrivez le lundi matin, le serveur est en panne.
 - **Scénario Standard (FHS) :** Vous tapez `ls /var/lib/`. Vous voyez `pgsql`. Vous comprenez que c'est un serveur de base de données. Vous regardez `/etc/postgresql/` pour la config. En 5 minutes, vous avez le diagnostic.
 - **Scénario Frédéric :** Vous regardez `/var/lib`, c'est vide. Vous pensez que la base a été supprimée. Vous cherchez pendant 1 heure avant de réaliser que tout est caché dans `/home/postgres`. **Bilan :** 1 heure d'interruption de service inutile.
 Par définition, `/home` est privé.
 - Le dossier `/var/lib/postgresql` est conçu pour être accessible par les services système.
 - Le dossier `/home/postgres` est protégé par les masques d'utilisateurs. Si un outil de sauvegarde automatisé (non-root) passe par là, il sera bloqué. Frédéric a créé une **faille de sécurité** en mélangeant données système et espace utilisateur.
 En respectant le FHS, vous bénéficiez de l'effet **"LEGO"** :
 1. Vous installez un serveur (Debian).
 2. Vous branchez un agent de sauvegarde (Veeam).
 3. Vous branchez un antivirus (ClamAV).
 4. Vous branchez un outil de log (Rsyslog).
 **Tout fonctionne instantanément sans aucune configuration manuelle de chemins.**
 ---
--- a/articles/2026/Créer
+++ b/articles/2026/Créer
@@ -0,0 +1,141 @@
 ---
 title: "Guide Complet : Créer sa propre Autorité de Certification (CA) avec OpenSSL"
 description:
 tags: [openssl, certification, ac, san]
 date: 2026-02-28 00:29
 lastmod: 2026-02-28 00:36
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Guide Complet : Créer sa propre Autorité de Certification (CA) avec OpenSSL
 Dans un environnement de test, un laboratoire local ou un intranet, l'utilisation de certificats SSL "auto-signés" classiques pose souvent problème : les navigateurs affichent des alertes de sécurité rouges et bloquent l'accès.
 La solution professionnelle consiste à **devenir votre propre Autorité de Certification**. En créant une "Racine de confiance" et en l'installant sur vos appareils, tous les certificats que vous générerez ensuite seront instantanément reconnus comme valides et sécurisés.
 ## 1. Création de l'Autorité de Certification (La Racine)
 C'est votre "passeport maître". Une fois généré, vous devrez installer le fichier `ma-ca.crt` dans les "Autorités de certification racines de confiance" de vos ordinateurs ou navigateurs.
 ### Générer la clé privée de l'AC
 Cette clé est le cœur de votre sécurité. Gardez-la précieusement et ne la partagez jamais.
 ```bash
 openssl genrsa -out ma-ca.key 4096
 ```
 ### Générer le certificat de l'AC (Self-Signed)
 Ce certificat est valable 10 ans. C'est lui que vous distribuerez à vos clients (PC, serveurs, mobiles).
 ```
 openssl req -x509 -new -nodes -key ma-ca.key -sha256 -days 3650 -out ma-ca.crt \
 -subj "/C=FR/ST=Paris/L=Paris/O=MonLabo/CN=Mon AC Locale"
 ```
 ---
 ## 2. Configuration SAN (Subject Alternative Name)
 Depuis quelques années, les navigateurs modernes (Chrome, Firefox, Edge) rejettent les certificats qui n'utilisent que le simple "Common Name" (CN). Il est désormais impératif d'utiliser une extension **SAN** pour lister vos domaines explicitement.
 Créez un fichier nommé `domaines.ext` et collez-y la configuration suivante :
 ```toml
 authorityKeyIdentifier=keyid,issuer
 basicConstraints=CA:FALSE
 keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
 subjectAltName = @alt_names
 [alt_names]
 DNS.1 = acegrp.lan
 DNS.2 = *.acegrp.lan
 DNS.3 = abonnel.fr
 DNS.4 = a5l.fr
 DNS.5 = localhost
 ```
 ---
 ## 3. Génération du Certificat pour vos domaines
 Nous allons maintenant créer un certificat serveur signé par votre propre AC.
 ### Étape A : Créer la clé privée du serveur
 ```bash
 openssl genrsa -out monserveur.key 2048
 ```
 ### Étape B : Créer la demande de signature (CSR)
 Le CSR est une requête officielle contenant vos informations d'identité.
 ```bash
 openssl req -new -key monserveur.key -out monserveur.csr \
 -subj "/C=FR/ST=Paris/L=Paris/O=MonLabo/CN=acegrp.lan"
 ```
 ### Étape C : Signer le certificat avec votre AC
 C'est ici que la magie opère : vous utilisez votre clé racine pour valider le certificat du serveur.
 ```bash
 openssl x509 -req -in monserveur.csr -CA ma-ca.crt -CAkey ma-ca.key \
 -CAcreateserial -out monserveur.crt -days 825 -sha256 -extfile domaines.ext
 ```
 > **Note de sécurité :** Nous limitons la validité à **825 jours** (environ 2 ans). Les navigateurs récents refusent les certificats serveurs ayant une durée de vie trop longue pour des raisons de sécurité.
 ---
 ## 4. Récapitulatif des fichiers obtenus
 |**Fichier**|**Rôle**|**Action requise**|
 |---|---|---|
 |**ma-ca.crt**|Certificat Racine|**À importer** sur vos PC/Mobiles (Root Store).|
 |**monserveur.crt**|Certificat Serveur|**À installer** sur Nginx, Apache ou IIS.|
 |**monserveur.key**|Clé privée Serveur|**À installer** sur le serveur (Garder secret !).|
 ---
 ## 5. Mise en place pratique (Exemple Nginx)
 Pour que vos sites soient reconnus sans erreur, configurez votre bloc `server` ainsi :
 ```nginx
 server {
    listen 443 ssl;
    server_name acegrp.lan abonnel.fr a5l.fr;
    ssl_certificate     /etc/nginx/ssl/monserveur.crt;
    ssl_certificate_key /etc/nginx/ssl/monserveur.key;
    # Paramètres de sécurité recommandés
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
 }
 ```
 ---
 ## Astuces de déploiement "Pro"
 - **Sur Windows (Parc informatique) :** Utilisez une **GPO** (Stratégie de groupe) pour déployer `ma-ca.crt` automatiquement dans le magasin "Autorités de certification racines de confiance" de tous les postes du domaine.
 - **Sur Linux (Ubuntu/Debian) :** Pour que votre système fasse confiance à votre AC en ligne de commande (ex: pour `curl`), copiez le fichier dans `/usr/local/share/ca-certificates/` et lancez la commande :
    `sudo update-ca-certificates`
 - **Sur Android/iOS :** Envoyez-vous le fichier `.crt` par email et ouvrez-le pour l'installer dans les réglages de confiance du profil.
 ---
 à suivre : **script Bash** pour automatiser entièrement la génération et le renouvellement de ces certificats.
--- a/articles/2026/Déploiement
+++ b/articles/2026/Déploiement
@@ -0,0 +1,135 @@
 ---
 title: "Déploiement d'Apache Guacamole via Docker sur Debian 12 (Bookworm)"
 description:
 tags: []
 date: 2026-03-11 00:27
 lastmod: 2026-03-11 01:19
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Déploiement d'Apache Guacamole via Docker sur Debian 12 (Bookworm)
 L'installation d'Apache Guacamole peut vite devenir un enfer de dépendances (Java, Tomcat, extensions JDBC). Le passage par Docker simplifie tout, à condition de bien gérer la persistance des données et l'initialisation de la base PostgreSQL.
 ## 1. La Philosophie du Stack
 Nous utilisons un trio de conteneurs isolés :
 - **Guacamole Client** : L'interface Web (Java/Tomcat).
 - **Guacd** : Le moteur natif (proxy RDP/SSH/VNC).
 - **PostgreSQL** : Le cerveau (stockage des utilisateurs et connexions).
 ## 2. Préparation du terrain
 On commence par structurer notre projet sur l'hôte :
 ```Bash
 mkdir ~/guacamole-docker && cd ~/guacamole-docker
 mkdir -p guacamole-home data init
 ```
 ## 3. Le Docker-Compose "Gagnant"
 Le secret d'une installation qui ne casse pas lors des mises à jour réside dans l'utilisation d'un fichier `guacamole.properties` externe.
 `nano docker-compose.yml`
 ```YAML
 services:
  # Moteur de protocoles
  guacd:
    image: guacamole/guacd
    container_name: guacd
    restart: always
  # Base de données
  postgres:
    image: postgres:15
    container_name: guac-postgres
    restart: always
    environment:
      POSTGRES_DB: guacamole_db
      POSTGRES_USER: guacamole_user
      POSTGRES_PASSWORD: TonMotDePasseFort
    volumes:
      - ./data:/var/lib/postgresql/data
      - ./init:/docker-entrypoint-initdb.d
  # Interface Web
  guacamole:
    image: guacamole/guacamole
    container_name: guacamole
    restart: always
    ports:
      - "8080:8080"
    environment:
      GUACD_HOSTNAME: guacd
      POSTGRESQL_HOSTNAME: postgres
      POSTGRESQL_DATABASE: guacamole_db
      POSTGRESQL_USER: guacamole_user
      POSTGRESQL_PASSWORD: TonMotDePasseFort
    volumes:
      - ./guacamole-home/guacamole.properties:/etc/guacamole/guacamole.properties
    depends_on:
      - guacd
      - postgres
 ```
 ## 4. Initialisation de la Base de Données
 C’est l'étape où 90% des installations échouent. Il faut générer le schéma SQL officiel de Guacamole et le donner à manger à Postgres.
 ```Bash
 # Générer le script SQL
 docker run --rm guacamole/guacamole /opt/guacamole/bin/initdb.sh --postgresql > ./init/01_initdb.sql
 # Lancer les conteneurs (Postgres va lire le dossier ./init)
 docker-compose up -d
 ```
 ## 5. Configuration Fine (`guacamole.properties`)
 Pour éviter que Java n'ignore vos variables d'environnement, créez ce fichier :
 `nano guacamole-home/guacamole.properties`
 ```Properties
 postgresql-hostname: postgres
 postgresql-port: 5432
 postgresql-database: guacamole_db
 postgresql-username: guacamole_user
 postgresql-password: TonMotDePasseFort
 # Optionnel : priorité à la DB
 extension-priority: postgresql
 ```
 ## 6. Le "Cheat Code" pour le premier accès
 Si `guacadmin` / `guacadmin` vous renvoie un "Identifiant incorrect" (souvent dû à un souci de hachage lors de l'init), créez un admin de secours directement en SQL :
 ```Bash
 docker exec -i guac-postgres psql -U guacamole_user -d guacamole_db -c "INSERT INTO guacamole_entity (name, type) VALUES ('admin_devops', 'USER');"
 docker exec -i guac-postgres psql -U guacamole_user -d guacamole_db -c "INSERT INTO guacamole_user (entity_id, password_hash, password_salt, password_date) SELECT entity_id, decode('8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918', 'hex'), NULL, CURRENT_TIMESTAMP FROM guacamole_entity WHERE name = 'admin_devops';"
 docker exec -i guac-postgres psql -U guacamole_user -d guacamole_db -c "INSERT INTO guacamole_system_permission (entity_id, permission) SELECT entity_id, permission::guacamole_system_permission_type FROM guacamole_entity, (VALUES ('CREATE_CONNECTION'), ('CREATE_USER'), ('ADMINISTER')) AS p (permission) WHERE name = 'admin_devops';"
 ```
 _Identifiants : `admin_devops` / `admin`_
 ---
 ## 🛠 Tips de DevOps :
 - **Logs** : Utilisez `docker logs -f guacamole` pour voir les extensions se charger. Vous devez voir `PostgreSQL Authentication loaded`.
 - **Sécurité** : Une fois connecté, créez votre utilisateur final et **supprimez** les comptes par défaut ou de secours.
 - **HTTPS** : Ne laissez jamais Guacamole en HTTP (8080). Posez un **Nginx Proxy Manager** ou un **Traefik** devant pour gérer le SSL.
--- a/articles/2026/Déployer
+++ b/articles/2026/Déployer
@@ -0,0 +1,288 @@
 ---
 title: Déployer DocuSeal sur Debian 13
 description: Procédure permettant de déployer DocuSeal sur une machine virtuelle Debian 13 (Trixie) hébergée dans Proxmox, en utilisant Docker Compose.
 tags: [docuseal, pdf, signature, autohebergement]
 date: 2026-03-12 20:26
 lastmod: 2026-03-12 20:55
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Déployer DocuSeal sur Debian 13
 Ce document décrit la procédure complète permettant de déployer **DocuSeal** sur une machine virtuelle **Debian 13 (Trixie)** hébergée dans **Proxmox**, en utilisant **Docker Compose**.
 L’objectif est d’obtenir une instance **auto-hébergée et souveraine** du service de signature électronique accessible via le domaine `sign.a5l.fr`.
 L’utilisation de Docker permet :
 - d’isoler l’application du système hôte,
 - de simplifier les mises à jour,
 - de faciliter les sauvegardes et la portabilité de l’instance.
 ---
 # 1. Création du conteneur LXC dans Proxmox
 Créer une conteneur  Debian 13 dans Proxmox.
 Ressources recommandées :
 - **2 vCPU**
 - **2 Go de RAM**
 - **10 Go de stockage minimum**
 DocuSeal reste relativement léger, mais la mémoire est utile lors du traitement de documents PDF.
 ---
 # 2. Installation de l’agent Proxmox
 Se connecter au conteneur via SSH ou via la console Proxmox, puis mettre le système à jour :
 ```bash
 sudo apt update
 sudo apt upgrade -y
 ```
 Il est également conseillé d’installer quelques outils utiles :
 ```bash
 apt install -y curl ca-certificates gnupg
 ```
 ---
 # 3. Installation de Docker
 Debian 13 utilise une gestion moderne des dépôts sécurisés.  
 La méthode recommandée consiste à utiliser le dépôt officiel Docker.
 ## Ajout de la clé GPG Docker
 ```bash
 sudo install -m 0755 -d /etc/apt/keyrings
 curl -fsSL https://download.docker.com/linux/debian/gpg \
 | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 sudo chmod a+r /etc/apt/keyrings/docker.gpg
 ```
 ## Ajout du dépôt Docker
 ```bash
 echo \
 "deb [arch=$(dpkg --print-architecture) \
 signed-by=/etc/apt/keyrings/docker.gpg] \
 https://download.docker.com/linux/debian \
 $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
 | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 ```
 ## Installation du moteur Docker
 ```bash
 sudo apt update
 sudo apt install -y \
 docker-ce \
 docker-ce-cli \
 containerd.io \
 docker-buildx-plugin \
 docker-compose-plugin
 ```
 ## Autoriser l’utilisateur courant à utiliser Docker
 ```bash
 sudo usermod -aG docker $USER
 ```
 Une **déconnexion / reconnexion de session** est nécessaire pour que ce changement prenne effet.
 ---
 # 4. Déploiement de DocuSeal
 Créer un répertoire dédié à l’application.
 ```bash
 mkdir -p ~/docuseal/data
 cd ~/docuseal
 ```
 Créer ensuite le fichier de configuration Docker Compose.
 ```bash
 nano docker-compose.yml
 ```
 Contenu recommandé :
 ```yaml
 services:
  docuseal:
    image: docuseal/docuseal:latest
    container_name: docuseal
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./data:/data
    environment:
      HOST: sign.a5l.fr
      DATABASE_URL: sqlite3:/data/docuseal.db
      FORCE_SSL: true
 ```
 Explications :
 - **ports 3000:3000**  
    expose le service localement.
 - **volume `./data`**  
    contient :
    - la base SQLite
    - les documents PDF
    - les fichiers temporaires
 - **HOST**  
    doit correspondre au nom de domaine utilisé.
 - **FORCE_SSL**  
    impose l’utilisation de HTTPS lorsque l’application est derrière un reverse proxy.
 ---
 ## Lancement de l’application
 ```bash
 docker compose up -d
 ```
 Vérifier que le conteneur fonctionne :
 ```bash
 docker ps
 ```
 L’application est alors accessible sur :
 ```
 http://IP_DE_LA_VM:3000
 ```
 ---
 # 6. Sauvegardes et maintenance
 ## Sauvegarde des données
 Les données importantes se trouvent dans :
 ```
 ~/docuseal/data
 ```
 Ce dossier contient :
 - la base SQLite
 - les documents signés
 - les métadonnées.
 Il est recommandé de :
 - sauvegarder ce dossier régulièrement
 - utiliser les sauvegardes Proxmox.
 ---
 ## Mise à jour de DocuSeal
 La mise à jour de l’application est simple :
 ```bash
 cd ~/docuseal
 docker compose pull
 docker compose up -d
 ```
 Avant toute mise à jour, il est recommandé de créer un **snapshot Proxmox**.
 ---
 # 7. Configuration SMTP
 Pour que DocuSeal puisse envoyer les invitations à signer, un serveur SMTP doit être configuré dans les paramètres de l’application.
 Les informations à fournir :
 - serveur SMTP
 - port
 - utilisateur
 - mot de passe
 - chiffrement TLS ou SSL
 Sans configuration SMTP, les invitations par email ne fonctionneront pas.
 ---
 # 8. Points de sécurité recommandés
 Plusieurs bonnes pratiques améliorent la sécurité de l’instance :
 - limiter l’accès SSH à des clés publiques
 - activer un pare-feu (`ufw` ou `nftables`)
 - restreindre l’accès direct au port **3000**
 - maintenir Debian et Docker à jour
 - effectuer des sauvegardes régulières.
 ---
 # 9. Avantages de DocuSeal en auto-hébergement
 DocuSeal présente plusieurs avantages pour un déploiement auto-hébergé :
 - **Souveraineté des données** : les documents restent sur votre infrastructure.
 - **Légèreté** : fonctionnement possible sur une petite VM.
 - **Déploiement simple** grâce à Docker.
 - **Maintenance limitée** : les mises à jour ne modifient pas le système hôte.
 Cette architecture permet de disposer d’un service de signature électronique fiable, isolé et facilement maintenable dans une infrastructure Proxmox.
--- a/articles/2026/GIT
+++ b/articles/2026/GIT
@@ -1,15 +1,14 @@
 ---
 title: GIT - Corriger un dossier un suivi par erreur
 description: Vous avez oublié de configurer votre .gitignore et des dossiers sensibles (ou inutiles) se retrouvent sur votre dépôt distant ? Découvrez comment retirer un dossier de l'index Git sans le supprimer de votre ordinateur.
-tags:
+tags: [Git]
  - Git
 category:
  - "[[Logiciels et Outils]]"
 type:
  - article
 status: terminé
 date: 2026-02-19 12:21
-lastmod: 2026-02-21 17:07
+lastmod: 2026-02-21 17:27
 ---
 # GIT - Corriger un dossier un suivi par erreur
@@ -44,6 +43,9 @@ L'objectif est de dire à Git : "Oublie ce dossier, mais ne le supprime pas de m
    `git commit -m "Suppression du dossier suivi par erreur et mise à jour du gitignore"`
 	et à pousser les modifications :
 	`git push`
 ### Et après ?
--- a/articles/2026/Installer
+++ b/articles/2026/Installer
@@ -0,0 +1,76 @@
 ---
 title: Installer Signal Desktop via Terminal
 description: Installer Signal Desktop via Terminal
 tags: [signal, messagerie]
 date: 2026-03-02 08:56
 lastmod: 2026-03-02 08:58
 type:
  - article
 category:
  - "[[Guide]]"
  - "[[Logiciels et Outils]]"
 status: terminé
 ---
 # Installer Signal Desktop via Terminal
 L'installation se décompose en trois étapes logiques : la sécurisation de la source, l'ajout du dépôt, et l'installation du logiciel.
 ### Étape 1 : Installation de la clé de signature publique
 Avant de télécharger le logiciel, votre système doit pouvoir vérifier l'authenticité des paquets. Cette clé prouve que le code provient bien de Signal et n'a pas été modifié par un tiers.
 ```Bash
 wget -O- https://updates.signal.org/desktop/apt/keys.asc | gpg --dearmor > signal-desktop-keyring.gpg;
 cat signal-desktop-keyring.gpg | sudo tee /usr/share/keyrings/signal-desktop-keyring.gpg > /dev/null
 ```
 - **`wget -O-`** : Télécharge la clé et l'affiche sur la sortie standard.
 - **`gpg --dearmor`** : Convertit la clé du format texte (ASCII) vers un format binaire que le système peut lire.
 - **`sudo tee`** : Enregistre de manière sécurisée la clé dans le dossier système `/usr/share/keyrings/`.
 ### Étape 2 : Ajout du dépôt officiel
 Par défaut, votre gestionnaire de paquets (`apt`) ne sait pas où chercher Signal. Cette commande ajoute l'adresse des serveurs de Signal à votre liste de sources.
 ```Bash
 wget -O signal-desktop.sources https://updates.signal.org/static/desktop/apt/signal-desktop.sources;
 cat signal-desktop.sources | sudo tee /etc/apt/sources.list.d/signal-desktop.sources > /dev/null
 ```
 - Cette étape crée un fichier `.sources` dans `/etc/apt/sources.list.d/`. C’est grâce à cela que Signal vous proposera des mises à jour en même temps que le reste de votre système.
 ### Étape 3 : Mise à jour et Installation
 Enfin, on demande au système de rafraîchir sa liste de logiciels disponibles et de procéder à l'installation.
 ```Bash
 sudo apt update && sudo apt install signal-desktop
 ```
 - **`sudo apt update`** : "Actualise" la base de données pour inclure le nouveau dépôt Signal.
 - **`sudo apt install signal-desktop`** : Télécharge et installe l'application.
 ---
 ## Pourquoi utiliser cette méthode plutôt que le Snap Store ?
 Bien que Signal soit disponible via des formats comme Flatpak ou Snap, la méthode **APT** (détaillée ci-dessus) est souvent privilégiée par les utilisateurs avancés pour :
 1. **L'intégration système** : Meilleure gestion des thèmes et des polices.
 2. **La légèreté** : Pas de couches de virtualisation supplémentaires.
 3. **La sécurité** : Lien direct avec les serveurs de mise à jour de Signal Messenger LLC.
 > [!IMPORTANT]
 > 
 > Une fois installé, vous devrez lier votre ordinateur à votre application mobile Signal (Paramètres > Appareils reliés) car Signal Desktop ne peut pas fonctionner de manière autonome sans compte mobile existant.
--- a/articles/2026/Installer
+++ b/articles/2026/Installer
@@ -0,0 +1,127 @@
 ---
 title: Installer un serveur de cache APT avec https
 description:
 tags: []
 date: 2026-02-28 01:25
 lastmod: 2026-02-28 01:28
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 Pour mettre en cache du contenu **HTTPS** (et donc réellement économiser de la bande passante sur des dépôts comme Docker, Nodesource ou Google Cloud), la méthode "PassThrough" ne suffit plus car elle ne fait que laisser passer le flux chiffré sans le lire.
 Pour que le serveur de cache puisse lire et stocker le contenu, il doit intercepter la connexion. Voici comment configurer une architecture **Man-in-the-Middle (MitM)** propre et sécurisée pour votre infrastructure locale.
 ---
 ## Le Concept : Proxy HTTPS Transparent
 Dans ce scénario, nous allons utiliser **Squid** avec la fonctionnalité **SSL Peek-and-Splice**.
 1. Le serveur de cache possède sa propre **Autorité de Certification (CA)**.
 2. Vous installez ce certificat CA sur tous vos clients comme "Autorité de confiance".
 3. Lorsqu'un client demande un paquet via HTTPS, le serveur génère un certificat à la volée, déchiffre la requête, vérifie son cache, et rechiffre le flux vers le client.
 ---
 ## 1. Génération du certificat CA auto-signé
 Sur votre serveur de cache, générez la clé et le certificat qui serviront à signer les requêtes interceptées :
 Bash
 ```
 # Créer un dossier pour les certificats
 sudo mkdir -p /etc/squid/ssl_cert
 sudo openssl req -new -newkey rsa:2048 -sha256 -days 3650 -nodes -x509 \
  -extensions v3_ca -keyout /etc/squid/ssl_cert/myCA.pem  \
  -out /etc/squid/ssl_cert/myCA.pem
 ```
 > **Important :** Le fichier `myCA.pem` contient votre clé privée. Protégez-le avec des permissions strictes (`chmod 400`).
 ---
 ## 2. Configuration de Squid (Serveur de Cache)
 Installez Squid avec le support SSL (vérifiez que votre version supporte `--with-openssl`) :
 Bash
 ```
 sudo apt update && sudo apt install squid -y
 ```
 Modifiez la configuration `/etc/squid/squid.conf` pour inclure ces directives :
 Plaintext
 ```
 # Port d'écoute avec interception SSL
 http_port 3128 ssl-bump \
  cert=/etc/squid/ssl_cert/myCA.pem \
  generate-host-certificates=on dynamic_cert_mem_cache_size=4MB
 # Définition de la stratégie d'interception
 acl step1 at_step SslBump1
 ssl_bump peek step1
 ssl_bump bump all
 # Cache des fichiers (ajustez la taille selon vos besoins)
 cache_dir ufs /var/spool/squid 10000 16 256
 maximum_object_size 1024 MB
 ```
 Initialisez la base de données des certificats dynamiques :
 Bash
 ```
 sudo /usr/lib/squid/security_file_certgen -c -s /var/lib/squid/ssl_db -M 4MB
 sudo chown -R proxy:proxy /var/lib/squid/ssl_db
 sudo systemctl restart squid
 ```
 ---
 ## 3. Configuration du Client (Étape CRUCIALE)
 Sans cette étape, vos clients bloqueront la connexion pour "tentative d'interception" (HSTS/SSL Pinning).
 ### A. Importer le certificat CA
 Copiez le fichier `myCA.pem` du serveur vers le client, puis :
 Bash
 ```
 sudo cp myCA.pem /usr/local/share/ca-certificates/my-proxy-ca.crt
 sudo update-ca-certificates
 ```
 ### B. Configurer APT pour utiliser le proxy
 Éditez `/etc/apt/apt.conf.d/00proxy` :
 Plaintext
 ```
 Acquire::http::Proxy "http://IP_SERVEUR:3128";
 Acquire::https::Proxy "http://IP_SERVEUR:3128";
 ```
 ---
 ## Avantages et Risques
 |**Avantages**|**Risques / Inconvénients**|
 |---|---|
 |**Vraie mise en cache** du HTTPS (Gain de temps massif).|**Point de défaillance unique** pour la sécurité.|
 |Réduction drastique de la bande passante externe.|Nécessite d'installer le certificat sur **chaque** client.|
 |Contrôle total sur les paquets entrant dans le réseau.|Incompatible avec certains dépôts qui utilisent le _Certificate Pinning_.|
--- a/articles/2026/Installer
+++ b/articles/2026/Installer
@@ -0,0 +1,131 @@
 ---
 title: Installer un serveur de cache APT
 description:
 tags:
 date: 2026-02-28 01:26
 lastmod: 2026-02-28 01:26
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 Installer un serveur de cache APT (comme **Apt-Cacher-NG**) est une excellente initiative pour économiser de la bande passante et accélérer les mises à jour de vos serveurs ou VMs Linux.
 Cependant, le passage au **HTTPS** pour les dépôts complique un peu la donne : par définition, le HTTPS est conçu pour empêcher les interceptions (ce que fait un cache). Pour contourner cela sans compromettre la sécurité, nous allons configurer un tunnel "CONNECT".
 ---
 ## 1. Installation de Apt-Cacher-NG
 Commencez par installer le service sur la machine qui servira de serveur de cache (Debian ou Ubuntu) :
 Bash
 ```
 sudo apt update
 sudo apt install apt-cacher-ng -y
 ```
 Le service écoute par défaut sur le port **3142**. Vous pouvez vérifier qu'il tourne bien en accédant à `http://IP_DU_SERVEUR:3142`.
 ---
 ## 2. Configuration pour le support HTTPS
 Comme le cache ne peut pas "décrypter" le flux HTTPS (à moins de faire une attaque Man-in-the-Middle complexe et peu recommandée), la solution standard est d'autoriser le serveur à agir comme un **proxy tunnel**.
 ### Sur le serveur de cache :
 Éditez le fichier de configuration :
 Bash
 ```
 sudo nano /etc/apt-cacher-ng/acng.conf
 ```
 Cherchez et modifiez (ou ajoutez) la ligne suivante pour autoriser le port 443 :
 Plaintext
 ```
 PassThroughPattern: ^(.*):443$
 ```
 _Note : Cela permet au client de passer à travers le cache pour le HTTPS. Les fichiers ne seront pas "mis en cache" de la même manière que le HTTP simple, mais cela centralise vos flux._
 Redémarrez le service :
 Bash
 ```
 sudo systemctl restart apt-cacher-ng
 ```
 ---
 ## 3. Configuration des Clients
 C'est ici que la magie opère. Vous ne devez pas modifier vos fichiers `sources.list`, mais dire à APT d'utiliser votre serveur comme proxy.
 ### Méthode A : Configuration globale (Recommandé)
 Créez un fichier de configuration sur chaque machine cliente :
 Bash
 ```
 sudo nano /etc/apt/apt.conf.d/00aptproxy
 ```
 Ajoutez la ligne suivante (remplacez par l'IP de votre serveur) :
 Plaintext
 ```
 Acquire::http::Proxy "http://192.168.1.50:3142";
 Acquire::https::Proxy "http://192.168.1.50:3142";
 ```
 ### Cas particulier : Le "HTTPS-over-HTTP"
 Si vous voulez vraiment mettre en cache le contenu HTTPS, la méthode la plus propre est de forcer APT à utiliser le protocole HTTP vers le cache, et de laisser le serveur de cache s'occuper du HTTPS vers l'extérieur.
 Pour cela, dans votre `sources.list` client, remplacez `https://` par `http://` et utilisez le mapping dans `acng.conf`. Mais attention, cela demande une maintenance plus lourde. La méthode du **PassThrough** (étape 2) est la plus robuste.
 ---
 ## 4. Maintenance et Statistiques
 L'un des grands avantages d'Apt-Cacher-NG est son interface web. Elle vous permet de voir combien de giga-octets vous avez économisés.
 - **Interface :** `http://IP_DU_SERVEUR:3142/acng-report.html`
 - **Expiration du cache :** Le serveur gère seul le nettoyage, mais vous pouvez forcer une purge via l'interface web pour supprimer les paquets obsolètes.
 |**Fonctionnalité**|**Action**|
 |---|---|
 |**Logs**|`/var/log/apt-cacher-ng/`|
 |**Stockage des paquets**|`/var/cache/apt-cacher-ng/`|
 |**Sécurité**|Pensez à limiter l'accès au port 3142 via votre pare-feu (UFW/Iptables) aux IPs de votre réseau local.|
 ---
 ### Résumé de l'architecture
 1. **Le Client** demande un paquet.
 2. **APT** voit la configuration proxy et envoie la requête au serveur de cache.
 3. **Le Serveur de cache** vérifie s'il a déjà le paquet.
    - Si oui : il le sert instantanément.
    - Si non : il le télécharge, le stocke et le sert au client.
 4. Pour le **HTTPS**, il crée un tunnel direct sans stockage local (sauf configuration spécifique).
 Souhaitez-vous que je vous aide à rédiger un script d'automatisation (Ansible ou Bash) pour déployer cette configuration sur 50 clients d'un coup ?
--- a/articles/2026/Installer
+++ b/articles/2026/Installer
@@ -0,0 +1,206 @@
 ---
 title: Installer un service ntfy dans votre domaine
 description:
 tags: []
 date: 2026-03-08 16:47
 lastmod: 2026-03-08 21:16
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 Installer son propre serveur **ntfy** sur Proxmox est une excellente idée pour reprendre le contrôle de ses notifications sans dépendre de services tiers.
 Voici un tutoriel pas à pas pour configurer cela dans un conteneur **LXC Debian sur ProxMox**.
 ---
 ## 1. Création du conteneur LXC sur Proxmox
 1. Créez un nouveau conteneur :
    - **Hostname :** `ntfy`
    - **Ressources conseillées :** 1 vCPU, 512 Mo de RAM, et 8 Go de disque (ntfy est très léger).
    - **Réseau :** Attribuez une IP statique ou une réservation DHCP.
    - **Template :** Debian 13.
 2. Démarrez le conteneur et connectez-vous en SSH ou via la console.
 ![](Pasted%20image%2020260308171916.png)
 ---
 ## 2. Installation de ntfy
 Nous allons utiliser le dépôt officiel pour faciliter les mises à jour.
 ```Bash
 # Mise à jour du système
 sudo apt update && sudo apt upgrade -y
 # Installation des dépendances
 sudo apt install -y curl debian-archive-keyring
 # Créer le dossier pour les clés s'il n'existe pas
 sudo mkdir -p /etc/apt/keyrings
 # Télécharger la nouvelle clé
 sudo curl -L -o /etc/apt/keyrings/ntfy.gpg https://archive.ntfy.sh/apt/keyring.gpg
 echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/ntfy.gpg] https://archive.ntfy.sh/apt stable main" | sudo tee /etc/apt/sources.list.d/ntfy.list
 sudo apt update
 sudo apt install ntfy -y
 # Activation du service au démarrage
 sudo systemctl enable ntfy
 ```
 ---
 ## 3. Configurer le reverseProxy avec le nom public
 ### 1. Publication sur `mon-domaine.fr`
 Pour que cela fonctionne depuis l'extérieur, vous devez configurer votre **Reverse Proxy** (qui doit se trouver sur une autre machine ou un autre LXC) :
 1. **Pointage DNS :** Faites pointer `ntfy.mon-domaine.fr` vers votre IP publique.
 2. **NAT/Port Forwarding :** Sur votre box/routeur, redirigez les ports **80** et **443** vers l'IP de votre Reverse Proxy.
 3. **Config Proxy :** Redirigez les requêtes arrivant sur `ntfy.mon-domaine.fr` vers l'IP locale de votre LXC ntfy sur le port **8080**.
    - _Note importante :_ Assurez-vous d'activer le support des **WebSockets** et de passer les headers `Upgrade` et `Connection`, sinon les notifications sur smartphone ne seront pas instantanées.
 ### 2. Le "piège" du Reverse Proxy (Headers)
 Comme vous publiez sur `mon-domaine.fr`, votre Reverse Proxy (Nginx, Traefik ou autre) doit impérativement transmettre l'IP réelle du visiteur à ntfy, sinon ntfy croira que toutes les requêtes viennent de votre proxy.
 Si vous utilisez **Nginx**, votre bloc de configuration devrait ressembler à ceci pour gérer les **WebSockets** (indispensables pour l'app Android/iOS) :
 ```Nginx
 location / {
    proxy_pass http://IP_DU_LXC_NTFY:80;
    proxy_http_version 1.1;
    # Ces lignes sont vitales pour les notifications en temps réel
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Host $host;  
 	proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_connect_timeout 1h;
    proxy_send_timeout 1h;
    proxy_read_timeout 1h;
 }
 ```
 ## 4. Configuration de ntfy
 Avant de modifier la configuration, nous devons préparer l'environnement de stockage pour que **ntfy** puisse enregistrer ses utilisateurs et le cache des messages de manière persistante.
 Exécutez ces commandes pour créer le répertoire de données et attribuer les permissions correctes à l'utilisateur système `ntfy` :
 ```
 sudo mkdir -p /var/lib/ntfy  
 sudo chown ntfy:ntfy /var/lib/ntfy
 sudo chmod 700 /var/lib/ntfy
 ```
 Le fichier de configuration principal se trouve dans `/etc/ntfy/server.yml`.
 1. Ouvrez le fichier : `nano /etc/ntfy/server.yml`
 2. Modifiez les lignes suivantes pour correspondre à votre domaine **ntfy.mon-domaine.fr** :
 ```YAML
 # L'URL de base est cruciale pour les liens dans les notifications
 base-url: "https://ntfy.mon-domaine.fr"
 # Écoute sur le port 80 (derrière un reverse proxy)
 listen-http: ":8080"
 # Lien avec votre broker MQTT existant
 mqtt-helper-url: "tcp://mqtt.workgroup.lan:1883"
 mqtt-helper-subscriptions:
  - topic: "ntfy/#"
 # Recommandé : Activer l'authentification pour éviter les abus sur votre domaine
 auth-file: "/var/lib/ntfy/user.db"
 auth-default-access: "deny-all"
 enable-login: true
 # Permet de conserver les messages si le destinataire est hors ligne
 cache-file: "/var/lib/ntfy/cache.db"
 cache-duration: "12h" # Garde les messages 12h par exemple
 auth-file: "/var/lib/ntfy/user.db"
 ```
 3. Redémarrez le service : `sudo systemctl restart ntfy`
 **Note :** Si le service refuse de démarrer, vérifiez les logs avec `journalctl -u ntfy -f`. Une erreur de syntaxe dans le fichier `.yml` (comme un espace en trop) est souvent la cause.
 ### Gestion des utilisateurs (Sécurité)
 Puisque la directive `auth-default-access: "deny-all"` est activée, l'accès est verrouillé par défaut. Vous devez impérativement créer un compte administrateur via le terminal pour reprendre la main sur le serveur et commencer à envoyer des notifications.
 #### Création du premier administrateur
 Exécutez les commandes suivantes sur votre serveur :
 ```Bash
 # Créer un utilisateur avec les privilèges d'administrateur
 ntfy user add --role=admin votre_nom_utilisateur
 # Redémarrer le service pour valider la nouvelle configuration
 sudo systemctl restart ntfy
 ```
 #### Distinction importante : Interface Web vs CLI
 Il est crucial de ne pas confondre la gestion du serveur avec la gestion de la session locale :
 - **L'interface graphique (Web UI) :** Elle ne permet pas d'ajouter ou de supprimer des utilisateurs dans la base de données du serveur.
 - **Menu "Paramètres" > "Gérer les utilisateurs" :** Cette option sert uniquement à **enregistrer vos identifiants de connexion** dans votre navigateur. Cela permet à l'interface web de s'authentifier auprès du serveur pour afficher vos sujets (topics) privés, mais cela ne crée en aucun cas un compte sur le système.
 > **Note :** Toute modification structurelle des permissions ou des comptes doit être effectuée en ligne de commande (CLI) à l'aide de la commande `ntfy user`.
 ---
 #### Résumé des droits d'accès
 Une fois votre utilisateur créé, vous pouvez affiner les droits selon vos besoins :
 |**Commande**|**Action**|
 |---|---|
 |`ntfy user list`|Voir tous les utilisateurs enregistrés.|
 |`ntfy access <user> <topic> read-write`|Donner un accès complet à un sujet précis.|
 |`ntfy user change-pass <user>`|Modifier le mot de passe d'un utilisateur.|
 ## 5. Test de fonctionnement
 Une fois le domaine et le proxy configurés, vous pouvez tester l'envoi d'une notification via un simple `curl` depuis n'importe quel terminal :
 ```Bash
 curl -u votre_user:votre_password \ -d "Test de notification sécurisée" \ https://ntfy.mon-domaine.fr/test
 ```
 Si vous allez sur `https://ntfy.mon-domaine.fr/test`, vous devriez voir votre message apparaître.
--- a/articles/2026/LTLS
+++ b/articles/2026/LTLS
@@ -0,0 +1,103 @@
 ---
 title: "TLS : Le garde du corps de vos données sur Internet"
 description: 
 tags: []
 date: 2026-02-28 00:00
 lastmod: 2026-02-28 00:05
 type: 
 category: 
 status: 
 ---
 # TLS : Le garde du corps de vos données sur Internet
 Chaque clic sur le Web déclenche un ballet invisible. Derrière le cadenas de votre navigateur, le protocole **TLS (Transport Layer Security)** assure que vos coordonnées bancaires ou vos messages privés ne finissent pas entre les mains d'un tiers. Mais comment ce protocole parvient-il à concilier sécurité absolue et rapidité instantanée ?
 ## 1. L’héritage du secret : de l’Antiquité au numérique
 Le besoin de masquer une information est millénaire. Les Spartiates utilisaient la **scytale**, un bâton de bois autour duquel on enroulait une lanière de cuir. Sans un bâton du _même diamètre_ (la clé), le message était illisible.
 C'est l'ancêtre du **chiffrement symétrique**. Aujourd'hui, nous n'utilisons plus de bâtons, mais des algorithmes mathématiques comme **AES (Advanced Encryption Standard)**.
 - **Le point fort :** Une rapidité foudroyante.
 - **Le point faible :** Le "problème de la distribution". Si vous voulez envoyer un message chiffré à quelqu'un à l'autre bout du monde, comment lui transmettre la clé sans qu'elle soit interceptée en chemin ?
 ## 2. La révolution asymétrique : l’invention du double cadenas
 En 1976, une percée mathématique change la donne : le chiffrement **asymétrique** (ou à clé publique). Imaginez une boîte aux lettres :
 1. N'importe qui peut y glisser un message (grâce à la **clé publique**, connue de tous).
 2. Seul le propriétaire de la boîte peut l'ouvrir (grâce à sa **clé privée**, gardée secrète).
 Cette méthode, utilisée par l'algorithme **RSA**, règle le problème de la transmission de la clé. Cependant, elle est extrêmement lourde en calculs mathématiques, ce qui ralentirait considérablement votre navigation si elle était utilisée pour tout le contenu d'une page web.
 ---
 ## 3. Le protocole TLS : Le meilleur des deux mondes
 Le génie de TLS réside dans son hybridité. Il utilise l'asymétrie pour faire les présentations, puis bascule sur la symétrie pour la discussion.
 ### 3.1 Anatomie d'une poignée de main (Handshake TLS 1.3)
 Lorsqu'un navigateur se connecte à un serveur, ils exécutent le **Handshake**, tel que défini par la **RFC 8446** :
 - **L'accord (Negotiation) :** Le client dit au serveur : "Voici les langues (algorithmes) que je parle". Le serveur en choisit une.
 - **La preuve (Authentication) :** Le serveur présente son **certificat numérique**. C'est son passeport, signé par une autorité de confiance.
 - **L'échange secret (Key Exchange) :** Via le mécanisme de **Diffie-Hellman éphémère (ECDHE)**, ils génèrent une clé de session symétrique sans jamais se l'envoyer directement sur le réseau. C'est de la magie mathématique.
 - **Le tunnel (Encryption) :** Une fois la clé établie, les données coulent, chiffrées en AES.
 > **Focus technique : Perfect Forward Secrecy (PFS)**
 > 
 > TLS 1.3 impose que chaque session ait sa propre clé unique. Si un pirate vole la clé privée d'un serveur dans un an, il ne pourra pas déchiffrer les conversations capturées aujourd'hui. C'est la _confidentialité persistante_.
 ### 3.2 Le Certificat : La pièce d'identité du serveur
 Un chiffrement n'est rien si vous parlez au mauvais destinataire. Le certificat (format **X.509**) garantit l'identité du site. Il contient :
 - Le nom de domaine (ex: `google.com`).
 - La clé publique du serveur.
 - La signature d'une Autorité de Certification (AC).
 En tant qu'administrateur, vous pouvez inspecter ces détails sous Linux :
 Bash
 ```
 # Pour lire les informations d'un certificat exporté
 openssl x509 -in certificat.pem -text -noout
 ```
 _Vérifiez toujours la date "Not After" : un certificat expiré est la cause n°1 des pannes de services web (Teams et Instagram en ont déjà fait l'amère expérience)._
 ---
 ## 4. Pourquoi le "tout-chiffré" est vital en 2026
 Le cybercrime n'est plus une nuisance, c'est une économie mondiale de **10,5 trillions de dollars** [CYBERCRIME]. Utiliser des protocoles "en clair" revient à crier son code de carte bleue dans une rue bondée.
 |**Protocole à bannir (Clair)**|**Alternative impérative (TLS)**|**Risque**|
 |---|---|---|
 |**HTTP**|**HTTPS**|Interception des mots de passe|
 |**FTP**|**FTPS**|Vol de fichiers industriels|
 |**LDAP**|**LDAPS**|Compromission de l'annuaire d'entreprise|
 |**Telnet**|**SSH**|Prise de contrôle totale du serveur|
 Grâce à des outils comme **Wireshark**, un attaquant sur le même réseau Wi-Fi que vous peut "voir" vos identifiants si vous n'utilisez pas TLS. Le passage au TLS généralisé n'est pas une option technique, c'est une responsabilité éthique pour protéger les utilisateurs.
 ## Conclusion
 TLS est le socle de la confiance numérique. En combinant la robustesse de l'Antiquité (chiffrement symétrique) et l'ingéniosité des mathématiques modernes (asymétrie), il permet à Internet de fonctionner de manière sécurisée à grande échelle.
 La sécurité est une chaîne : le protocole est le maillon fort, mais la vigilance humaine (renouvellement des certificats, arrêt des vieux protocoles) reste le pivot.
--- a/articles/2026/Le
+++ b/articles/2026/Le
@@ -0,0 +1,117 @@
 ---
 title: "Le Paradoxe de Linux : Entre Cimetière de Projets et Hégémonie Mondiale"
 description: "Si l’on se fie aux données de DistroWatch, le constat est cinglant : sur près de 1 000 distributions GNU/Linux référencées, plus de 630 sont aujourd'hui au cimetière numérique."
 tags: []
 date: 2026-02-28 11:57
 lastmod: 2026-02-28 12:00
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Le Paradoxe de Linux : Entre Cimetière de Projets et Hégémonie Mondiale
 Le monde de l’open source est un théâtre d’une brutalité rare. Si l’on se fie aux données de **DistroWatch**, le constat est cinglant : sur près de 1 000 distributions GNU/Linux référencées, plus de 630 sont aujourd'hui au cimetière numérique. Avec un taux de survie qui oscille autour de 30 %, le paysage Linux ressemble davantage à une sélection naturelle darwinienne qu’à un long fleuve tranquille.
 Pourtant, cette hécatombe cache une réalité paradoxale. Si Linux peine à conquérir le bureau de "Monsieur Tout-le-monde", il est devenu l'oxygène du monde numérique moderne.
 ---
 ### I. Les Échecs Illustres : Quand l'Argent et l'Ambition ne Suffisent Pas
 Le succès d'une distribution ne dépend ni de sa levée de fonds, ni de son marketing, mais de la solidité de sa communauté et de sa pertinence technique. Trois exemples marquent cette difficulté :
 - **Mandriva (1998-2011) : La chute du fleuron français.** Née Mandrake, elle a prouvé que Linux pouvait être beau, simple et vendu en boîte chez Carrefour. Sa faillite, après 13 ans de lutte, a laissé un vide immense, bien que son ADN survive à travers **Mageia** et **OpenMandriva**.
 - **Corel Linux (1999-2001) : L'étoile filante.** Corel (connu pour WordPerfect) a tenté de défier Windows frontalement avec une force de frappe financière massive. Résultat ? Une revente en moins de deux ans. L'argent ne suffit pas à acheter une adoption durable.
 - **Ubuntu Touch / Unity (2011-2017) : Le rêve brisé de la convergence.** Mark Shuttleworth (Canonical) voulait un OS unique pour PC et smartphones. Malgré des millions investis, le projet a été abandonné, prouvant que même le leader du bureau ne peut pas forcer le marché mobile face au duo Android/iOS.
 - **Lindows / Linspire (2001-2008) : La promesse brisée.** L'idée était de créer un Linux capable d'exécuter les logiciels Windows nativement (via Wine). Microsoft a attaqué le nom en justice, forçant le passage à "Linspire". Malgré une tentative de simplification extrême (le "Click-n-Run"), le projet a sombré car il n'offrait ni la stabilité de Debian, ni la compatibilité réelle avec Windows.
 - **SteamOS (v1 & v2) : Le faux départ de Valve.** Avant le succès actuel du Steam Deck (sous SteamOS 3 basé sur Arch), Valve avait tenté de lancer des "Steam Machines" sous Debian. Ce fut un échec cuisant : trop peu de jeux compatibles à l'époque et une interface moins performante que Windows. Cela prouve que même avec des milliards, le timing du marché est crucial.
 - **Antergos (2012-2019) : La mort par épuisement.** C'était la distribution préférée de ceux qui voulaient la puissance d'Arch Linux sans la complexité de l'installation. Elle a disparu non par manque d'utilisateurs, mais parce que les développeurs bénévoles n'avaient plus le temps de maintenir un dépôt de paquets sécurisé. La survie est aussi une question de ressources humaines.
 ---
 ### II. Le Poste de Travail : La Forteresse Imprenable ?
 Sur le segment du **Desktop**, le bilan est plus mitigé. En dehors de la niche des développeurs, des administrateurs système et des passionnés de vie privée, Linux stagne. Plusieurs facteurs expliquent ce plafond de verre :
 1. **La pré-installation :** Windows et macOS sont vendus avec le matériel.
 2. **L'écosystème logiciel :** Malgré des progrès (Proton pour le jeu vidéo, suites SaaS), l'absence de la suite Adobe ou d'une version native d'Office reste un frein pour les entreprises.
 3. **La fragmentation :** Le choix immense (plus de 270 distributions actives) est une force pour l'expert, mais une source de confusion pour le néophyte.
 ---
 ### III. La Domination Invisible : Le Maître des Serveurs et du Cloud
 Si Linux est discret sur votre bureau, il est **omniprésent** dès que vous vous connectez à Internet. Le contraste est saisissant :
 - **96 % des serveurs** web mondiaux tournent sous Linux.
 - **100 % des 500 plus gros supercalculateurs** de la planète utilisent une distribution Linux.
 - **Le Cloud (AWS, Azure, GCP)** est quasi intégralement propulsé par Linux. Même Microsoft, autrefois ennemi juré, admet qu'une majorité des instances sur Azure sont sous Linux.
 #### Le "Big Four" de la Production
 En environnement professionnel, le chaos des centaines de distributions disparaît au profit de quatre piliers de stabilité :
 1. **RHEL (Red Hat Enterprise Linux) :** Le standard pour les grandes entreprises et la finance.
 2. **Ubuntu Server :** Le roi du cloud et de la facilité d'utilisation.
 3. **Debian :** Le "système d'exploitation universel", réputé pour sa stabilité légendaire et sa neutralité.
 4. **SUSE :** Pilier de l'industrie, notamment en Europe et dans le secteur industriel.
 ---
 ### IV. Pourquoi le duo Debian / Red Hat survole le marché ?
 Si des centaines de distributions disparaissent, **Debian** et **Red Hat (RHEL)** restent les piliers inébranlables de l'informatique mondiale. Voici pourquoi ils excellent là où les autres échouent.
 #### 1. Red Hat (RHEL) : Le modèle de la prédictibilité
 Red Hat n'est pas seulement un OS, c'est une **assurance vie** pour les entreprises.
 - **Le cycle de vie (Life Cycle) :** Une version de RHEL est supportée pendant 10 ans. Pour une banque ou une usine, savoir que son système recevra des patchs de sécurité jusqu'en 2034 sans avoir à tout réinstaller est un argument massue.
 - **La certification matérielle :** Dell, HP et IBM certifient leurs serveurs spécifiquement pour RHEL. Si un bug survient, le support technique est contractuel.
 - **L'écosystème :** Red Hat a créé les standards (format de paquet RPM, SELinux pour la sécurité). Ils sont les plus gros contributeurs au noyau Linux, ce qui leur donne une maîtrise totale de la technologie.
 #### 2. Debian : Le "Rocher" de l'indépendance
 Debian excelle pour des raisons diamétralement opposées : c'est la démocratie technique pure.
 - **La Stabilité Légendaire :** La version "Stable" de Debian ne sort que lorsqu'elle est prête, sans pression marketing. Les paquets sont testés pendant des mois, voire des années. C'est pour cela qu'elle est la base de prédilection des serveurs critiques et des infrastructures spatiales.
 - **L'Universalité :** Debian supporte une quantité phénoménale d'architectures de processeurs (ARM, x86, PowerPC, MIPS...). Elle tourne aussi bien sur un vieux routeur que sur un supercalculateur.
 - **La neutralité politique :** Contrairement à Ubuntu (Canonical) ou RHEL (IBM), Debian n'appartient à aucune entreprise. Elle est gérée par une organisation à but non lucratif. Pour de nombreux ingénieurs, c'est la garantie que l'OS ne changera pas de direction pour des raisons purement financières.
 ---
 ### V. L'Illusion DistroWatch : Pourquoi Debian Gagne à la Fin
 Il est crucial de ne pas confondre **popularité de curiosité** et **adoption réelle**. DistroWatch mesure l'intérêt des visiteurs (les clics sur les pages), ce qui favorise les distributions "tendance" ou graphiquement innovantes.
 C'est ainsi que **Debian** n'est presque jamais n°1 du classement, alors qu'elle est probablement la distribution la plus influente de l'histoire. Elle sert de base à Ubuntu (et donc à Mint, Pop!_OS, etc.) et fait tourner des millions de serveurs critiques en arrière-plan. C'est le moteur robuste et discret d'une voiture de course dont on ne regarderait que la carrosserie.
 ---
 Le taux d'échec de 70 % n'est pas un signe de faiblesse, mais la preuve d'une vitalité extrême. Dans l'open source, on a le droit d'échouer, de "forker" (reprendre un projet) et d'expérimenter.
 Linux a perdu la bataille du marketing de masse sur le bureau, mais il a gagné la guerre de l'infrastructure mondiale. Pour l'expert, Linux est l'outil de précision ultime. Pour le grand public, c'est cette force invisible qui permet à Netflix, Spotify et à votre banque de fonctionner chaque seconde sans interruption.
--- a/articles/2026/Olvid.md
+++ b/articles/2026/Olvid.md
@@ -0,0 +1,59 @@
 ---
 title: Olvid
 description:
 tags: []
 date: 2026-02-28 12:11
 lastmod: 2026-02-28 12:12
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 Pour contrer l'approche d'Empreinte.com ou les compromis de la DINUM, **Olvid** est souvent citée comme le "gold standard" de la souveraineté numérique française. Contrairement à une solution de visio classique, Olvid est une messagerie instantanée (incluant appels et visio) qui repose sur ## Gemini a dit
 **Olvid** est une application française de messagerie instantanée et de téléphonie (voix/vidéo) qui se distingue par un positionnement radical : la **sécurité maximale par l'absence totale de serveurs centraux d'annuaire.**
 Contrairement à WhatsApp, Signal ou Telegram, Olvid ne vous demande ni votre numéro de téléphone, ni votre accès au carnet d'adresses, ni votre email.
 ---
 ## 1. L'architecture "Zero Trust" (Confiance Zéro)
 C'est la différence fondamentale avec Google, Microsoft ou même Empreinte.
 - **Pas d'annuaire centralisé :** Olvid n'a pas de serveur qui contient la liste de vos contacts. L'échange de clés de chiffrement se fait directement entre les utilisateurs (via un QR code ou un code à 4 chiffres).
 - **Suppression du tiers de confiance :** Même si les serveurs d'Olvid étaient piratés (ou saisis par un État), les attaquants n'auraient accès à aucune donnée, car les métadonnées (qui parle à qui) sont elles-mêmes chiffrées.
 ## 2. Faits Techniques : La "Stack" de Souveraineté
 Contrairement à Empreinte, Olvid a aligné ses actes techniques sur son discours politique :
 |**Élément**|**État de l'art Olvid**|**Comparaison Empreinte/DINUM**|
 |---|---|---|
 |**Sécurité**|Certification de Sécurité de Premier Niveau (**CSPN**) de l'ANSSI.|Empreinte : Propriétaire non certifié.|
 |**Métadonnées**|Anonymisation totale (pas de numéro de téléphone requis).|Google/Microsoft : Collecte massive.|
 |**Infrastructure**|Indépendante de l'annuaire (pas de LDAP/AD central).|DINUM : Dépend de l'annuaire de l'État.|
 |**Chiffrement**|Chiffrement de bout en bout (E2EE) post-quantique.|Visio classique : Souvent chiffrée uniquement sur le serveur.|
 ## 3. Olvid vs La Critique de la DINUM
 Si l'on reprend la lettre de François Caron, Olvid répond à tous les points de friction :
 - **Indépendance technique :** Olvid a développé son propre moteur cryptographique et ses propres protocoles de communication. Ils ne "consomment" pas de briques américaines prêtes à l'emploi.
 - **Auditabilité :** Bien qu'une partie du code soit propriétaire pour des raisons commerciales, la partie critique (le moteur cryptographique) est **Open Source** et a été auditée par l'ANSSI. C'est le compromis idéal : protection du business et garantie absolue pour l'utilisateur.
 ## 4. Les limites (Le revers de la médaille)
 La souveraineté totale a un prix technique et ergonomique :
 - **L'expérience utilisateur (UX) :** Le processus d'invitation (échange de codes) est plus lourd qu'un simple lien Zoom ou Teams. Pour le grand public, c'est un frein.
 - **Pas de "Cloud" classique :** Comme rien n'est stocké sur un serveur, si vous perdez votre téléphone sans avoir fait de sauvegarde manuelle, vous perdez tout. C'est le prix de la sécurité absolue.
 - **Usage spécifique :** Olvid est parfait pour la messagerie mobile et les appels sécurisés, mais moins adapté pour une grande conférence visio à 100 personnes avec partage d'écran complexe, domaine où Zoom ou la solution de la DINUM (basée sur LiveKit) restent plus agiles.
--- a/articles/2026/Piloter
+++ b/articles/2026/Piloter
@@ -0,0 +1,223 @@
 ---
 title: "IPAM Web : piloter dnsmasq avec une interface PHP et SQLite"
 description: Si dnsmasq est l'un des serveurs DNS/DHCP les plus légers et robustes pour les réseaux locaux, sa configuration passe traditionnellement par l'édition de fichiers textes via SSH. Pour simplifier l'exploitation quotidienne — sans pour autant sortir l'artillerie lourde — nous avons développé une suite de scripts PHP permettant de gérer son infrastructure réseau depuis un navigateur.
 tags: [dnsmasq, dns, dhcp, gui]
 date: 2026-02-27 22:42
 lastmod: 2026-02-27 23:56
 type:
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # IPAM Web : piloter dnsmasq avec une interface PHP et SQLite
 **IPAM** est l'acronyme de **Internet Protocol Address Management** (en français : Gestion des adresses IP). C'est une méthodologie, souvent accompagnée d'un logiciel qui permet de planifier, de suivre et de gérer l'espace d'adressage IP au sein d'un réseau. L'inventaire, la corrélation (DNS/DHCP) et la détection des conflits sont les 3 piliers qui définissent l'IPAM.
 `dnsmasq` s’est imposé comme une référence pour fournir des services DNS et DHCP sur des réseaux locaux grâce à sa simplicité, sa faible empreinte et sa grande stabilité. En contrepartie, son administration reste historiquement centrée sur l’édition manuelle de fichiers de configuration, ce qui peut rapidement devenir chronophage et source d’erreurs lorsque l’infrastructure évolue.
 L’interface **IPAM Web** répond à ce besoin : proposer une couche d’administration graphique légère, sans remettre en cause la philosophie minimaliste de `dnsmasq`. L’objectif n’est pas de remplacer l’outil, mais d’en améliorer l’ergonomie et la fiabilité opérationnelle.
 Projet : [https://git.abonnel.fr/cedricAbonnel/dnsmasq-gui](https://git.abonnel.fr/cedricAbonnel/dnsmasq-gui)
 ---
 ## Une approche : conserver la simplicité, ajouter de l’intelligence
 Le système transforme un serveur Linux standard en véritable solution d’**IP Address Management**.  
 La logique est volontairement simple :
 - **SQLite** stocke l’état de référence (DNS, réservations, métadonnées).
 - Des scripts PHP génèrent les fichiers de configuration.
 - `dnsmasq` reste l’unique moteur d’exécution.
 Cette séparation garantit que l’on conserve une infrastructure transparente, lisible et facilement réversible : les fichiers produits restent compatibles avec une exploitation classique en ligne de commande.
 ---
 ## Gestion DNS : un référentiel unique et cohérent
 Le module `admin_dns.php` introduit une gestion centralisée de la résolution locale.
 Plutôt que de disperser l’information dans différents fichiers, chaque enregistrement est stocké en base. Cette approche permet d’assurer la cohérence des données, de limiter les doublons et de tracer les modifications.
 Le système génère ensuite automatiquement un fichier dédié contenant les directives `address=/nom/IP`, directement exploitables par `dnsmasq`.  
 La gestion de la résolution inverse est intégrée : les enregistrements PTR sont créés automatiquement afin de garantir une correspondance bidirectionnelle entre noms et adresses, indispensable pour le diagnostic réseau et certains usages applicatifs.
 ---
 ## DHCP : relier observation et configuration
 Le module `admin_dhcp.php` se positionne comme un outil d’exploitation plutôt que de simple configuration.
 Il analyse en continu le fichier `dhcp.leases` afin de refléter l’état réel du réseau : machines présentes, adresses attribuées, durées de bail.  
 À partir de cette observation, il devient possible de transformer un bail dynamique en réservation permanente en une seule action, ce qui simplifie fortement la stabilisation d’un parc.
 Cette logique réduit les opérations manuelles et limite les risques d’erreur lors de la création de réservations, puisque les informations (MAC, IP, hostname) proviennent directement de la réalité du réseau.
 ---
 ## Visibilité réseau : confronter le modèle et le réel
 Le module `free-ip.php` apporte une dimension d’audit souvent absente des outils légers.
 Plutôt que de se baser uniquement sur les fichiers de configuration, il confronte :
 - le **plan d’adressage théorique** (DNS et DHCP) ;
 - l’**état observé** via un scan ARP.
 Cette corrélation permet d’identifier immédiatement :
 - les équipements présents mais non déclarés ;
 - les incohérences de configuration ;
 - les plages réellement disponibles.
 On obtient ainsi une vision fiable du réseau, utile pour préparer des déploiements ou diagnostiquer des conflits d’adresses.
 ---
 ## Architecture et modules
 La solution est structurée de manière modulaire afin de rester lisible et extensible.
 | Script                 | Fonction       | Rôle opérationnel                                     |
 | ---------------------- | -------------- | ----------------------------------------------------- |
 | index.php              | Point d’entrée | Accès aux modules et vue synthétique                  |
 | admin_dns.php          | Gestion DNS    | Création et export des enregistrements                |
 | admin_dhcp.php         | DHCP           | Visualisation des baux et réservations                |
 | free-ip.php            | Audit IP       | Détection des adresses utilisées/libres               |
 | ddns.php               | DNS dynamique  | Mise à jour via API sécurisée (pas encore implémenté) |
 | migrate_to_sqlite.php  | Initialisation | Import des configurations existantes                  |
 | configurer-dnsmask.php | Paramétrage    | Gestion des options globales                          |
 ---
 ## Modèle de sécurité : contrôle fin des privilèges
 L’interface doit pouvoir écrire dans `/etc/dnsmasq.d/` tout en évitant d’exposer des privilèges root complets au serveur web.
 Le choix retenu repose sur l’utilisation ciblée de commandes autorisées via `sudo`, typiquement `sudo tee` pour l’écriture contrôlée de fichiers.  
 Cette approche limite la surface d’attaque tout en conservant une automatisation complète du cycle de configuration.
 ---
 ## Positionnement de la solution
 IPAM Web se situe volontairement entre deux mondes :
 - plus ergonomique qu’une administration purement en ligne de commande ;
 - plus léger et transparent qu’une solution IPAM d’entreprise.
 Il permet de conserver la maîtrise totale de l’infrastructure tout en améliorant la fiabilité opérationnelle, la visibilité réseau et la rapidité d’intervention.
 ---
 ## Pistes d’amélioration du projet
 Le socle actuel remplit déjà efficacement son rôle d’interface d’exploitation. Les évolutions pertinentes consistent surtout à renforcer la fiabilité, la traçabilité et l’ouverture vers d’autres usages, tout en conservant la philosophie de simplicité.
 ### Fiabilité et robustesse
 La robustesse du système peut être accrue par l'introduction d'un mécanisme de validation "pre-flight". En isolant les modifications dans des fichiers éphémères avant déploiement, nous pouvons soumettre chaque itération à un test de cohérence applicatif. Ce garde-fou empêche toute corruption de la configuration active.
 Parallèlement, la mise en place d'un archivage horodaté des états offre une capacité de restauration critique en cas de régression. Cette architecture gagne à être complétée par une abstraction des fichiers de configuration via **Jinja2**, séparant ainsi la "source de vérité" (données) de sa représentation technique (forme).
 ### Journalisation et audit
 L’ajout d’un journal applicatif structuré permettrait de tracer :
 - qui a effectué une modification ;
 - quand elle a été appliquée ;
 - quelle était la valeur précédente.
 Au-delà du diagnostic, cela transforme l’outil en véritable référentiel d’exploitation et facilite la conformité dans des environnements plus sensibles.
 ### Modélisation réseau plus riche
 Aujourd’hui centré sur les adresses IP et les noms, le modèle pourrait intégrer des notions supplémentaires :
 - segments ou VLAN ;
 - plages IP avec statut (réservé, dynamique, infrastructure, invités) ;
 - métadonnées d’équipement (type, localisation, propriétaire).
 Cette structuration rendrait la recherche et la visualisation beaucoup plus pertinentes, en rapprochant l’outil d’un IPAM complet tout en restant léger.
 ### Visualisation et compréhension du réseau
 Une représentation graphique simple (cartographie logique ou vue par plage IP) améliorerait la compréhension globale du réseau.  
 Sans aller vers une cartographie automatique complexe, une visualisation basée sur les données connues (réservations, baux, détection ARP) suffirait déjà à offrir une lecture immédiate de l’occupation.
 ### API et automatisation
 L’exposition d’une API REST documentée permettrait d’intégrer l’outil dans des workflows existants :
 - scripts d’installation automatisés ;
 - intégration avec un inventaire ou un outil de provisioning ;
 - mise à jour dynamique depuis des équipements.
 Le module DDNS existant constitue déjà une base naturelle pour cette ouverture mais n'est pas encore exploité. Il faudrait qu'il alimente une table `machines` dans notre base SQLite. Ainsi, notre tableau de bord `index.php` pourra afficher une liste complète de notre parc avec :
 - Le nom de la machine.
 - Sa dernière IP connue.
 - Son système d'exploitation (extrait de `hostnamectl`).
 - La date de sa dernière "vue" (Last Seen).
 ### Sécurité applicative
 Plusieurs axes peuvent renforcer la posture de sécurité :
 - authentification forte (OIDC ou SSO) ;
 - gestion de rôles (lecture seule, exploitation, administration) ;
 - protection CSRF et durcissement des entrées utilisateur.
 Ces éléments deviennent essentiels dès que l’outil dépasse un usage strictement personnel.
 ### Expérience d’exploitation
 Enfin, quelques améliorations ergonomiques ont un impact immédiat :
 - recherche globale (IP, nom, MAC) ;
 - actions rapides contextuelles ;
 - indicateurs d’état (conflit IP, doublon DNS, incohérence PTR).
 Ces fonctions réduisent le temps d’analyse et rapprochent l’outil d’une console d’exploitation quotidienne.
 ## Gestion de l'Idempotence
 Le script `migrate_to_sqlite.php` vide la table (`DELETE FROM dns_records`) à chaque lancement. C'est risqué.
 **Amélioration :** Adoptez une logique de synchronisation :
 1. Lire le fichier.
 2. Comparer chaque ligne avec la base SQLite.
 3. `INSERT` si nouveau, `UPDATE` si différent, et ne rien faire si identique. Cela évite de perdre des données si le script s'arrête en plein milieu.
--- a/articles/2026/Pourquoi
+++ b/articles/2026/Pourquoi
@@ -0,0 +1,71 @@
 ---
 title: "`rm -rf /` : Pourquoi cette commande \"suicidaire\" fait-elle encore parler d'elle ?"
 description: Dans l'imaginaire collectif des utilisateurs de Linux, il n'existe pas de suite de caractères plus terrifiante que `rm -rf /`.
 tags: []
 date: 2026-03-04 13:56
 lastmod: 2026-03-04 13:56
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # `rm -rf /` : Pourquoi cette commande "suicidaire" fait-elle encore parler d'elle ?
 Dans l'imaginaire collectif des utilisateurs de Linux, il n'existe pas de suite de caractères plus terrifiante que `rm -rf /`. C'est le "bouton rouge" de l'informatique : une commande capable de réduire un système d'exploitation entier à néant en quelques secondes. Pourtant, comme vous l'avez souligné, cette commande est aujourd'hui bridée par des sécurités natives. Alors pourquoi faire une vidéo de 10 minutes à son sujet en 2026 ?
 ## 1. L'anatomie d'une bombe numérique
 Pour comprendre le danger, il faut décomposer les composants de la commande :
 - **`rm` (remove) :** L'outil de base pour supprimer des fichiers.
 - **`-r` (recursive) :** Indique à l'outil de descendre dans tous les sous-dossiers.
 - **`-f` (force) :** Ignore les fichiers protégés en écriture et ne demande jamais de confirmation.
 - **`/` (root) :** Désigne la racine du système, là où tout commence (système, données, configurations).
 ## 2. La protection `--preserve-root` : Le garde-fou moderne
 Depuis 2006, la plupart des distributions Linux (via les _GNU Coreutils_) incluent une protection par défaut. Si vous tapez exactement `rm -rf /`, le terminal vous renverra une erreur du type :
 > _it is dangerous to operate recursively on '/' (use --preserve-root to override)_
 C'est une "sécurité enfant" qui empêche l'exécution accidentelle. Cependant, la vidéo de _Techquickie_ souligne que cette protection est **loin d'être infaillible**.
 ## 3. Les failles de la protection (Pourquoi le danger persiste)
 Il existe plusieurs manières de contourner cette sécurité, parfois sans même le vouloir :
 - **L'astérisque fatale (`rm -rf /*`) :** C'est le piège le plus courant. L'astérisque est interprétée par le shell comme "tous les dossiers contenus dans la racine". Comme la cible n'est techniquement pas `/` mais `/bin`, `/home`, `/etc`, etc., la protection ne se déclenche pas et le système s'autodétruit.
 - **Les variables d'environnement vides :** Un script mal écrit contenant `rm -rf $REPERTOIRE_TEMP/` peut devenir catastrophique si la variable est vide. La commande devient alors `rm -rf /`.
 ## 4. Au-delà du logiciel : Le "brickage" matériel
 L'un des points les plus fascinants (et effrayants) abordés dans la vidéo est l'impact sur le **firmware UEFI**. Sur certains ordinateurs modernes, Linux monte les variables du BIOS/UEFI comme des fichiers modifiables dans `/sys/firmware/efi/efivars`.
 Si vous lancez un `rm -rf /` avec les privilèges administrateur :
 1. Le système efface les fichiers système.
 2. Il accède ensuite aux variables EFI et les efface.
 3. **Résultat :** La carte mère ne sait plus comment démarrer (ni même accéder au BIOS). L'ordinateur est physiquement "briqué" et nécessite souvent une réparation matérielle.
 ## 5. L'aspect historique et humain
 La vidéo justifie sa durée par l'aspect culturel. Elle mentionne notamment l'incident chez **Pixar** lors de la production de _Toy Story 2_. Un employé a accidentellement lancé une commande de suppression sur le serveur principal, effaçant 90 % du travail du film. Le film n'a été sauvé que parce qu'une directrice technique avait une copie de sauvegarde sur son ordinateur personnel chez elle pendant son congé maternité.
 ## Conclusion : Une leçon de prudence
 Si `rm -rf /` est aujourd'hui protégée contre les erreurs de frappe les plus basiques, elle reste le symbole ultime de la puissance (et de la dangerosité) de la ligne de commande. La protection logicielle est une barrière, mais la compréhension de ce que l'on tape reste la seule véritable sécurité.
 ---
 **Souhaitez-vous que je vous montre comment configurer un "alias" de sécurité pour empêcher toute suppression accidentelle sur votre propre système ?**
--- a/articles/2026/Souveraineté
+++ b/articles/2026/Souveraineté
@@ -0,0 +1,147 @@
 ---
 title: "Souveraineté Numérique : La \"Lettre Ouverte\" de François Caron, un Cas d’École d'Incohérence Stratégique ?"
 description: Si la DINUM n'est pas parfaite, elle a au moins le mérite de construire des outils dont elle possède le code source et qu'elle héberge sur des infrastructures certifiées (SecNumCloud).
 tags: []
 date: 2026-02-28 12:01
 lastmod: 2026-02-28 12:12
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Souveraineté Numérique : La "Lettre Ouverte" de François Caron, un Cas d’École d'Incohérence Stratégique ?
 Le 22 février 2026, François Caron, PDG de l'entreprise **Empreinte.com**, a publié une lettre ouverte adressée à la DINUM (Direction Interministérielle du Numérique). Ce texte se veut un plaidoyer pour la souveraineté française face aux géants américains. Pourtant, une analyse approfondie de la "stack" technique de l'auteur révèle un gouffre entre les paroles et les actes, transformant ce qui devait être une leçon de patriotisme en une démonstration de dépendance aux GAFAM.
 ## I. Le Discours : Un Plaidoyer pour l'Indépendance
 Dans sa lettre, François Caron attaque frontalement la DINUM sur ses choix technologiques pour la solution **Visio-Agents**. Ses griefs sont clairs :
 1. **L’utilisation de briques étrangères :** Il reproche à l’État d’utiliser des briques comme _LiveKit_ (technologie américaine), même si elles sont Open Source.
 2. **Le mépris des PME françaises :** Il affirme que sa propre solution, _Empreinte.Live_, est ignorée par l’administration depuis 2021 alors qu’elle serait "plus souveraine".
 3. **Le faux nez de l’Open Source :** Pour lui, le code ouvert ne garantit pas la souveraineté si le moteur reste américain. Il prône une "indépendance par l'industrie française".
 ## II. La Réalité Technique : "Faites ce que je dis, pas ce que je fais"
 C’est ici que le bât blesse. Lorsque l’on analyse l’infrastructure réelle d’Empreinte.com, la contradiction est flagrante. Plusieurs experts et observateurs du numérique ont relevé trois points qui vident le discours de sa substance :
 ### 1. La messagerie chez Google
 Alors que la souveraineté commence par la protection des échanges internes (stratégies, devis, fichiers clients), Empreinte.com utilise **Google Workspace**. En pointant leurs enregistrements MX vers les serveurs de Mountain View, l'entreprise soumet de fait ses données au _Cloud Act_ américain.
 > **Le paradoxe :** Demander à l’État de quitter Microsoft tout en gérant sa propre boîte mail sur Google.
 ### 2. Le site web sous protection américaine (Cloudflare)
 Le site vitrine d'Empreinte, qui vante une "visio souveraine", est protégé par **Cloudflare**. Cette entreprise californienne agit comme un intermédiaire : chaque visiteur du site passe par des serveurs américains avant d'atteindre le contenu français.
 ### 3. Le choix du "Code Fermé" (Propriétaire)
 Caron critique l'Open Source de la DINUM, mais propose un logiciel **propriétaire**.
 - **La DINUM :** Utilise du code ouvert (modifiable, auditable, réutilisable par tous).
 - **Empreinte :** Propose une "boîte noire" dont seul l'éditeur détient les clés.
    En termes de souveraineté, l'État préfère généralement posséder le code (Open Source) plutôt que d'être "captif" d'un éditeur privé français qui peut faire faillite ou être racheté.
 ## III. Les Enjeux : Une Guerre de Modèles
 Derrière cette lettre se cache une lutte de pouvoir sur la définition même de la souveraineté :
 - **La Souveraineté Économique (Caron) :** "Achetez mon produit parce que je suis Français et que je paie mes impôts ici." C'est une vision protectionniste.
 - **La Souveraineté Technique (DINUM) :** "Nous voulons maîtriser le code de A à Z, sans dépendre d'un contrat avec une entreprise privée, même nationale." C'est une vision d'autonomie stratégique.
 |**Critère**|**Solution DINUM**|**Solution Empreinte**|
 |---|---|---|
 |**Code Source**|Open Source (Libre)|Propriétaire (Fermé)|
 |**Hébergement**|Cloud Souverain (Outscale)|Site web derrière Cloudflare (US)|
 |**Outils Internes**|Suite de l'État|Google Workspace (US)|
 |**Modèle**|Commun numérique|Produit commercial|
 ## IV. Conclusion : L'Arroseur Arrosé
 La lettre ouverte de François Caron souffre d'un manque de crédibilité technique. En 2026, on ne peut plus se contenter de brandir un drapeau français pour masquer des dépendances structurelles aux GAFAM.
 Si la DINUM n'est pas parfaite, elle a au moins le mérite de construire des outils dont elle possède le code source et qu'elle héberge sur des infrastructures certifiées (SecNumCloud). À l'inverse, proposer une solution de visio "souveraine" tout en étant client de Google pour ses mails revient à vendre des serrures françaises tout en laissant le double des clés de l'usine chez son voisin américain.
 ---
 # Les faits techniques
 Pour sortir de la polémique émotionnelle et se concentrer sur la **vérité technique**, voici les faits bruts issus de l'analyse des infrastructures numériques d'Empreinte.com au 28 février 2026.
 Ces données sont publiques (via les outils de requêtes DNS et d'analyse de headers HTTP) et permettent de confronter le discours de souveraineté à la réalité des flux de données.
 ## 1. Analyse de la Messagerie (Le "Cœur" de l'entreprise)
 La souveraineté numérique commence par la confidentialité des échanges internes. L'analyse des enregistrements **MX (Mail Exchange)** du domaine `empreinte.com` révèle :
 - **Serveur de réception :** `ASPMX.L.GOOGLE.COM`
 - **Fournisseur :** Google Workspace (États-Unis).
 - **Implication technique :** Toutes les communications d'Empreinte (échanges avec la DINUM, stratégies commerciales, données clients) transitent par les serveurs de Google et sont techniquement soumises au **Cloud Act** américain, qui permet aux autorités US d'accéder aux données d'une entreprise américaine, même si elles sont stockées à l'étranger.
 ## 2. Analyse de la Diffusion Web et Sécurité (Le "Point de Passage")
 L'analyse des **Name Servers (NS)** et des adresses IP du site `empreinte.com` montre l'utilisation de **Cloudflare** :
 - **Infrastructure :** Les serveurs de noms pointent vers `*.ns.cloudflare.com`.
 - **Le rôle de Cloudflare :** C'est un "Reverse Proxy". Cela signifie que lorsqu'un utilisateur se connecte sur le site d'Empreinte, sa connexion est interceptée par Cloudflare (USA) avant d'être renvoyée vers l'hébergeur.
 - **Le risque de souveraineté :** Cloudflare a la capacité technique de déchiffrer le flux SSL/TLS (le petit cadenas du navigateur) pour inspecter le trafic. Une entreprise qui prône l'indépendance totale confie ici ses clés de chiffrement de transport à un tiers californien.
 ## 3. Analyse du Logiciel : Propriétaire vs Open Source
 C'est le point de friction majeur avec la DINUM. Voici la différence structurelle entre les deux approches :
 ### La solution DINUM (Basée sur LiveKit)
 - **Modèle :** Open Source.
 - **Auditabilité :** Le code est public. N'importe quel expert peut vérifier l'absence de "backdoor" (porte dérobée).
 - **Maîtrise :** L'État peut "forker" (copier et modifier) le code. Si LiveKit (l'entreprise US) disparaît, l'État français possède toujours le code et peut continuer à le faire évoluer.
 ### La solution Empreinte.Live
 - **Modèle :** Propriétaire (Code fermé).
 - **Auditabilité :** Impossible sans l'autorisation et les outils fournis par l'éditeur.
 - **Dépendance :** L'État devient captif. Si Empreinte.com change ses tarifs ou fait faillite, la solution s'arrête. C'est ce qu'on appelle le **"Vendor Lock-in"** (enfermement propriétaire).
 ---
 ## Synthèse des Faits Techniques
 |**Composant**|**État de l'Art Souverain**|**Réalité Empreinte.com**|
 |---|---|---|
 |**Emails**|ProtonMail, BlueMind, Zimbra (Hébergé FR)|**Google Workspace (USA)**|
 |**DNS / Protection**|Orange Cyberdefense, Gandi, NS1|**Cloudflare (USA)**|
 |**Moteur Vidéo**|Jitsi, BigBlueButton (Open Source)|**Propriétaire (Fermé)**|
 |**Analytique Web**|Matomo (RGPD / Auto-hébergé)|Souvent **Google Analytics** (à vérifier sur le site)|
 ## Conclusion Technique
 D'un point de vue purement ingénierie, la critique de François Caron envers la DINUM est **techniquement asymétrique**.
 Il reproche à l'État d'utiliser des briques _Open Source_ d'origine américaine (qu'on peut pourtant "nationaliser" par le code), alors que sa propre entreprise est structurellement dépendante de services _SaaS_ américains (Google, Cloudflare) qu'il ne peut ni modifier, ni auditer, ni contrôler juridiquement.
 En clair : **La DINUM construit une maison avec des briques étrangères mais dont elle a les plans, tandis qu'Empreinte vend une maison française dont les clés de la porte d'entrée et la boîte aux lettres appartiennent à Google.**
 Voir aussi [[Olvid]]
--- a/articles/2026/convertir
+++ b/articles/2026/convertir
@@ -0,0 +1,42 @@
 ---
 title: Convertir un fichier MKV en MP4
 description: Remuxing d'un fichier mkv en mp4 sous linux avec ffmpeg.
 tags:
  - ffmpeg
  - mp4
  - mkv
 date: 2026-03-11 17:59
 lastmod: 2026-03-11 18:02
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Convertir un fichier MKV en MP4
 Un fichier vidéo est comme une boîte (le **conteneur** : MKV, MP4) qui contient des objets (les **flux** : vidéo H.264/H.265, audio AAC/MP3). Comme le MKV et le MP4 acceptent souvent les mêmes types de flux vidéo, on peut simplement "transvaser" le contenu de l'un vers l'autre sans rien transformer.
 C'est ce qu'on appelle le **remuxing** (ou copie de flux). C'est instantané et il n'y a **aucune perte de qualité**.
 Sous Linux Mint, l'outil roi est **FFmpeg**. S'il n'est pas installé : `sudo apt install ffmpeg`.
 Pour changer le conteneur sans réencoder la vidéo ni l'audio, ouvrez un terminal dans votre dossier et tapez :
 ``ffmpeg -i entree.mkv -codec copy sortie.mp4``
 - `-i entree.mkv` : votre fichier source.
 - `-codec copy` : indique à FFmpeg de copier les flux tels quels sans les recalculer.
 - `sortie.mp4` : le nouveau fichier.
 Bien que le changement de conteneur suffise 90% du temps, voici deux cas où cela pourrait coincer :
 1. **Le format audio :** Le MP4 est plus strict que le MKV. Si votre MKV contient de l'audio au format **FLAC** ou **Vorbis**, certains lecteurs MP4 ne l'aimeront pas. Il faudra alors convertir juste l'audio :
    - `ffmpeg -i entree.mkv -c:v copy -c:a aac sortie.mp4` (On copie la vidéo, on convertit l'audio en AAC).
 2. **Les sous-titres :** Le MKV gère très bien les sous-titres intégrés (ASS/SSA). Le MP4 est beaucoup plus limité. Ils risquent de disparaître lors d'un simple "copy".
--- a/articles/2026/gscan2pdf
+++ b/articles/2026/gscan2pdf
@@ -0,0 +1,65 @@
 ---
 title: "Linux Mint 22 et gscan2pdf : Pourquoi il faut \"briser\" la routine d'installation"
 description: Comment installer gscan2pdf sur Linux Mint 22 ?
 tags: [scan, ocr, scan2pdf, Mint, Linux]
 date: 2026-03-13 12:40
 lastmod: 2026-03-13 12:44
 type:
  - article
 category:
  - "[[Logiciels et Outils]]"
  - "[[Guide]]"
 status: terminé
 ---
 # Linux Mint 22 et gscan2pdf : Pourquoi il faut "briser" la routine d'installation
 ![](Pasted%20image%2020260313124448.png)
 C'est un paradoxe classique du logiciel libre : la version d'une application incluse dans votre gestionnaire de logiciels n'est pas toujours la meilleure pour vous. Dans le cas de **gscan2pdf** sur **Linux Mint 22**, installer la version "standard" revient à installer un moteur en panne.
 ## Le constat : Le piège du dépôt "Stable"
 Normalement, l'utilisateur Linux a un réflexe sain : utiliser les dépôts officiels. Mais sur Mint 22 (basée sur Ubuntu 24.04), le dépôt standard propose la version **2.13.2**.
 Pour gscan2pdf, c'est la version de trop. Elle se heurte à deux murs :
 1. **L'évolution de Perl :** Le système utilise un langage trop récent pour le vieux code de l'application, inondant l'utilisateur d'alertes de dépréciation.
 2. **Le changement de structure de Mint :** L'application cherche un fichier là où Mint 22 a désormais placé un dossier (`/etc/upstream-release`), provoquant un crash immédiat.
 Résultat ? L'installation standard est, au sens propre, inutilisable.
 ## Contourner pour mieux régner
 Pour retrouver un scanner fonctionnel, la consigne est claire : **ne pas faire confiance au dépôt par défaut.** Il faut aller chercher la correction directement à la source, là où le développeur (Jeffrey Ratcliffe) a déjà colmaté les brèches.
 La solution ne passe pas par une interface graphique, mais par trois commandes décisives dans le terminal. On force le système à ignorer sa base de données habituelle pour adopter celle du développeur :
 1. **L'ajout de l'autorité (PPA) :** On crée un "tunnel" direct vers les mises à jour du créateur.
    ```Bash
    sudo add-apt-repository ppa:jeffreyratcliffe/ppa
    ```
 2. **La synchronisation :** On force Mint à constater que, oui, il existe une version bien plus moderne (2.13.4 ou supérieure) ailleurs.
    ```Bash
    sudo apt update
    ```
 3. **Le remplacement :** On écrase la version défaillante.
    ```Bash
    sudo apt install gscan2pdf
    ```
 ## L'OCR en français
 Une fois le logiciel "réanimé", il reste souvent muet face aux textes français. Par défaut, le moteur de reconnaissance **Tesseract** ne parle qu'anglais. Pour compléter cette installation, il est indispensable d'ajouter manuellement la brique linguistique :
 ```Bash
 sudo apt install tesseract-ocr-fra
 ```
--- a/articles/2026/guide_d_installation_linux_mint_depuis_windows.md
+++ b/articles/2026/guide_d_installation_linux_mint_depuis_windows.md
@@ -0,0 +1,939 @@
 ---
 title: "Guide d'installation : Linux Mint (depuis Windows)"
 description: 
 tags: []
 date: 2026-03-04 22:04
 lastmod: 2026-03-04 23:11
 type: 
 category: 
 status: 
 ---
 # Guide d'installation : Linux Mint (depuis Windows)
 Ce guide, utilisé par les bénévoles d'**Alpinux**, détaille les étapes pour installer Linux Mint 21.2 (Cinnamon) en dual-boot ou en remplacement de Windows.
 ## Préparation de Windows
 ### Sauvegarder son profil Firefox (Windows vers Linux)
 Le profil Firefox contient l'intégralité de votre vie numérique : marque-pages, mots de passe enregistrés, extensions et historique. Sous Linux Mint, Firefox est souvent installé par défaut, ce qui facilite la transition.
 #### Procédure de sauvegarde sous Windows :
 1. **Accéder aux informations de dépannage :**
    Ouvrez Firefox. Dans la barre d'adresse, tapez `about:support` et appuyez sur **Entrée**.
 2. **Localiser le dossier du profil :**
    Dans le tableau "Paramètres de base de l’application", cherchez la ligne **Répertoire du profil**. Cliquez sur le bouton **Ouvrir le dossier correspondant**.
 3. **Fermer Firefox :**
    > **Important :** Avant de copier quoi que ce soit, fermez complètement Firefox. Si le navigateur reste ouvert, certains fichiers (comme les bases de données de mots de passe) risquent d'être corrompus ou incomplets.
 4. **Remonter dans l'arborescence :**
    Dans la fenêtre de l'Explorateur de fichiers qui vient de s'ouvrir, cliquez dans la barre d'adresse sur le dossier parent nommé `Profiles`.
 5. **Copier les éléments essentiels :**
    Copiez les éléments suivants sur une clé USB ou un disque externe :
    - **Le dossier de votre profil** (nommé souvent `xxxxxxx.default-release`).
    - **Les fichiers `installs.ini` et `profiles.ini`** : ils se situent un niveau au-dessus (dans le dossier `Firefox`). Ces fichiers sont cruciaux car ils indiquent à Firefox quel dossier de profil charger par défaut.
 6. **Sécuriser la copie :**
    Vérifiez que la copie est terminée avant d'éjecter votre support amovible.
 ---
 ### Note pour Linux Mint (Restauration)
 Une fois Linux Mint installé, l'emplacement de destination sera différent.
 - **Si Firefox est installé classiquement :** Le dossier se trouve dans `~/.mozilla/firefox/` (appuyez sur `Ctrl + H` dans votre dossier personnel pour voir les dossiers cachés).
 - **Si Firefox est en format Flatpak :** Le chemin sera `~/.var/app/org.mozilla.firefox/.mozilla/firefox/`.
 ---
 ### Étape cruciale : Déterminer le mode de démarrage (UEFI ou BIOS)
 Avant de lancer l'installation, vous devez savoir comment votre carte mère communique avec votre système actuel. Cela impacte directement la création de la clé USB (format de partition GPT ou MBR).
 #### Procédure sous Windows :
 1. **Lancer l'outil de diagnostic :** Appuyez simultanément sur les touches **`⊞ Win + R`**, tapez `msinfo32` dans la boîte de dialogue, puis validez avec **Entrée**.
 2. **Identifier le mode :** Dans la fenêtre "Résumé du système" qui s'affiche, cherchez la ligne intitulée **Mode BIOS**.
    - **UEFI :** L'ordinateur utilise l'interface moderne. C'est le cas de la quasi-totalité des PC vendus depuis 2012.
    - **Hérité (ou Legacy) :** L'ordinateur utilise l'ancien système (BIOS classique). Cela concerne les machines plus anciennes.
 - **Si vous êtes en UEFI :**
    - Votre disque dur utilise probablement une table de partition **GPT**.
    - Lors de l'installation, Linux Mint aura besoin d'une petite partition spécifique nommée **ESP** (EFI System Partition), généralement de 200 à 500 Mo, formatée en FAT32.
 - **Si vous êtes en BIOS (Hérité) :**
    - Votre disque utilise une table de partition **MBR**.
    - L'installation est plus simple (pas de partition EFI), mais ce mode ne supporte pas les disques de plus de 2 To.
 Si vous êtes en mode **UEFI**, Windows utilise souvent le **Secure Boot**.
 - **Linux Mint actuel** est parfaitement compatible avec le Secure Boot.
 - Cependant, si vous installez des pilotes propriétaires (comme ceux pour les cartes graphiques NVIDIA), le système pourra vous demander de créer un mot de passe de sécurité (MOK) au premier redémarrage pour valider ces pilotes.
 ### Désactiver le "Démarrage Rapide" (Fast Boot) de Windows
 Le "Démarrage rapide" de Windows (versions 8, 10 et 11) est une sorte d'hibernation partielle. Au lieu de s'éteindre complètement, Windows verrouille le disque dur et le matériel pour redémarrer plus vite.
 #### Méthode 1 : Via l'interface graphique (Recommandé)
 1. Ouvrez le **Panneau de configuration** (tapez-le dans la recherche Windows).
 2. Allez dans **Matériel et audio** > **Options d’alimentation**.
 3. Dans la colonne de gauche, cliquez sur **Choisir l’action des boutons d’alimentation**.
 4. Cliquez sur le lien bleu en haut : **Modifier des paramètres actuellement non disponibles** (cela demande les droits administrateur).
 5. En bas de la fenêtre, dans la section "Paramètres d'arrêt", **décochez** la case **Activer le démarrage rapide (recommandé)**.
 6. Cliquez sur **Enregistrer les modifications**.
 #### Méthode 2 : Via le Terminal (La plus rapide)
 Cette commande désactive l'hibernation, ce qui par extension désactive le démarrage rapide :
 1. Faites un clic droit sur le bouton **Démarrer**.
 2. Choisissez **Terminal (administrateur)**, **PowerShell (admin)** ou **Invite de commandes (admin)**.
 3. Tapez la commande suivante et validez avec Entrée :
    DOS
    ```
    powercfg /hibernate off
    ```
 > [!info]
 > **Astuce :** Au moment d'éteindre Windows pour insérer votre clé USB, maintenez la touche **Maj (Shift) ⇧** enfoncée tout en cliquant sur **Démarrer > Arrêter**. Cela force un arrêt complet et définitif de la session.
 ### Gestion de l'alimentation de la carte Wi-Fi
 Certaines cartes Wi-Fi (notamment les puces Realtek ou Broadcom) peuvent rester dans un état de "basse consommation" ou de "verrouillage" défini par Windows au moment de l'arrêt. Si Linux Mint démarre alors que la carte est dans cet état, il peut être impossible d'activer le Wi-Fi, ou vous pourriez subir des déconnexions intempestives.
 #### Procédure sous Windows (8, 10 et 11) :
 1. **Ouvrir le gestionnaire :** Faites un clic droit sur le bouton **Démarrer** (ou utilisez le raccourci `Win + X`) et sélectionnez **Gestionnaire de périphériques**.
 2. **Trouver la carte :** Déroulez la section **Cartes réseau**.
 3. **Accéder aux propriétés :** Faites un clic droit sur votre carte Wi-Fi (généralement nommée avec les termes "Wireless", "AC", "AX" ou "Wi-Fi") et choisissez **Propriétés**.
 4. **Désactiver la veille :** * Allez dans l'onglet **Gestion de l'alimentation**.
    - **DÉCOCHEZ** la case : **"Autoriser l'ordinateur à éteindre ce périphérique pour économiser de l'énergie"**.
    - Validez avec **OK**.
 > **Note technique :** Si l'onglet "Gestion de l'alimentation" n'apparaît pas, cela signifie que Windows gère l'énergie via un profil global (Modern Standby). Dans ce cas, assurez-vous simplement d'avoir bien désactivé le **Démarrage Rapide** (voir étape précédente), ce qui libérera proprement le matériel lors de l'arrêt.
 > [!info]
 >  Une fois que Linux Mint sera installé, si vous constatez toujours des instabilités Wi-Fi, il existe une manipulation similaire sous Linux. Le script de post-installation d'Alpinux s'en occupe souvent, mais voici la commande manuelle pour désactiver la gestion d'énergie Wi-Fi sous Mint :
 >
 ```bash
 # Pour vérifier l'état actuel (5 = activé, 2 = désactivé)
 grep WiFi.powersave /etc/NetworkManager/conf.d/default-wifi-powersave-on.conf
 ```
 ## Désactiver le Secure Boot (Démarrage Sécurisé)
 Le **Secure Boot** est une fonctionnalité de l'UEFI qui n'autorise que le lancement de systèmes d'exploitation dont la "signature" est reconnue. Bien que Linux Mint soit compatible avec le Secure Boot, il est souvent préférable de le désactiver pour faciliter l'installation.
 #### Pourquoi désactiver le Secure Boot ?
 - **Pilotes tiers :** Il bloque parfois l'installation de pilotes propriétaires indispensables (cartes graphiques NVIDIA, certaines cartes Wi-Fi).
 - **Compatibilité USB :** Certaines clés USB de démarrage (dont Ventoy dans certaines configurations) peuvent être rejetées au démarrage si le Secure Boot est actif.
 - **Maintenance :** Il empêche l'utilisation de nombreux outils de diagnostic ou de récupération système basés sur Linux.
 **Méthode 1 : Accès direct au démarrage**
 1. Éteignez l'ordinateur.
 2. Rallumez-le et tapotez immédiatement la touche d'accès au BIOS/UEFI (généralement **F2**, **F12**, **Suppr** ou **Échap** selon la marque).
 **Méthode 2 : Depuis Windows (si le démarrage est trop rapide)**
 1. Cliquez sur le menu **Démarrer** > **Marche/Arrêt**.
 2. Maintenez la touche **Maj (Shift) ⇧** enfoncée et cliquez sur **Redémarrer**.
 3. L'ordinateur affiche un menu bleu : choisissez **Dépannage** > **Options avancées** > **Paramètres du firmware UEFI**, puis validez.
 **Dans le menu UEFI :**
 1. Allez dans l'onglet **Security** (Sécurité) ou **Boot** (Démarrage).
 2. Cherchez la ligne **Secure Boot**.
 3. Passez-la sur **Disabled** (Désactivé).
 4. Appuyez sur **F10** pour "Save and Exit" (Enregistrer et quitter).
 ## Préparer son support d'installation
 ### 1. Choisir son édition
 Linux Mint est proposé avec différents "environnements de bureau". Le cœur du système est le même, seule l'apparence et la consommation de ressources changent.
 - **Cinnamon Edition :** Le fleuron de Linux Mint. C'est l'environnement le plus moderne et le plus complet. Idéal pour les ordinateurs récents (après 2012).
 - **XFCE Edition :** L'édition la plus légère et la plus sobre. Elle est parfaite pour redonner vie à un ordinateur ancien ou disposant de peu de mémoire vive.
 - **MATE Edition :** Un excellent compromis entre tradition et performance (très stable).
 #### Limitations importantes :
 - **Fin du 32 bits :** Linux Mint ne propose plus de versions 32 bits (pour les processeurs d'avant 2007). Si votre matériel est plus ancien, il faudra vous tourner vers d'autres distributions comme _Debian_ ou _LMDE_ (Linux Mint Debian Edition) dans sa version spécifique, mais cela reste marginal.
 - **Processeurs ARM :** Linux Mint est conçu pour les processeurs Intel et AMD (x86_64).
 ---
 ### 2. Spécifications matérielles
 Bien que l'éditeur propose des minimums théoriques, l'expérience **Alpinux** montre qu'il faut viser un peu plus haut pour un confort réel.
 |Composant|Minimum (Éditeur)|Recommandé (Alpinux)|
 |---|---|---|
 |**Mémoire Vive (RAM)**|2 Go|**4 Go** (pour naviguer sur le Web sans lenteur)|
 |**Espace Disque**|20 Go|**50 Go** (pour inclure les mises à jour et vos documents)|
 |**Résolution**|1024 x 768 px|1366 x 768 px ou plus|
 > **⚠️ Alerte Installation :** L'installateur refuse de se lancer si l'espace disque détecté est inférieur à **10,7 Go**.
 ---
 ### 3. Télécharger Linux Mint
 1. Rendez-vous sur le site officiel : [https://linuxmint.com/](https://linuxmint.com/).
 2. Cliquez sur le bouton **Download**.
 3. Choisissez votre édition (**Cinnamon** par défaut).
 4. Sélectionnez un "miroir" de téléchargement (un serveur) proche de chez vous (par exemple en France : _Ircam_, _CRIHAN_ ou _Équilibre_) pour un téléchargement plus rapide.
 ---
 ### 4. Créer la clé USB avec Ventoy (Méthode Alpinux)
 Puisque vous utilisez **Ventoy**, la préparation est extrêmement simple :
 1. **Préparer la clé :** Si ce n'est pas déjà fait, installez Ventoy sur votre clé USB (cela effacera les données de la clé).
 2. **Copier-Coller :** Une fois la clé "Ventoy" prête, elle apparaît comme un disque amovible classique. **Copiez simplement le fichier ISO** (ex: `linuxmint-32-cinnamon-64bit.iso`) directement à la racine de la clé.
 3. **Multisystème :** L'avantage de Ventoy est que vous pouvez copier plusieurs fichiers ISO (Mint, Ubuntu, outils de réparation) sur la même clé ; un menu au démarrage vous permettra de choisir lequel lancer.
 ## Démarrer sur la clé USB (Session Live)
 ### 1. Branchements et préparation
 - Insérez votre clé USB **Ventoy** dans un port USB (évitez les hubs USB si possible, préférez un port direct sur la machine).
 - **Important :** Branchez un câble réseau (Ethernet). Cela permet à Linux Mint de télécharger les mises à jour et les codecs manquants dès l'installation, ce qui évite bien des soucis de pilotes plus tard.
 ### 2. Accéder au menu de démarrage (Boot Menu)
 Redémarrez l'ordinateur et tapotez immédiatement la touche de sélection du démarrage. Cette touche varie selon les constructeurs :
 - **F12** (Dell, Lenovo, Acer, Gigabyte)
 - **F10** (HP)
 - **F8** ou **F11** (ASUS)
 - **Échap** (HP, certains portables)
 Dans la liste qui s'affiche, sélectionnez votre clé USB.
 > **Conseil Alpinux :** Si vous voyez deux fois votre clé USB (ex: "USB Disk" et "**UEFI:** USB Disk"), choisissez toujours l'option commençant par **UEFI** pour une installation moderne.
 ### 3. Utiliser le menu Ventoy
 Une fois sur l'écran bleu de **Ventoy** :
 1. Utilisez les flèches du clavier pour sélectionner l'ISO de Linux Mint (ex: `linuxmint-22-cinnamon-64bit.iso`).
 2. Appuyez sur **Entrée**.
 3. Choisissez l'option **"Boot in normal mode"** (ou appuyez simplement sur Entrée).
 > [!info] Pourquoi passer par le mode BIOS ou EFI ?
 >
 > Ventoy fait le pont pour vous, mais vous remarquerez une différence visuelle :
 >
 >- **En mode UEFI :** Le menu de sélection initial est souvent en texte blanc sur fond noir (GRUB). C'est le mode recommandé pour les PC récents.
  >  
 >- **En mode BIOS (Legacy) :** Le menu peut sembler plus ancien (Isolinux). Ce mode est à réserver aux vieux ordinateurs d'avant 2012.
 ### 4. Lancement de Linux Mint
 Un second menu (le GRUB de Mint) apparaît. Choisissez : **"Start Linux Mint (64-bit)"**
 - Le logo de Linux Mint (LM) s'affiche au centre de l'écran.
 - Après quelques secondes, vous arrivez sur le **Bureau Live**.
 ---
 Vous êtes maintenant dans une version de test de Linux Mint qui s'exécute entièrement depuis la mémoire vive (RAM).
 - **Rien n'est encore installé sur votre disque dur.** Vous pouvez naviguer sur Internet et tester le matériel.
 - **Notification réseau :** Une petite bulle en haut à droite confirmera votre connexion : _"Vous êtes maintenant connecté au réseau filaire 1"_ (Wired connection 1).
 ---
 ## La session Live : Tests et Configuration
 Avant de lancer l'installation définitive, vous devez configurer votre environnement de test pour qu'il soit confortable.
 ### Mettre le clavier en français (AZERTY)
 Par défaut, la session Live démarre souvent en anglais (QWERTY). Pour corriger cela rapidement sans naviguer dans les menus :
 1. Ouvrez un **Terminal** (icône d'écran noir en bas à gauche, ou raccourci `Ctrl + Alt + T`).
 2. Utilisez l'astuce de la **complétion automatique** :
    - Tapez les premières lettres : `setx`
    - Appuyez sur la touche **Tab ⇆** : le terminal complète automatiquement le reste de la commande (`setxkbmap`).
    - Ajoutez un espace et les lettres `fr`.
 3. La commande finale doit être :
    ```Bash
    setxkbmap fr
    ```
 4. Appuyez sur **Entrée**. Votre clavier est maintenant en français. Vous pouvez fermer le terminal.
 > **Astuce Alpinux :** La touche **Tab ⇆** est votre meilleure amie sous Linux. Elle permet de compléter les noms de commandes ou de fichiers, évitant ainsi les erreurs de frappe.
 ---
 ### Vérifications indispensables
 Profitez de cette session "Live" pour vérifier que tout votre matériel est bien reconnu par Linux Mint **avant** d'installer :
 - **Affichage :** L'image est-elle nette et stable ? (Si l'écran semble "écrasé", les pilotes graphiques seront installés plus tard).
 - **Connexion Internet :** * Si vous avez branché un câble, vérifiez l'icône réseau en bas à droite.
    - Si vous êtes en Wi-Fi, cliquez sur l'icône réseau (deux flèches ou ondes) et connectez-vous au réseau local.
 - **Son :** Cliquez sur l'icône de haut-parleur et essayez de modifier le volume ; vous devriez entendre un "clic" de confirmation.
 - **Touchpad / Souris :** Les clics et le défilement fonctionnent-ils de manière fluide ?
 ---
 ### Pourquoi faire ces tests ?
 Si un élément majeur (comme le Wi-Fi) ne fonctionne pas du tout en session Live, il est préférable de demander l'aide d'un bénévole Alpinux avant de lancer l'installation. Dans 95 % des cas, il s'agit simplement d'un pilote propriétaire à activer, mais il vaut mieux le savoir dès maintenant.
 ---
 ## Démarrer l'installation
 Une fois que vous avez vérifié que votre matériel (Wi-Fi, son, affichage) fonctionne correctement en session Live, vous pouvez lancer l'installation définitive sur le disque dur.
 ### 1. Lancement
 Double-cliquez sur l'icône **"Install Linux Mint"** présente sur le bureau.
 ### 2. Bienvenue et Langue
 - Sélectionnez **Français** dans la colonne de gauche.
 - Cliquez sur **Continuer**.
 ### 3. Disposition du clavier
 C'est une étape cruciale pour éviter les erreurs de mot de passe plus tard.
 - Sélectionnez **Français** dans la liste de gauche.
 - À droite, l'association Alpinux recommande de choisir **Français (variante)** ou **Français (variante, AltGr morte)**.
 - **Le test indispensable :** Utilisez la zone de saisie en bas pour tester les touches spéciales : le chiffre `²` (en haut à gauche), l'arobase `@` et les accents.
 - Cliquez sur **Continuer**.
 ### 4. Codecs Multimédia
 Une case à cocher vous propose d'**"Installer les codecs multimédia"**.
 - **Conseil Alpinux :** **Cochez cette case.** * **Pourquoi ?** Ces logiciels (parfois propriétaires) sont indispensables pour lire vos fichiers MP4, écouter de la musique en MP3 ou regarder des vidéos sur certains sites web. Cela vous évitera d'avoir un système "muet" ou incapable de lire des vidéos après l'installation.
 - Cliquez sur **Continuer**.
 ---
 ### Le point technique : Pourquoi des codecs "non open source" ?
 Certains formats de fichiers (comme le MP3 ou le H.264) sont protégés par des brevets. Linux Mint respecte la philosophie du logiciel libre en ne les installant pas d'office, mais vous donne la liberté de les ajouter en un clic pour une expérience utilisateur complète ("out of the box").
 ---
 ## Création des partitions Linux
 Cette étape consiste à préparer le terrain sur votre disque dur. Puisque nous n'utilisons pas de multiboot, nous allons définir manuellement l'organisation de Linux Mint.
 ### 1. Choisir le mode personnalisé
 À l'écran "Type d'installation", sélectionnez l'option **"Autre chose"** puis cliquez sur **Continuer**.
 > 🚩 **Alerte Sécurité :** Si vous voyez plusieurs disques (`sda`, `sdb`, `nvme0n1`), ne prenez aucun risque et demandez l'aide d'un bénévole Alpinux pour identifier le bon support.
 ---
 ### 2. Préparer le disque
 - **Disque vierge :** Si le disque ne contient aucune donnée, cliquez sur **Nouvelle table de partition...** (choisissez **GPT** si vous êtes en UEFI, ou **MBR** si vous êtes en BIOS/Legacy).
 - **Nettoyage :** Si des partitions existent déjà (anciennes partitions Windows), vous pouvez les supprimer une par une avec le bouton **-** pour obtenir un grand espace "Espace libre" ou utilisez **Nouvelle table de partition...**
 ---
 ### 3. Créer les partitions
 Cliquez sur l'espace libre, puis sur le bouton **+** pour créer chaque partition selon votre mode de démarrage :
 #### A. Partitions système obligatoires
 |Mode de boot|Type de partition|Taille|Utilisation / Point de montage|
 |---|---|---|---|
 |**Si UEFI**|Partition système **EFI**|200 à 500 Mo|(Indispensable pour démarrer)|
 |**Si BIOS**|Zone réservée pour le chargeur d'amorçage BIOS|500 Mo|(Optionnel, mais recommandé)|
 #### B. Partitions Linux (Dans tous les cas)
 1. **Le Swap (Espace d'échange) :**
    - **Taille :** Environ 1,5 fois votre RAM (ex: 8000 Mo pour 4 ou 8 Go de RAM).
    - **Utiliser comme :** Espace d'échange ("swap").
 2. **La Racine (Le système `/`) :**
    - **Taille :** 30 à 150 Go (selon la taille totale du disque).
    - **Utiliser comme :** Système de fichiers journalisé **ext4**.
    - **Point de montage :** `/`
 3. **Le Home (Vos documents `/home`) :**
    - **Taille :** Tout l'espace restant.
    - **Utiliser comme :** Système de fichiers journalisé **ext4**.
    - **Point de montage :** `/home`
 ---
 ### 4. Lancer l'écriture
 Une fois votre tableau de partitions prêt, vérifiez que le "Périphérique où sera installé le chargeur d'amorçage" est bien votre disque principal (ex: `/dev/sda` ou `/dev/nvme0n1`).
 1. Cliquez sur **Installer maintenant**.
 2. **EFI (éventuel) :** Si un message vous avertit sur l'absence ou la configuration de l'EFI, lisez-le attentivement mais cliquez généralement sur **Continuer**.
 3. **Confirmation :** Un dernier avertissement récapitule les changements. **Attention :** après avoir cliqué sur **Continuer**, toutes les données précédentes sur ces partitions seront définitivement effacées.
 ---
 > [!info] Pourquoi séparer le `/home` ?
 >
 >L'association Alpinux recommande cette méthode car elle sépare vos fichiers personnels (documents, photos, réglages) du système. Si vous devez réinstaller Linux plus tard, vous pourrez formater la racine (`/`) sans toucher à vos données personnelles (`/home`).
 Voici une version plus professionnelle et sécurisante pour la phase finale de l'installation. J'ai ajouté des précisions sur le choix des noms et sur la procédure physique de retrait de la clé.
 ---
 ## Configurer le compte utilisateur
 Pendant que le système commence à copier les fichiers en arrière-plan, vous devez créer le compte principal (administrateur) de l'ordinateur.
 ### 1. Informations d'identité
 - **Votre nom :** Saisissez le nom complet de l'utilisateur (ex: _Jean Dupont_).
 - **Nom de votre ordinateur :** Choisissez un nom simple pour identifier le PC sur le réseau (ex: _portable-jean_).
 - **Nom d'utilisateur :** C'est l'identifiant pour la session (en minuscules, sans espace ni accent, ex: _jean_).
 ### 2. Sécurité et Mot de passe
 - **Mot de passe :** Pour les besoins de l'Install Party, nous utilisons le mot de passe temporaire : `alpinux73`.
 - **Option de connexion :** * Il est fortement recommandé de cocher **"Demander mon mot de passe pour ouvrir une session"** pour garantir la sécurité de vos données.
    - L'option "Chiffrer mon dossier personnel" est disponible, mais attention : en cas d'oubli du mot de passe, vos données seront définitivement irrécupérables.
 ---
 ##  Finalisation et Redémarrage
 ### 1. Patience...
 Le processus d'installation peut prendre entre 10 et 30 minutes selon la vitesse de votre disque dur et de votre connexion internet. Linux Mint en profite pour télécharger les dernières mises à jour de sécurité et les packs de langue française.
 ### 2. Le signal de fin
 Une fois l'installation terminée, une fenêtre s'affiche : **"Installation terminée"**. Cliquez sur le bouton **Redémarrer maintenant**.
 ### 3. Retrait de la clé USB (Étape cruciale)
 Ne retirez pas la clé USB tout de suite !
 1. L'écran va devenir noir ou afficher un message textuel.
 2. Attendez de voir l'instruction : **"Please remove the installation medium, then press ENTER"**.
 3. À ce moment précis, **retirez la clé USB** de l'ordinateur.
 4. Appuyez sur la touche **Entrée**.
 ---
 > [!info] Pourquoi attendre l'instruction pour retirer la clé ?
 >
 >Si vous retirez la clé trop tôt, le système risque de ne pas finaliser l'écriture des fichiers de démarrage (GRUB), ce qui pourrait empêcher l'ordinateur de démarrer correctement sur Linux Mint.
 Voici une version enrichie et clarifiée de la section post-installation. J'ai ajouté des explications sur l'utilité réelle de ces actions pour un utilisateur au quotidien.
 ---
 ##  Opérations de post-installation
 Le système est installé, mais quelques réglages sont nécessaires pour le rendre parfaitement fonctionnel et agréable à utiliser.
 ### 1. Le Script de post-installation Alpinux
 Pour automatiser les tâches répétitives, l'association met à disposition un script. Il permet de configurer en une seule ligne tout ce qui manque souvent après une installation standard.
 **Procédure :**
 1. Ouvrez un **Terminal** (`Ctrl + Alt + T`).
 2. Copiez et collez la commande suivante (attention, cette adresse est spécifique au réseau local de l'Install Party) :
    ```Bash
    wget -q -O - http://10.0.0.1/install.sh | sudo bash
    ```
 3. Saisissez votre mot de passe (`alpinux73`) quand il est demandé (les caractères ne s'affichent pas, c'est normal).
 ---
 ### 2. Que fait ce script exactement ?
 Le script Alpinux optimise votre Mint pour un usage immédiat :
 - **Logithèque enrichie :** Installation de polices Microsoft (essentiel pour la compatibilité des documents Word/Excel), d'outils de gravure, de logiciels de webcam et d'un gestionnaire de mots de passe.
 - **Confort matériel :** Installation de `numlockx` pour gérer le pavé numérique dès le démarrage.
 - **Sérénité et Sécurité :**
    - **Mises à jour automatiques :** Active la recherche et l'installation des correctifs de sécurité sans intervention de votre part.
    - **Packs de langue :** Télécharge les traductions manquantes pour que tous vos logiciels (LibreOffice, Firefox, etc.) soient intégralement en français.
 ---
 ### 3. Activation manuelle du pavé numérique
 Bien que le script installe l'outil nécessaire, vous devez parfois confirmer l'activation visuellement :
 1. Ouvrez le menu **Paramètres du système**.
 2. Allez dans la section **Fenêtre de connexion**.
 3. Dans l'onglet **Paramètres**, cochez la case **"Activer le verrouillage numérique"**.
    > **Note :** Désormais, votre pavé numérique sera actif dès que vous devrez saisir votre mot de passe au démarrage.
 ---
 ### Pourquoi installer les "Polices Microsoft" ?
 Par défaut, Linux utilise des polices libres. Si vous recevez un document rédigé en _Arial_ ou _Times New Roman_, la mise en page pourrait être décalée sans ces polices officielles. Le script Alpinux règle ce problème pour vous afin de garantir une parfaite compatibilité avec vos collègues ou votre administration.
 ---
 ### Finaliser la configuration linguistique
 Même si vous avez choisi le français lors de l'installation, certains composants du système ou logiciels tiers peuvent rester en anglais. Il est nécessaire de valider ces paramètres pour harmoniser l'ensemble.
 #### Procédure de mise en conformité :
 1. **Ouvrir l'outil dédié :** Cliquez sur le menu **Démarrer**, tapez "Langues" et ouvrez l'application **Langues** (ou via _Paramètres système_ > _Langues_).
 2. **Vérifier les réglages :** Dans la fenêtre qui s'ouvre, assurez-vous que le **Français, France UTF-8** est sélectionné pour les trois options principales :
    - **Langue** (L'interface des menus)
    - **Région** (Les formats locaux)
    - **Format de l'heure** (L'affichage 24h)
 3. **Installer les paquets manquants :** Si un bouton **"Installer / Supprimer des langues"** affiche un symbole d'avertissement ou si une barre de progression indique que des paquets sont manquants, cliquez dessus pour finaliser le téléchargement du support français.
 4. **Appliquer à l'ensemble du système :**
    > **Étape cruciale :** Cliquez sur le bouton **"Appliquer à tout le système"** en bas de la fenêtre. Cela permet d'appliquer le français dès l'écran de connexion (celui où vous tapez votre mot de passe).
 5. **Prise en compte :** Fermez la fenêtre.
 ---
 Contrairement à d'autres réglages, le changement de langue nécessite une fermeture de session ou un redémarrage pour que toutes les applications en cours (le bureau Cinnamon, le gestionnaire de fichiers, etc.) rechargent les nouveaux fichiers de traduction.
 Si après cette étape certains logiciels (comme Firefox ou LibreOffice) restent encore en anglais, ne vous inquiétez pas : c'est l'objet de la section suivante qui traite des vérifications spécifiques par application.
 ### Configuration linguistique de Firefox
 Il arrive que Firefox conserve une interface en anglais ou propose des sites Web en version internationale. Voici comment harmoniser votre navigateur.
 #### 1. Changer la langue de l'interface (menus et messages)
 Si les menus de Firefox (ex: _File, Edit, View_) ne sont pas en français :
 1. Cliquez sur le **menu "hamburger"** (les trois lignes horizontales ≡) en haut à droite et choisissez **Paramètres** (ou _Settings_).
 2. Dans l'onglet **Général**, descendez jusqu'à la section **Langue**.
 3. Sélectionnez **Français** dans le menu déroulant. Si le français n'apparaît pas, cliquez sur "Chercher d'autres langues..." pour le télécharger et l'installer.
 4. Redémarrez Firefox si le navigateur vous le demande.
 #### 2. Configurer la langue préférée pour les sites Web
 Certains sites détectent votre langue via les réglages de votre navigateur. Pour éviter de voir Wikipédia ou Google s'afficher en anglais :
 1. Toujours dans **Paramètres** > **Général** > **Langue**.
 2. Juste en dessous du réglage précédent, repérez : **"Choisir la langue préférée pour l'affichage des pages"**. Cliquez sur le bouton **Choisir...**.
 3. Assurez-vous que **Français [fr]** est en haut de la liste.
 4. Si besoin, utilisez le bouton "Sélectionner une langue à ajouter" pour trouver le français et cliquez sur **Ajouter**, puis montez-la en première position.
 5. Validez avec **OK**.
 ---
 ###  Vérification technique (Outil Alpinux)
 Pour confirmer que votre navigateur se présente correctement aux serveurs Web, vous pouvez effectuer un test réel :
 1. Visitez le site [https://ip.abonnel.fr](https://ip.abonnel.fr).
 2. Descendez jusqu'à la section **"D'autres informations techniques"**.
 3. Regardez la ligne **"Langues préférées"** (ou _Accept-Language_).
    - **Correct :** Vous devez voir `fr`, `fr-FR` ou `fr-fr` en première position.
    - **Incorrect :** Si `en` ou `en-US` apparaît en premier, reprenez l'étape 2 ci-dessus.
 ### Correction orthographique dans Firefox
 Il ne suffit pas que l'interface soit en français ; il faut aussi que Firefox sache souligner vos fautes de frappe lorsque vous rédigez un texte en ligne.
 #### 1. Test de détection
 Avant toute chose, vérifiez si le dictionnaire est déjà actif :
 1. Faites un clic droit dans n'importe quel champ de texte (par exemple, la barre de recherche ou un champ de commentaire).
 2. Vérifiez si l'option **"Vérifier l'orthographe"** est cochée.
 3. Si elle est cochée mais que vos fautes ne sont pas soulignées, le dictionnaire français est probablement manquant.
 #### 2 . Méthode 1 : Installer le dictionnaire français
 Si le français n'est pas proposé dans le menu "Langues" lors d'un clic droit :
 1. Faites un clic droit dans un champ de texte.
 2. Allez sur **Langues** > **Ajouter des dictionnaires...**.
 3. Une page officielle de Firefox s'ouvre. Recherchez **"Français"** dans la liste.
 4. Cliquez sur **"Installer le dictionnaire"** (choisissez de préférence le dictionnaire "Moderne" ou "Réforme 1990").
 5. Cliquez sur le bouton bleu **"+ Ajouter à Firefox"**, puis validez l'installation.
 #### 3. Méthode 2 : Via la page des modules complémentaires (Add-ons)
 Si vous préférez une interface graphique sans passer par un champ de texte :
 1. Cliquez sur le **menu ≡** (en haut à droite) et choisissez **Extensions et thèmes**.
 2. Dans la barre de recherche en haut, tapez : **"Dictionnaire français"**.
 3. Cherchez celui proposé par "LanguageTeam" (souvent nommé _Dictionnaires français_).
 4. Cliquez sur **Ajouter à Firefox**.
 #### 4. Validation finale
 1. Retournez dans un champ de texte.
 2. Faites un clic droit > **Langues**.
 3. Assurez-vous que **"Français"** est bien sélectionné.
 4. Tapez un mot faux (ex: _bonjoure_) : il doit se souligner en rouge.
 ---
 ### Vérification linguistique dans LibreOffice
 Il est fréquent que LibreOffice nécessite une petite validation pour activer ses menus en français et, surtout, son correcteur orthographique.
 #### 1. Vérifier l'interface (menus et icônes)
 Ouvrez **LibreOffice Writer** (le traitement de texte).
 - Si les menus s'affichent en anglais (_File, Edit, View_), allez dans : **Tools** > **Options** > **Language Settings** > **Languages**.
 - Dans **User Interface**, choisissez **French (France)**.
 #### 2. Activer le correcteur orthographique
 Pour éviter les fautes de frappe, le dictionnaire français doit être sélectionné par défaut :
 1. Toujours dans le menu **Outils** > **Options** > **Paramètres linguistiques** > **Langues**.
 2. Dans la section **Langues par défaut pour les documents**, vérifiez que "Occidental" est réglé sur **Français (France)**.
 3. **Le détail qui compte :** Assurez-vous qu'une petite icône bleue avec les lettres **"ABC"** et une coche est présente devant "Français (France)". Cela confirme que le dictionnaire est bien installé.
 #### 3. Que faire si le dictionnaire est absent ?
 Si vous ne voyez pas l'icône "ABC" ou si le français n'est pas proposé :
 - Fermez LibreOffice.
 - Relancez le script de post-installation Alpinux ou allez dans le menu **Démarrer** > **Paramètres** > **Langues** et cliquez sur **"Installer/Supprimer des langues"**. Cela complétera l'installation des paquets `libreoffice-l10n-fr` et `hunspell-fr`.
 ---
 Une fois la configuration terminée, tapez un mot volontairement mal orthographié dans Writer. S'il se souligne en rouge, votre correcteur fonctionne ! Appuyez sur **F7** pour lancer la vérification complète de votre document.
 ---
 ### Gestion des sauvegardes avec Timeshift
 **Timeshift** est un utilitaire qui crée des "instantanés" (des points de restauration) de votre système. En cas de mauvaise manipulation ou de mise à jour qui se passe mal, il vous permet de revenir en arrière en quelques clics.
 #### Pourquoi modifier ses réglages ?
 Par défaut, Timeshift peut être configuré pour créer des sauvegardes quotidiennes ou horaires. Sur un disque dur de petite taille (moins de 128 Go), cela peut rapidement consommer tout votre espace disque et bloquer l'ordinateur.
 #### Procédure recommandée par Alpinux :
 1. Ouvrez **Timeshift** depuis le menu Démarrer (votre mot de passe sera demandé).
 2. Si l'assistant de configuration s'ouvre, choisissez **RSYNC** et cliquez sur **Suivant**.
 3. À l'étape **"Sélectionner les niveaux d'instantanés"** :
    - **Décochez toutes les cases** (Quotidien, Horaire, Hebdomadaire, etc.).
    - _Pourquoi ?_ Cela évite que le disque ne se remplisse de façon imprévisible.
 4. Un message d'avertissement peut apparaître pour vous dire que le système n'est plus protégé : cliquez sur **OK / Ignorer**.
 5. Cliquez sur **Terminer**.
 ### Tests matériels finaux (Check-list)
 Avant de considérer l'installation comme terminée, il est crucial de tester chaque composant physique de l'ordinateur. Cela permet de détecter d'éventuels pilotes manquants ou des réglages à affiner.
 #### 1. Système Audio
 - **Haut-parleurs :** Allez dans _Paramètres système_ > _Son_ et cliquez sur "Tester le son".
 - **Casque :** Branchez des écouteurs ou un casque filaire. Vérifiez que le son bascule automatiquement des haut-parleurs vers le casque.
 - **Microphone :** Ouvrez l'application "Magnétophone" ou vérifiez la barre de volume d'entrée dans les paramètres sonores en parlant.
 #### 2. Connectivité sans fil
 - **Wi-Fi :** Débranchez le câble Ethernet. Connectez-vous à un réseau Wi-Fi, ouvrez Firefox et chargez une page Web pour confirmer que le flux de données est stable.
 - **Bluetooth :** Cliquez sur l'icône Bluetooth en bas à droite. Essayez de jumeler un appareil (souris, casque ou smartphone). _C'est le test idéal pour vérifier si la puce Bluetooth nécessite un micrologiciel (firmware) spécifique._
 #### 3. Multimédia et Périphériques
 - **Webcam :** Lancez l'application **Cheese** ou **Hypnotix**. L'image est-elle fluide ?
 - **Lecteur DVD / USB :** Si l'ordinateur possède un lecteur optique, insérez un DVD pour tester la lecture. Testez également les différents ports USB de la machine avec une clé de données.
 - **Écran externe :** Si l'utilisateur a un second écran (HDMI/VGA), branchez-le pour vérifier que le double affichage est bien géré.
 #### 4. Matériel spécifique de l'utilisateur
 > **Le conseil Alpinux :** Demandez toujours à l'utilisateur s'il a apporté un périphérique particulier (imprimante portable, tablette graphique, scanner). Il est beaucoup plus simple de configurer ces éléments avec l'aide des bénévoles lors de l'Install Party.
 ### Restaurer son profil Firefox sur Linux Mint
 Sur Linux Mint, Firefox stocke ses données dans un dossier caché. La méthode la plus propre consiste à remplacer le contenu du nouveau profil par l'ancien.
 #### 1. Préparer le terrain
 1. Lancez Firefox une première fois sur Linux Mint, puis **refermez-le immédiatement**. Cela permet au système de créer l'arborescence de dossiers nécessaire.
 2. Branchez votre support de sauvegarde (clé USB ou disque externe).
 #### 2. Localiser le dossier de destination
 Ouvrez votre **Dossier personnel** (le gestionnaire de fichiers Nemo) et suivez ces étapes :
 1. Affichez les dossiers cachés en appuyant sur **`Ctrl + H`**.
 2. Naviguez vers le chemin suivant : `.mozilla` > `firefox`.
    > _Note : Si vous ne voyez pas `.mozilla`, vérifiez que vous avez bien lancé Firefox au moins une fois._
 #### 3. Restaurer les données
 Il existe deux méthodes selon votre aisance, la "Méthode Express" est la plus recommandée :
 **Méthode Express (Remplacement total) :**
 1. Dans le dossier `.mozilla/firefox` de votre ordinateur, supprimez tout le contenu existant.
 2. Copiez l'intégralité de votre sauvegarde (votre dossier `xxxx.default-release` **ET** les fichiers `profiles.ini` et `installs.ini`) et collez-les ici.
 3. Relancez Firefox. Vos extensions, onglets et mots de passe devraient apparaître instantanément.
 **Méthode Sélective (Si Firefox ne démarre pas) :**
 Si après la méthode express Firefox affiche une erreur de profil, procédez ainsi :
 1. Ouvrez le nouveau dossier de profil créé par Linux (ex: `yyyyy.default-release`).
 2. Ouvrez votre dossier de sauvegarde (ex: `xxxx.default-release`).
 3. Copiez tout le **contenu** du dossier de sauvegarde et collez-le **à l'intérieur** du nouveau dossier de profil sur Linux, en acceptant d'écraser les fichiers existants.
 ### Vérification après restauration
 Une fois Firefox ouvert, vérifiez deux points :
 - **La synchronisation :** Si vous utilisiez un compte Firefox Sync, il se peut que vous deviez vous reconnecter pour réactiver la synchronisation en temps réel.
 - **Les DRM :** Pour regarder Netflix ou Prime Video, allez dans `Paramètres` > recherchez "DRM" et assurez-vous que la case "Lire le contenu contrôlé par DRM" est bien cochée.
 ## Conditions d'utilisation de ce document
 ### Remerciements
 Nous tenons à exprimer notre gratitude envers les bénévoles et les membres des bureaux successifs qui ont contribué à améliorer et à faire évoluer les Install Party depuis 1999. Merci pour leurs précieuses assistances.
 ### Licence
 La paternité de ce document doit être **“Alpinux, Le LUG de Savoie”**. L'URL référente doit être https://gitea.alpinux.org/akml/alpinux.installparty/raw/branch/master/guide_d_installation_linux_mint_depuis_windows.md
 Cet document est mis à disposition sous les termes de la licence **CC BY-SA 4.0**, également connue sous le nom de **Attribution - Partage dans les Mêmes Conditions 4.0 International**. Il est important de noter que certains contenus présents dans ce document, tels que les designs, textes, graphiques, images, vidéos, informations, logos, icônes-boutons, logiciels, fichiers audio, et autres, sont protégés par le droit d'auteur, la protection des marques commerciales déposées, d'autres lois et conditions d'utilisation spécifiques. La licence **CC BY-SA 4.0** ne peut pas prévaloir sur ces conditions de protection existantes.
 La licence sus mentionnée accorde uniquement des autorisations en vertu du droit d'auteur.
 Les marques déposées ou les noms propres sont utilisés dans ce document à titre d'exemple, dans un but de démonstration et à des fins pédagogiques exclusivement. Nous n'avons aucun lien ni affiliation avec ces marques, et leur utilisation dans ce document est soumise aux conditions d'utilisation spécifiques qui leur sont applicables.
 ### Responsabilité
 **Limitation de Responsabilité :** L'association Alpinux décline toute responsabilité quant à l'utilisation de ses services ou produits par les utilisateurs. Les utilisateurs reconnaissent qu'ils utilisent les services ou produits à leurs propres risques et périls.
 **Exonération de Responsabilité :** Alpinux ne sera en aucun cas tenue responsable des dommages directs, indirects, spéciaux, consécutifs ou accessoires, y compris, mais sans s'y limiter, les pertes de données, les pertes de bénéfices, les interruptions de service, les dommages matériels, les réclamations de tiers ou tout autre préjudice résultant de l'utilisation ou de l'incapacité à utiliser nos services ou produits.
 **Utilisation Conforme :** Les utilisateurs s'engagent à utiliser nos services ou produits conformément aux lois applicables et aux présentes Conditions d'utilisation. L'entreprise ne peut être tenue responsable de toute utilisation illégale ou non conforme de ses services ou produits par les utilisateurs.
 **Mises à Jour et Modifications :** L'association se réserve le droit de mettre à jour, modifier ou interrompre ses services ou produits à tout moment, sans préavis. Elle ne peut être tenue responsable des conséquences de telles mises à jour, modifications ou interruptions.
 **Liens Externes :** Nos services ou produits peuvent contenir des liens vers des sites Web tiers. L'entreprise n'est pas responsable du contenu, de la sécurité ou de la confidentialité de ces sites Web tiers, et les utilisateurs sont invités à consulter les Conditions d'utilisation et les politiques de confidentialité de ces sites avant de les utiliser.
 **Indemnisation :** Les utilisateurs s'engagent à indemniser et à dégager de toute responsabilité Alpinux, ses instances dirigeantes, le bureau, les contractuels, bénévoles, employés et partenaires contre toute réclamation, action en justice, responsabilité, perte, coût ou dépense résultant de leur utilisation de nos services ou produits ou de toute violation des présentes Conditions d'utilisation.
 **Modification des Conditions :** Alpinux se réserve le droit de modifier les présentes **Conditions d'utilisation** à tout moment. Les utilisateurs sont tenus de consulter régulièrement les Conditions d'utilisation pour être informés des modifications éventuelles.
--- a/articles/2026/kobo-sideload-mode.md
+++ b/articles/2026/kobo-sideload-mode.md
@@ -0,0 +1,95 @@
 ---
 title: 'Kobo : Configurer votre liseuse Kobo en "Sideload Mode"'
 description: Ce mode permet d'utiliser votre liseuse sans créer de compte Rakuten Kobo, tout en optimisant l'interface et la confidentialité.
 tags: []
 date: 2026-02-26 18:53
 lastmod: 2026-02-26 18:55
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Kobo : Configurer votre liseuse Kobo en "Sideload Mode"
 Ce mode permet d'utiliser votre liseuse sans créer de compte Rakuten Kobo, tout en optimisant l'interface et la confidentialité.
 ### 1. Connexion de la liseuse
 Lorsque l'écran d'invitation à la connexion s'affiche sur votre Kobo, branchez-la à votre ordinateur via le port USB.
 > **Conseil :** Connectez le câble directement sur un port de l'ordinateur. Évitez les hubs USB ou les rallonges pour garantir une stabilité maximale lors du transfert de données.
 Une fois branchée, l'écran de la liseuse affichera **"Ordinateur détecté"**. Appuyez alors sur **Connecter**.
 ### 2. Accès aux fichiers système
 Sur votre ordinateur, un nouveau lecteur nommé **KOBOeReader** apparaît.
 1. Ouvrez le lecteur.
 2. Accédez au dossier masqué `.kobo` (activez l'affichage des éléments cachés sur votre système si nécessaire).
 3. Entrez ensuite dans le sous-dossier `Kobo`.
 > **Note :** Dans le dossier racine `.kobo`, vous trouverez également le fichier `Kobo Reader.sqlite`. Il s'agit de la base de données principale de votre appareil (historique, progression, etc.).
 ### 3. Modification de la configuration
 Le fichier à modifier est : `.kobo/Kobo/Kobo eReader.conf`. Ouvrez-le avec un éditeur de texte (type Notepad++ ou TextEdit).
 #### A. Désactiver les services superflus
 Ajoutez ou modifiez les lignes suivantes pour alléger l'interface :
 ```ini
 kobo_wishlist_enabled=False
 kobo_subscriptions_enabled=False
 kobo_redeem_enabled=False
 instapaper_enabled=False
 kobo_audiobooks_enabled=False
 ```
 #### B. Activer le "Sideload Mode" (Bypass du compte)
 Sous la section `[ApplicationPreferences]`, ajoutez :
 ```ini
 SideloadedMode=true
 ```
 _Vérifiez également la présence des paramètres régionaux suivants :_
 ```ini
 CurrentLocale=fr
 WifiRegulatoryDomain=FR
 is24HourClock=true
 ```
 #### C. Désactiver le tracking (Confidentialité)
 Sous la section `[FeatureSettings]`, ajoutez :
 ```ini
 DownloadDiagnostics=false
 UploadDiagnostics=false
 ```
 ### 4. Finalisation
 1. Enregistrez le fichier et éjectez proprement la liseuse de votre ordinateur.
 2. L'écran **"Bienvenue sur Kobo"** s'affiche. Cliquez sur **"C'est parti"**.
 3. Configurez le Wi-Fi si nécessaire, puis réglez la date et l'heure.
 4. Vous accédez maintenant directement à votre bibliothèque locale.
 ---
 **Astuce :** Pour maintenir votre appareil à jour, rendez-vous dans le menu **Plus** > **Paramètres** > **Informations techniques** et cliquez sur **Vérifier les mises à jour**.
--- a/articles/2026/les
+++ b/articles/2026/les
@@ -0,0 +1,167 @@
 ---
 title: 'Pourquoi le silence au bout du fil est votre pire ennemi : Les dangers cachés des appels "fantômes"'
 description: Silence au bout du fil ? Attention, votre voix est une cible. Ce guide complet décrypte les techniques des cybercriminels (Ping Call, Robocalls, fraude au CEO) et vous donne les réflexes de survie numérique pour bloquer les arnaques sur iPhone et Android.
 tags: []
 date: 2026-02-22 17:12
 lastmod: 2026-02-23 01:52
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Pourquoi le silence au bout du fil est votre pire ennemi : Les dangers cachés des appels "fantômes"
 ## 1. Introduction : Le mystère du "Allô" sans réponse
 C’est une scène devenue universelle : votre téléphone vibre, vous décrochez, vous prononcez un "Allô ?" interrogateur, et... **rien**. Un silence pesant de quelques secondes, puis la ligne raccroche. Si vous pensiez à un simple bug technique ou à une erreur de réseau, détrompez-vous.
 Ce silence n'est pas fortuit ; c'est une **phase d'approche tactique**. En réalité, votre simple réponse vocale est une donnée précieuse que les cybercriminels cherchent à capturer. Ce n'est pas seulement un appel manqué, c'est le point d'entrée d'une attaque sophistiquée. En tant qu'expert en cyber-sûreté, je vous explique comment votre voix est devenue une cible et comment transformer votre inquiétude en une vigilance proactive.
 ---
 ## 2. La « Preuve de Vie Numérique » : Valider votre ligne active
 Le premier objectif des appels automatisés (_robocalls_) est d'assurer une mise à jour de base de données en temps réel. Des automates d'appel (ou _dialers_) composent des milliers de numéros chaque jour avec une mission unique : **identifier les lignes réellement exploitables.**
 ### Un diagnostic de réactivité immédiat
 Dès l'instant où vous décrochez ou prononcez un mot, vous confirmez que votre numéro est rattaché à un utilisateur humain. Ce simple geste déclenche trois conséquences majeures :
 - **Validation instantanée :** Vous sortez de l'anonymat pour devenir une « ligne confirmée ».
 - **Explosion de la valeur marchande :** Un numéro validé se revend à prix d'or sur les marchés cybercriminels. Vous passez du statut de contact aléatoire à celui de **cible qualifiée** pour des campagnes de phishing, de démarchage agressif ou d'extorsion.
 - **Le cercle vicieux du spam :** En répondant, vous augmentez votre « score de réactivité ». Cette donnée, partagée entre réseaux de fraudeurs, déclenche mécaniquement une recrudescence d'appels dans les jours suivants.
 ### Une réalité documentée par les régulateurs
 Ce mécanisme de détection n'est pas une théorie, mais une pratique identifiée par les autorités de régulation des télécoms :
 > **L'analyse de la FCC :** Dans ses rapports sur les _robocalls_, la Federal Communications Commission (États-Unis) souligne que décrocher un appel inconnu suffit à valider votre présence dans les fichiers de fraudeurs.
 > 
 > _Source : [FCC - Stop Unwanted Robocalls](https://www.fcc.gov/consumers/guides/stop-unwanted-robocalls-and-texts)_
 En somme, la revente de bases de données de numéros « chauds » (actifs) constitue aujourd'hui un pilier de l'économie souterraine. Le concept de **Lead Scoring**, habituel en marketing légal, est ici détourné par les cybercriminels pour optimiser la rentabilité de leurs attaques.
 ---
 Voici une version retravaillée pour gagner en impact, en fluidité et en autorité. J'ai renforcé le ton "cyber-vigilance" tout en conservant une structure claire et percutante.
 ---
 ## 3. Le Clonage Vocal : Votre identité à la merci d'un échantillon de 3 secondes
 Votre voix n'est plus un simple trait de personnalité : c'est une **donnée biométrique vulnérable**. Avec l'essor de l'IA générative, la frontière entre l'humain et la machine s'est volatilisée. Aujourd'hui, un échantillon sonore dérisoire suffit à bâtir un "double numérique" capable de tromper vos proches comme vos collaborateurs.
 > **« Quelques secondes d'enregistrement permettent à une IA de capturer votre timbre, votre souffle et vos intonations, transformant votre identité en une redoutable arme d'ingénierie sociale. »**
 Le risque, validé par les experts en cyber-assurance, se traduit déjà par des préjudices financiers et émotionnels massifs :
 | **Scénario**           | **Mécanisme d'attaque**                                               | **Conséquences**                                    |
 | ---------------------- | --------------------------------------------------------------------- | --------------------------------------------------- |
 | **Fraude au CEO**      | Usurpation vocale d'un dirigeant (cas certifié par **Euler Hermes**). | **220 000 €** détournés en un seul appel.           |
 | **Kidnapping Virtuel** | Simulation de la voix d'un enfant ou d'un proche en détresse.         | Extorsion d'urgence et traumatismes psychologiques. |
 ### L'illusion parfaite : Le cas Euler Hermes
 L'affaire des 220 000 € fait aujourd'hui figure de cas d'école. L'assureur a révélé que l'IA avait reproduit avec une précision chirurgicale l'accent germanique et les nuances mélodiques du PDG. Face à une telle perfection technique, l'oreille humaine est démunie : la fraude est devenue, par nature, indécelable pour un employé non averti.
 ---
 ### Le nouveau réflexe de survie : La « Défense du Silence »
 Face à cette menace, nos codes de politesse deviennent nos failles de sécurité. Pour neutraliser les tentatives de capture vocale, adoptez ces deux réflexes face à un numéro inconnu :
 #### 1. Pratiquez le silence initial (3 à 5 secondes)
 Au décrochage d'un numéro suspect, **ne dites rien**.
 - **L'intérêt :** Les systèmes de numérotation automatique et les serveurs d'IA attendent un signal sonore pour s'activer. Si vous restez muet, le système considère souvent la ligne comme "morte" et coupe la communication sans que votre voix n'ait été enregistrée.
 #### 2. Évitez le piège du « Oui »
 Une technique classique consiste à poser une question anodine : _« Vous m'entendez bien ? »_.
 - **Le danger :** Un simple « Oui » peut être découpé et utilisé comme une signature vocale pour valider des contrats ou des transactions à votre insu.
 - **La parade :** Répondez systématiquement par une question : _« À qui ai-je l'honneur ? »_ ou _« Quel est l'objet de votre appel ? »_.
 ---
 ### L'impolitesse est une mesure de sécurité
 En matière de cybersécurité vocale, la règle d'or est la suivante : **plus l'urgence semble réelle, plus vous devez ralentir.**
 1. **Doutez** : L'émotion est le levier préféré des fraudeurs.
 2. **Vérifiez** : Raccrochez et rappelez le contact via un canal officiel ou un numéro enregistré.
 3. **Sanctuarisez** : Traitez votre signature vocale avec la même vigilance que votre code de carte bancaire.
 ---
 ### La Règle d'Or : Le test du silence
 Le robot attend souvent un **déclencheur sonore** (votre voix) pour lancer l'enregistrement ou transférer l'appel à un escroc humain. Si vous restez muet pendant 3 à 5 secondes après avoir décroché, le système raccrochera souvent automatiquement, vous marquant comme "inactif".
 ---
 ## 4. Le "Ping Call" : Le piège psychologique du rappel
 Une variante classique mais toujours efficace est le **"Ping Call"** (ou _Wangiri_). L'appel ne dure qu'une ou deux sonneries, provenant souvent de numéros internationaux (+216, +44, +225, etc.).
 Ici, les fraudeurs misent sur votre curiosité ou votre peur d'avoir manqué un appel important. Le piège réside dans le **rappel** : ces numéros sont lourdement surtaxés. Pour maximiser les profits, des messages pré-enregistrés ("Votre livraison est bloquée", "Service client, ne quittez pas") sont utilisés pour vous maintenir en ligne et gonfler votre facture téléphonique de plusieurs dizaines d'euros.
 ---
 ## 5. Guide Pratique : Déployez vos boucliers numériques
 Ne subissez plus ces appels. Utilisez les outils natifs de votre smartphone pour filtrer les menaces.
 ### Sur Android (Filtrage intelligent)
 1. Ouvrez l'application **Téléphone** > **Paramètres** (les trois points).
 2. Activez **"ID appelant et protection contre le spam"**.
 3. Cochez l'option **"Filtrer les appels indésirables"**. Votre téléphone bloquera ces appels silencieusement sans même vous déranger.
 ### Sur iPhone (L'application Begone)
 Apple autorise des applications tierces à agir comme des pare-feu. L'application **Begone** (gratuite) est une référence :
 1. Téléchargez Begone sur l'App Store.
 2. Allez dans **Réglages** > **Téléphone** > **Blocage d'appels**.
 3. Activez les **listes communautaires** pour bloquer automatiquement les numéros déjà signalés par des milliers d'utilisateurs.
 ---
 ## 6. Le réflexe de vérification : Google avant le rappel
 En cas de doute, la curiosité doit vous mener vers un moteur de recherche, jamais vers la touche "Rappeler".
 - **Copiez le numéro** dans Google associé aux mots-clés **"arnaque"** ou **"qui est ce numéro"**.
 - Des plateformes comme _tellows_ ou _annuaire-inverse_ listent les expériences de milliers de victimes en temps réel.
 - **Rappel essentiel :** Un service officiel (banque, administration, livreur) laissera systématiquement un message vocal ou un SMS clair en cas d'urgence.
 ---
 ## 7. Vers une hygiène numérique proactive
 Le silence face à l'inconnu n'est pas une impolitesse, c'est une mesure de protection vitale. Dans un monde où votre identité vocale peut être détournée, le "Allô" automatique doit devenir un réflexe du passé.
 En adoptant ces quelques gestes simples, vous sécurisez non seulement votre facture téléphonique, mais aussi l'intégrité de votre identité numérique. **Votre silence est votre meilleure défense ; apprenez à l'utiliser.**
--- a/articles/2026/maitriser_le_forwarding_avec_NPMplus_et_Apache.md
+++ b/articles/2026/maitriser_le_forwarding_avec_NPMplus_et_Apache.md
@@ -0,0 +1,75 @@
 ---
 title: Maîtriser le Forwarding avec NPMplus et Apache
 description: Marre de voir l'IP de votre reverse proxy dans vos logs Apache ? Découvrez comment configurer NPMplus et le module mod_remoteip pour restaurer la visibilité de l'IP réelle de vos visiteurs. Un guide détaillé pour DevOps incluant la gestion du header X-Forwarded-For et les bonnes pratiques de sécurité.
 tags: []
 date: 2026-03-10 07:43
 lastmod: 2026-03-10 07:51
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Maîtriser le Forwarding avec NPMplus et Apache
 **Par Cédrix** | _Date d'édition : 10 mars 2026_
 Dans l'architecture moderne des micro-services, le **Reverse Proxy** est devenu la pierre angulaire de la sécurité et de la flexibilité. Que ce soit pour la terminaison SSL, le load-balancing ou la gestion des noms de domaine, des outils comme **NPMplus** (Nginx Proxy Manager Plus) facilitent grandement la vie des DevOps.
 Pourtant, un problème récurrent hante les administrateurs : **la disparition de l'adresse IP réelle du client dans les logs applicatifs.** Pourquoi votre serveur Apache ne voit-il que l'IP locale du proxy ? Comment restaurer la visibilité sans briser la chaîne de confiance ? Plongée au cœur des headers HTTP.
 ## Le Problème : L'illusion de la connexion directe
 Lorsqu'un utilisateur consulte votre site, il ne parle pas directement à Apache. Il établit une connexion TCP avec **NPMplus**. Pour Apache, le "client", c'est le proxy.
 > **Le risque :** Si votre Apache croit que tout le trafic provient de `192.168.100.95` (votre proxy), vos outils d'analyse (Matomo, AWStats) sont aveugles, et vos outils de sécurité (Fail2Ban) risquent de bannir votre propre infrastructure au premier faux pas d'un utilisateur.
 ## La Solution : Le Header `X-Forwarded-For`
 Pour pallier cela, le reverse proxy doit devenir un "messager". Avant de transmettre la requête à Apache, il ajoute une étiquette à l'enveloppe HTTP : le header `X-Forwarded-For` (XFF).
 ### 1. La configuration du messager (NPMplus)
 NPMplus utilise Nginx sous le capot. Pour qu'il transmette l'identité du visiteur, il doit injecter ces directives dans la configuration du bloc `location` :
 ```Nginx
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 ```
 _$proxy_add_x_forwarded_for_ est crucial car il conserve la trace de tous les proxys traversés (si l'utilisateur passe déjà par un VPN ou un CDN comme Cloudflare).
 ## Le Récepteur : Configurer Apache avec `mod_remoteip`
 Côté Apache, il ne suffit pas de recevoir le header ; il faut lui donner une valeur légale. C'est ici qu'intervient le module **`mod_remoteip`**.
 ### Étape A : Établir la relation de confiance
 Apache refuse par défaut de croire n'importe quel header XFF (car n'importe quel pirate pourrait injecter une fausse IP). Vous devez définir une liste blanche d'IP de confiance.
 Dans votre configuration (`/etc/apache2/conf-available/remoteip.conf`) :
 ```Apache
 RemoteIPHeader X-Forwarded-For
 RemoteIPInternalProxy 192.168.100.95
 ```
 **Point d'attention :** Une simple erreur de frappe ici, et Apache ignorera le header, revenant à l'affichage de l'IP du proxy.
 ### Étape B : Réécrire le format de journalisation
 Par défaut, Apache utilise la variable `%h` (hostname) dans ses logs. Pour afficher l'IP "extraite" par le module remoteip, il faut passer à la variable **`%a`** (peer IP address).
 Modifiez votre `LogFormat` dans `apache2.conf` :
 Apache
 ```
 # Remplacez %h par %a
 LogFormat "%a %l %u %t \"%r\" %>s %b" combined
 ```
 ## Vérification finale
 Un simple `tail -f /var/log/apache2/access.log` vous confirmera immédiatement si le réglage est opérationnel. Si vous voyez une IP publique au lieu de votre IP locale, vous avez réussi votre mise en production !
--- a/articles/2026/maitriser_tcp_analyse_wireshark_flux_pertes_congestion_securite.md
+++ b/articles/2026/maitriser_tcp_analyse_wireshark_flux_pertes_congestion_securite.md
@@ -0,0 +1,747 @@
 ---
 title: "Maîtriser TCP par l'Analyse Wireshark : Flux, Pertes et Congestion"
 description:
 tags: []
 date: 2026-03-08 13:35
 lastmod: 2026-03-08 14:35
 type:
  - article
 category:
  - "[[Guide]]"
 status: terminé
 ---
 # Maîtriser TCP par l'Analyse Wireshark : Flux, Pertes et Congestion
 Le protocole **TCP (Transmission Control Protocol)** est le pilier de la fiabilité sur Internet (Web, SSH, Bases de données). Contrairement aux idées reçues, TCP ne compte pas des paquets, mais des **octets**. Comprendre cette nuance est la clé pour interpréter les comportements complexes : retransmissions, fenêtres de réception et fermetures de connexion.
 ## La Fiabilité de TCP — Séquençage et Acquittement
 Le protocole **TCP (Transmission Control Protocol)** est souvent comparé à une conversation téléphonique polie : on ne se contente pas de parler, on s'assure que l'autre a bien entendu et compris chaque segment avant de poursuivre. Contrairement à UDP, TCP garantit que les données arrivent dans l'ordre et sans erreurs.
 ---
 ### 1. Les Fondations : SEQ et ACK
 TCP ne voit pas les données comme des fichiers distincts, mais comme un **flux continu d'octets**. Pour s'y retrouver dans ce flux, il utilise deux compteurs essentiels logés dans l'en-tête du segment :
 #### **A. Le Numéro de Séquence (SEQ)**
 Le champ **SEQ** indique la position du premier octet de données du segment actuel dans le flux global.
 - **Logique :** Si vous envoyez un segment contenant 500 octets et que votre SEQ actuel est $1000$, le segment couvre les octets $1000$ à $1499$.
 - **Calcul du prochain SEQ :** $SEQ_{suivant} = SEQ_{actuel} + \text{Taille des données}$. Dans notre exemple, le prochain envoi commencera au SEQ $1500$.
 #### **B. Le Numéro d'Acquittement (ACK)**
 Le champ **ACK** est une confirmation, mais surtout une **requête pour la suite**.
 - **Logique :** Il indique le numéro du _prochain_ octet attendu par le récepteur.
 - **Exemple :** Si le récepteur renvoie un `ACK 1501`, il signifie explicitement : _"J'ai bien reçu tout ce qui précède l'octet 1501. Envoie-moi maintenant la suite à partir de 1501."_
 Les flags `SYN` et `FIN` consomment virtuellement **1 unité de numéro de séquence**, même s'ils ne transportent pas de données réelles
 ---
 ### 2. L'Initialisation : L'ISN (Initial Sequence Number)
 Pourquoi ne pas commencer systématiquement à zéro ? Pour des raisons de sécurité et de robustesse, TCP utilise l'**ISN**.
 - **Définition :** Lors de la phase de connexion (_Three-Way Handshake_), chaque hôte choisit un numéro de départ **aléatoire** sur 32 bits.
 - **Pourquoi l'aléatoire ?**
    1. **Éviter les collisions :** Si une ancienne connexion sur le même port traîne encore sur le réseau (paquets retardés), un numéro aléatoire évite que ces vieux paquets ne soient acceptés par erreur dans la nouvelle session.
    2. **Sécurité :** Si les numéros étaient prévisibles, un attaquant pourrait injecter de faux paquets dans une session en devinant le prochain SEQ.
 ---
 ### 3. Application Pratique : L'Analyse Wireshark
 Lorsque vous capturez du trafic avec Wireshark, vous remarquerez que les numéros commencent souvent à $0$. Ce sont des **numéros relatifs**, simplifiés par le logiciel pour faciliter la lecture humaine.
 > **Manipulation Étudiante : Voir la réalité du réseau**
 > 
 > Pour observer les véritables numéros de 32 bits (les ISN réels) :
 > 
 > 1. Faites un clic droit sur un paquet TCP.
 >     
 > 2. Allez dans **Protocol Preferences** > **Transmission Control Protocol**.
 >     
 > 3. Décochez **"Relative sequence numbers"**.
 >     
 >     _Observez alors les chiffres massifs (ex: 3824910542) qui circulent réellement sur vos câbles._
 >     
 ---
 ### 4. Résumé du mécanisme
 | **Concept** | **Rôle principal**    | **Analogie**                                     |
 | ----------- | --------------------- | ------------------------------------------------ |
 | **SEQ**     | Identifie l'envoi     | "Voici les caractères n'°1000 à 1500"            |
 | **ACK**     | Confirme la réception | "Bien reçu, donne-moi la suite à partir de 1501" |
 | **ISN**     | Sécurise le départ    | Choisir un numéro au hasard pour commencer.      |
 ---
 ## 2. L'Établissement de la Connexion et la Négociation des Paramètres
 Dans l'architecture TCP/IP, une application ne peut pas simplement "jeter" des données sur le réseau. Avant tout échange, les deux hôtes doivent s'accorder sur un état commun. C'est le rôle du **Three-Way Handshake** (la poignée de main en trois temps), une procédure de synchronisation qui transforme un canal physique non fiable en une liaison logique robuste.
 ---
 ### 1. Le "Three-Way Handshake" (3WHS)
 L'établissement d'une session TCP suit un rituel immuable en trois étapes, permettant d'échanger les numéros de séquence initiaux (**ISN**) et de confirmer la disponibilité des ressources.
 1. **SYN (Synchronize) :** Le client envoie un segment avec le flag `SYN` activé. Il y insère son **ISN** (Initial Sequence Number) généré aléatoirement. C'est une déclaration d'intention : _"Je souhaite ouvrir une connexion et voici mon point de départ numérique."_
 2. **SYN-ACK (Synchronize-Acknowledgment) :** Le serveur répond avec les deux flags activés.
    - Il choisit son propre **ISN**.
    - Il acquitte celui du client en envoyant un **ACK** égal à $ISN_{client} + 1$. Cela signifie : _"J'ai reçu ton SYN, j'attends l'octet suivant."_
 3. **ACK (Acknowledgment) :** Le client finalise la boucle en acquittant l'ISN du serveur ($ACK = ISN_{serveur} + 1$). La connexion est alors déclarée **ESTABLISHED**.
 ---
 ### 2. Négociation des Paramètres Critiques
 Le handshake n'est pas qu'une simple politesse ; c'est une phase de **négociation contractuelle**. Les hôtes y annoncent leurs limites techniques pour optimiser le transfert.
 #### **A. Le MSS (Maximum Segment Size)**
 Le MSS définit la quantité maximale de données utiles (le "payload") qu'un hôte peut accepter dans un seul segment TCP.
 - **Calcul :** Sur un réseau Ethernet standard, le MTU (Maximum Transmission Unit) est de 1500 octets. Si l'on retire l'en-tête IP (20 octets) et l'en-tête TCP (20 octets), il reste un **MSS de 1460 octets**.
 - **Impact :** Si les deux hôtes ont des MSS différents, c'est la valeur la plus **petite** qui est retenue pour éviter la fragmentation IP, coûteuse en ressources.
 ---
 ### B. Le Window Scale (L'extension de fenêtre)
 À l'origine, le champ **Window Size** dans l'en-tête TCP était codé sur 16 bits, limitant la fenêtre de réception à un maximum de **64 Ko** ($2^{16}$). Sur les réseaux modernes à très haut débit (Fibre, 10GbE), cette limite s'est transformée en goulot d'étranglement : l'émetteur passait plus de temps à attendre des acquittements qu'à envoyer des données.
 - **Le mécanisme du Bit Shift :** Pour dépasser cette limite sans modifier la structure de l'en-tête, on utilise l'option **Window Scale**. Elle définit un "facteur de décalage" (Shift Count). Par exemple, si le facteur est de **7**, chaque valeur de fenêtre annoncée est décalée de 7 bits vers la gauche, ce qui revient à multiplier la valeur par **128** ($2^7$).
 - **Résultat :** Ce multiplicateur permet d'étendre virtuellement la fenêtre jusqu'à **1 Go**, une capacité indispensable pour saturer les liens à haut débit et forte latence, appelés **LFN** (_Long Fat Networks_).
 ---
 ### C. Le SACK (Selective Acknowledgment)
 Dans le fonctionnement TCP standard (dit "Cumulative ACK"), si le segment n°3 est perdu mais que les n°4 et n°5 arrivent, le récepteur est incapable de signaler qu'il possède déjà la suite. Il ne peut que répéter : _"J'attends toujours le n°3"_. Par prudence, l'émetteur finit souvent par retransmettre inutilement tout le flux à partir du n°3.
 - **L'optimisation SACK :** Négocié via l'option _SACK Permitted_ lors du handshake, ce mécanisme permet au récepteur d'envoyer des informations précises sur les blocs de données déjà stockés en mémoire. Il dit explicitement : _"Il me manque l'octet n°3, MAIS j'ai déjà bien reçu et mis de côté les blocs allant du n°4 au n°6"_.
 - **Gain de performance :** L'émetteur identifie immédiatement les "trous" dans le flux. Il ne retransmet que les segments manquants, préservant ainsi la bande passante et évitant de congestionner inutilement le réseau.
 ---
 ### Résumé
 |**Paramètre**|**Phase de négociation**|**Utilité majeure**|
 |---|---|---|
 |**SYN / ACK**|Handshake|Synchronisation des ISN et état de la session.|
 |**MSS**|Handshake|Éviter la fragmentation en s'adaptant à la MTU.|
 |**Window Scale**|Handshake|Permettre des transferts haute performance (> 64 Ko).|
 |**SACK**|Handshake|Retransmission intelligente des segments perdus.|
 ---
 Pour bien comprendre, rien ne vaut l'observation des "entrailles" d'un paquet. Nous allons simuler une analyse de trame comme si vous étiez devant votre écran, en nous concentrant sur le premier paquet d'une connexion (le **SYN**).
 ### Travaux Dirigés : Analyse d'un segment SYN sous Wireshark
 Lorsqu'un client (PC) contacte un serveur (Web), le premier paquet envoyé contient toutes les "négociations" que nous avons vues. Voici comment les interpréter dans les couches protocolaires.
 ---
 #### 1. L'anatomie du premier échange (Le SYN)
 Dans l'en-tête TCP de ce premier paquet, vous trouverez les champs suivants :
 - **Flags : 0x002 (SYN)** : Seul le bit de synchronisation est levé.
 - **Sequence Number : 0** (Relatif) ou un nombre aléatoire comme `3824910542` (Réel).
 - **Window Size : 64240** : La mémoire tampon initiale proposée par le client.
 ---
 #### 2. Le bloc "Options" : Le cœur de la négociation
 C'est ici que se joue la performance de la future connexion. Dans Wireshark, déployez l'arborescence **"Options"** sous l'en-tête TCP :
 ##### **A. Maximum Segment Size (MSS)**
 - **Valeur type :** `1460 bytes`.
 - **Interprétation :** Le client informe le serveur : _"Mes trames Ethernet font 1500 octets, donc ne m'envoie pas de segments de données brutes dépassant 1460 octets."_
 ##### **B. Window Scale (WS)**
 - **Valeur type :** `Shift count 7 (multiplier 128)`.
 - **Interprétation :** Sans cette option, le débit serait bridé à cause de la latence. Ici, la fenêtre réelle sera calculée en multipliant la `Window Size` annoncée par 128. C'est l'accélérateur pour la fibre optique.
 ##### **C. SACK Permitted**
 - **Valeur :** `True`.
 - **Interprétation :** Le client dit au serveur : _"Je supporte les acquittements sélectifs. Si tu perds un paquet au milieu de l'envoi, je te dirai exactement lequel, ne renvoie pas tout !"_
 ---
 #### 3. Le "Three-Way Handshake" complet en chiffres
 Imaginons un client (C) et un serveur (S) :
 1. **C → S [SYN]** : `SEQ = 1000`, `Options: MSS=1460, SACK=OK, WS=128`
 2. **S → C [SYN, ACK]** : `SEQ = 5000`, `ACK = 1001`, `Options: MSS=1400, SACK=OK, WS=64`
    > _Note : Le serveur a un MSS plus petit (1400). Les deux utiliseront 1400 pour toute la session._
 3. **C → S [ACK]** : `SEQ = 1001`, `ACK = 5001`.
 ---
 #### Synthèse : Pourquoi est-ce crucial pour un administrateur ?
 Si vous diagnostiquez une lenteur réseau ("Le réseau est lent"), vérifiez toujours ces options :
 - Un **MSS mal négocié** provoque de la fragmentation et fait chuter les performances.
 - Un **Window Scale absent** (multiplicateur à 1) empêche d'utiliser la pleine bande passante sur des liens longue distance.
 ---
 ## 3. La Gestion des Pertes — Résilience et Réactivité de TCP
 Dans un monde idéal, chaque paquet arrive à destination. Dans la réalité des réseaux (WiFi instable, encombrement des routeurs, câbles défectueux), des segments se perdent. TCP ne panique pas : il dispose de deux stratégies complémentaires pour boucher les "trous" dans le flux de données.
 ---
 ### 1. La Retransmission sur Timeout (RTO) : La roue de secours
 Le **RTO (Retransmission Time-Out)** est le mécanisme de base, fondé sur la patience. Lorsqu'un émetteur envoie un segment, il déclenche un chronomètre. S'il n'a reçu aucun acquittement (`ACK`) à l'expiration de ce délai, il considère le segment comme perdu et le renvoie.
 #### **Le concept du Backoff Exponentiel**
 Si le réseau est saturé, renvoyer frénétiquement des paquets ne ferait qu'aggraver la congestion (c'est l'analogie d'un bouchon sur l'autoroute : ajouter des voitures n'aide pas).
 - **Logique :** À chaque échec consécutif, TCP **double** le délai d'attente.
 - **Exemple :** Si le premier timeout est de 1s, le suivant sera de 2s, puis 4s, 8s... jusqu'à abandonner la connexion si le lien est totalement coupé.
 ---
 ### 2. La Fast Retransmission : La réactivité par les "Duplicate ACKs"
 Attendre un timeout est lent et pénalise les performances. TCP utilise donc une astuce basée sur les retours du récepteur : la **Fast Retransmission**.
 #### **Le mécanisme des "Acks en double"**
 Imaginons que l'émetteur envoie les segments 1, 2, 3, 4 et 5. Le segment **n°2 est perdu**.
 1. Le récepteur reçoit le n°1 : il renvoie `ACK 2` (J'attends le 2).
 2. Le récepteur reçoit le n°3 (au lieu du 2) : il ne peut pas acquitter le 3. Il renvoie donc à nouveau **`ACK 2`**.
 3. Le récepteur reçoit le n°4 : il renvoie encore **`ACK 2`**.
 #### **La règle des 3 Duplicate ACKs**
 Dès que l'émetteur reçoit **3 acquittements identiques supplémentaires** (soit 4 fois le même ACK au total), il n'attend pas la fin de son chronomètre (RTO). Il comprend immédiatement que le segment n°2 est manquant et le renvoie sur-le-champ. C'est ce qu'on appelle la "Retransmission Rapide".
 ---
 ### 3. Comparaison des deux mécanismes
 |Caractéristique|Retransmission par Timeout (RTO)|Fast Retransmission|
 |---|---|---|
 |**Déclencheur**|Absence totale de réponse (Silence)|Réception de 3 Duplicate ACKs|
 |**Vitesse**|Lente (attend l'expiration du timer)|Très rapide (réaction immédiate)|
 |**Scénario type**|Coupure réseau ou perte massive|Perte isolée d'un segment dans un flux|
 |**Impact Débit**|Chute brutale du débit (Backoff)|Impact modéré sur la performance|
 Exporter vers Sheets
 ---
 ### Analyse Wireshark : Repérer les problèmes
 Dans Wireshark, ces événements sont mis en évidence par des couleurs spécifiques (souvent texte noir sur fond rouge ou inversement) :
 - **[TCP Retransmission]** : Indique un renvoi après un timeout.
 - **[TCP Fast Retransmission]** : Indique un renvoi suite à des Duplicate ACKs.
 - **[TCP Dup ACK]** : Les messages du récepteur signalant qu'il lui manque quelque chose.
 > **Note d'expert :** Si vous voyez beaucoup de _Fast Retransmissions_, le réseau fonctionne mais "saigne" un peu (quelques pertes). Si vous voyez des _Timeouts_, la connexion est probablement en train de s'effondrer.
 ## 4. Le Contrôle de Flux — La Fenêtre Glissante (Sliding Window)
 La vitesse d'un transfert TCP ne dépend pas seulement de la puissance du processeur, mais de la capacité du récepteur à "digérer" les données. Le **Contrôle de Flux** empêche un émetteur rapide de submerger un récepteur lent ou occupé.
 ---
 ### 1. Le mécanisme de la Fenêtre de Réception (Win)
 Chaque segment TCP contient un champ **Window Size**. C'est une annonce faite par le récepteur : _"Voici l'espace (en octets) qu'il me reste dans mon buffer de réception"_.
 L'émetteur a le droit d'envoyer des données tant que la somme des octets non acquittés est inférieure à cette valeur. C'est ce qu'on appelle la **Fenêtre Glissante**.
 #### **A. TCP Window Full (Côté Émetteur)**
 C'est une alerte Wireshark qui indique que l'émetteur a épuisé le quota autorisé par le récepteur.
 - **Conséquence :** L'émetteur s'arrête net et attend un acquittement avant de renvoyer quoi que ce soit.
 - **Diagnostic :** C'est souvent le signe que le réseau est très rapide, mais que le récepteur (ou l'application) ne suit pas la cadence.
 #### **B. TCP Zero Window (Côté Récepteur)**
 Le récepteur envoie un segment avec une **Window Size = 0**.
 - **Signification :** _"Stop ! Mon buffer est totalement plein. Ne m'envoie plus un seul octet."_ * **Cause :** L'application (ex: un serveur de base de données ou un navigateur) est figée ou traite les données moins vite que le système d'exploitation ne les reçoit.
 ---
 ### 2. Le déblocage : Window Update et Keep-Alive
 Une connexion ne peut pas rester indéfiniment à l'arrêt. TCP utilise deux mécanismes pour relancer la machine :
 - **Window Update :** Dès que l'application a libéré de l'espace dans le buffer, le récepteur envoie spontanément un segment (souvent sans données) avec une nouvelle valeur de fenêtre positive. C'est le signal de reprise : _"C'est bon, j'ai à nouveau 16 Ko de place !"_
 - **TCP Keep-Alive (et Zero Window Probe) :** Si le message "Window Update" est perdu en chemin, la connexion resterait bloquée à jamais. Pour éviter cela, l'émetteur envoie régulièrement de petits segments de test (Keep-Alive) pour forcer le récepteur à répondre et à renvoyer son état de fenêtre actuel. Il est utile de préciser que c'est l'**émetteur** qui prend l'initiative du "Probe" (sonde) pour éviter un interblocage (_deadlock_) si le paquet "Window Update" du récepteur est perdu. Sans cela, les deux resteraient à attendre indéfiniment.
 ---
 ### 3. Synthèse des états de saturation
 | **Message Wireshark** | **Qui parle ?** | **Signification**                                        |
 | --------------------- | --------------- | -------------------------------------------------------- |
 | **TCP Window Full**   | L'Émetteur      | "J'ai atteint la limite que tu m'as fixée, je m'arrête." |
 | **TCP Zero Window**   | Le Récepteur    | "Je suis saturé, ne m'envoie plus rien."                 |
 | **Window Update**     | Le Récepteur    | "J'ai vidé mon buffer, tu peux reprendre l'envoi."       |
 | **TCP Keep-Alive**    | L'Émetteur      | "Es-tu toujours là ? Ta fenêtre est-elle toujours à 0 ?" |
 ---
 ### Analyse de performance : Le "BDP" (Bandwidth-Delay Product)
 Pour un administrateur, la taille de la fenêtre est vitale. Si votre fenêtre est trop petite par rapport à la latence (ping) du réseau, vous ne pourrez jamais atteindre le débit maximal de votre fibre, même si le lien est vide. C'est ici que l'option **Window Scale** (vue au chapitre précédent) devient indispensable pour "gonfler" artificiellement la fenêtre au-delà de 64 Ko.
 ## 5. La Terminaison de Connexion — Dire au revoir (ou raccrocher au nez)
 Une fois les données transférées, TCP doit libérer les ressources (mémoire, ports, sockets) utilisées par la session. Contrairement à l'ouverture qui se fait en 3 étapes, la fermeture "propre" nécessite généralement **4 étapes**, car TCP est un protocole **Full-Duplex** : chaque sens de communication doit être fermé indépendamment.
 ---
 ### 1. La Fermeture Propre : Le "Four-Way Handshake" (FIN)
 Lorsque l'une des applications (souvent le client) a fini d'envoyer ses données, elle initie une procédure de fermeture élégante en utilisant le flag **FIN** (_Finish_).
 1. **FIN (Client → Serveur) :** "J'ai fini d'envoyer mes données, je souhaite fermer mon sens de communication."
 2. **ACK (Serveur → Client) :** "Bien reçu, je prends note que tu ne m'enverras plus rien."
    > _À ce stade, la connexion est dans un état "Semi-fermé". Le serveur peut encore envoyer des données s'il en a en attente._
 3. **FIN (Serveur → Client) :** "De mon côté aussi, j'ai terminé."
 4. **ACK (Client → Serveur) :** "Parfait, nous sommes d'accord. Adieu."
 ---
 ### 2. La Fermeture Brutale : Le Reset (RST)
 Parfois, la politesse n'est plus de mise. Le flag **RST** (_Reset_) est utilisé pour interrompre immédiatement une connexion sans attendre d'acquittement. C'est l'équivalent de raccrocher le téléphone brusquement.
 #### **Les causes d'un paquet RST :**
 - **Port fermé :** Vous tentez de vous connecter à un port (ex: 8080) où aucun service n'écoute. Le serveur répond par un `RST`.
 - **Crash applicatif :** L'application qui gérait la connexion a planté. Le système d'exploitation envoie un `RST` pour nettoyer la session devenue orpheline.
 - **Action d'un Pare-feu (Firewall) :** Un équipement de sécurité décide de couper une connexion jugée suspecte ou interdite.
 - **Incohérence de séquence :** TCP reçoit un paquet qui ne correspond à aucune session active ou dont le numéro de séquence est totalement aberrant.
 ---
 ### 3. Comparaison : FIN vs RST
 |Caractéristique|FIN (Fermeture Propre)|RST (Fermeture Brutale)|
 |---|---|---|
 |**Analogie**|"Au revoir, à la prochaine."|"Erreur fatale, on coupe tout !"|
 |**Données en transit**|Sont transmises et acquittées avant l'arrêt.|Sont perdues immédiatement.|
 |**État Wireshark**|Suite logique de `FIN`, `ACK`, `FIN`, `ACK`.|Un seul paquet rouge marqué `[RST]`.|
 |**Utilisation**|Fin normale d'un transfert HTTP, FTP, etc.|Rejet de connexion, timeout sévère, sécurité.|
 Exporter vers Sheets
 ---
 ### 4. L'état critique : TIME_WAIT
 Après avoir envoyé le dernier `ACK`, l'initiateur de la fermeture ne libère pas son port immédiatement. Il entre dans l'état **TIME_WAIT**.
 - **Pourquoi ?** Pour s'assurer que le dernier `ACK` est bien arrivé au destinataire et pour éviter qu'un paquet "égaré" d'une ancienne session ne vienne perturber une nouvelle connexion qui réutiliserait le même port.
 ---
 ## Synthèse : Le Code de Communication TCP (Les Flags)
 Les flags sont des bits de 1 (activé) ou 0 (désactivé) situés dans l'en-tête TCP. Ils dictent la nature du segment envoyé.
 ### 1. Les "Bâtisseurs" (Ouverture)
 - **SYN (Synchronize) :** Utilisé uniquement lors de l'établissement de la connexion. Il indique l'intention de synchroniser les numéros de séquence (**ISN**).
 - **ACK (Acknowledgment) :** Le flag le plus courant. Une fois la connexion établie, presque tous les paquets l'ont activé pour confirmer la réception des données précédentes.
 ### 2. Les "Transporteurs" (Transfert)
 - **PSH (Push) :** Demande à la pile TCP du récepteur de transmettre immédiatement les données à l'application sans attendre que le buffer de réception soit plein. Très utilisé en SSH ou Telnet pour l'interactivité.
 - **URG (Urgent) :** Indique que certaines données dans le segment sont prioritaires (rarement utilisé aujourd'hui).
 ### 3. Les "Démolisseurs" (Fermeture)
 - **FIN (Finish) :** Fermeture polie. L'émetteur n'a plus rien à dire mais attend que l'autre côté confirme et ferme aussi.
 - **RST (Reset) :** Fermeture brutale. On coupe tout sans préavis suite à une erreur ou un rejet de sécurité.
 ---
 ### Tableau Récapitulatif : Diagnostic Rapide
 |**Flag(s) visible(s)**|**Interprétation Wireshark**|**Scénario probable**|
 |---|---|---|
 |**SYN**|Tentative de connexion|Début d'un chargement de page Web.|
 |**SYN, ACK**|Acceptation du serveur|Le serveur est prêt à parler.|
 |**ACK**|Confirmation simple|Le transfert se passe bien.|
 |**PSH, ACK**|Envoi de données|L'application envoie un morceau de fichier.|
 |**FIN, ACK**|Demande de fermeture|L'utilisateur ferme l'onglet du navigateur.|
 |**RST**|Rejet / Erreur|Tentative sur un port fermé ou coupure pare-feu.|
 ---
 ### 💡 Le Conseil de l'Expert
 Lorsqu'on vous donne une suite de paquets à analyser, regardez toujours le **premier flag** :
 1. Si c'est un **SYN**, c'est une nouvelle session.
 2. Si vous voyez **RST** dès le début, le service est inaccessible.
 3. Si vous voyez des **Dup ACK** (souvent marqués en noir/rouge dans Wireshark), il y a de la congestion ou des pertes de paquets sur le lien.
 ---
 ## Étude de cas : datagramme IPv4
 ![](Pasted%20image%2020260308142720.png)
 Cette image est une représentation classique de l'**en-tête d'un datagramme IPv4**. C'est un document fondamental pour comprendre comment les données circulent sur Internet.
 ### 1. Structure Générale
 L'image montre comment un paquet IP est organisé au niveau binaire.
 - **Les Lignes (Words) :** Chaque ligne numérotée de 1 à 6 représente un "mot" de **32 bits** (soit 4 octets).
 - **La Largeur (Bits) :** L'échelle en haut indique la position des bits, de 0 à 31.
 - **Le Header (En-tête) :** Les 5 premières lignes sont obligatoires (20 octets). La 6ème ligne (Options) est facultative.
 - **Data :** Tout ce qui se trouve après l'en-tête est la charge utile (le message réel, souvent un segment TCP ou UDP).
 ---
 ## 2. Analyse ligne par ligne
 #### Ligne 1 : Contrôle de base
 - **Version (4 bits) :** Indique la version du protocole (ici, `4` pour IPv4).
 - **IHL (4 bits) :** _Internet Header Length_. Indique la longueur de l'en-tête. C’est crucial car la zone "Options" peut varier en taille.
 - **Type of Service (8 bits) :** Utilisé pour la qualité de service (QoS), par exemple pour prioriser la voix sur IP (VoIP) par rapport à un email.
 - **Total Length (16 bits) :** La taille totale du paquet (en-tête + données).
 #### Ligne 2 : Fragmentation
 _C'est ici que l'IP gère les paquets trop gros pour certains réseaux._
 - **Identification (16 bits) :** Un numéro unique pour identifier tous les fragments d'un même paquet initial.
 - **Flags (3 bits) :** Permettent de dire "ne pas fragmenter" ou "il y a d'autres fragments après celui-ci".
 - **Fragmentation Offset (13 bits) :** Indique la position exacte de ce fragment dans le message d'origine.
 #### Ligne 3 : Durée de vie et Protocole
 - **Time to Live (TTL - 8 bits) :** Un compteur de "sauts" (hops) entre routeurs. À chaque routeur, on retire 1. Si ça tombe à 0, le paquet est détruit. Cela évite que des paquets tournent en boucle indéfiniment.
 - **Protocol (8 bits) :** Indique quel protocole de couche supérieure se trouve dans les données (ex: 6 pour TCP, 17 pour UDP, 1 pour ICMP).
 - **Header Checksum (16 bits) :** Un code de vérification pour s'assurer que l'en-tête n'a pas été corrompu pendant le transport.
 ### Lignes 4 & 5 : L'adressage
 - **Source Address (32 bits) :** L'adresse IP de l'expéditeur.
 - **Destination Address (32 bits) :** L'adresse IP du destinataire.
 ### Ligne 6 : Options et Bourrage
 - **Options :** Utilisé très rarement pour des tests ou de la sécurité.
 - **Padding (Padding) :** Comme l'en-tête doit toujours se terminer sur un multiple de 32 bits, on ajoute des zéros si les options sont trop courtes.
 ---
 ## 3. Pourquoi est-ce important en Cybersécurité ?
 Comprendre ce schéma vous permet de :
 1. **Analyser les logs :** Comprendre ce que vous voyez dans un outil comme **Wireshark**.
 2. **Détecter des anomalies :** Un TTL anormalement bas peut indiquer une tentative de cartographie réseau (Traceroute).
 3. **Comprendre l'IP Spoofing :** L'usurpation d'adresse consiste à modifier manuellement le champ _Source Address_.
 > **Note aux débutants :** Retenez bien que l'IP ne garantit pas que le message arrive (c'est le rôle de TCP). L'IP s'occupe uniquement de l'adressage et de l'acheminement "au mieux" (_Best Effort_).
 ## Étude de cas : datagramme TCP
 ![](Pasted%20image%2020260308143044.png)
 On monte d'un étage dans le modèle OSI : après la couche Réseau (IP), voici l'en-tête du segment **TCP (Transmission Control Protocol)**, situé au niveau de la couche **Transport**.
 Si l'IP est l'enveloppe avec l'adresse de la maison, le TCP est la lettre recommandée avec accusé de réception qui s'assure que le contenu arrive intact et dans le bon ordre.
 ---
 ### 1. Les Ports : L'aiguillage des applications
 Contrairement à l'IP qui identifie une machine, le TCP utilise des **ports** pour identifier une application spécifique sur cette machine.
 - **Source Port (16 bits) :** Le port utilisé par l'application qui envoie les données (souvent un port aléatoire au-dessus de 1024).
 - **Destination Port (16 bits) :** Le port de l'application réceptrice (ex: 80 pour HTTP, 443 pour HTTPS, 22 pour SSH).
 ### 2. La Fiabilité : Séquençage et Accusés
 C'est ici que réside la "magie" du TCP.
 - **Sequence Number (32 bits) :** Chaque octet envoyé reçoit un numéro. Cela permet au destinataire de reconstruire le message dans l'ordre, même si les paquets arrivent dans le désordre.
 - **Acknowledgement Number (32 bits) :** C'est l'accusé de réception. Le récepteur dit : "J'ai bien reçu jusqu'à l'octet X, j'attends maintenant le X+1".
 ### 3. Gestion et Flux
 - **Header Length (4 bits) :** Comme pour l'IP, indique où s'arrête l'en-tête et où commencent les données.
 - **Code Bits / Flags (6 bits) :** Ce sont les "interrupteurs" du TCP. Les plus connus en cyber sont :
    - **SYN :** Pour établir la connexion.
    - **ACK :** Pour accuser réception.
    - **FIN :** Pour terminer proprement la connexion.
    - **RST :** Pour réinitialiser brutalement une connexion (souvent vu lors d'un scan de port).
 - **Window (16 bits) :** C'est le contrôle de flux. Le récepteur dit : "Ne m'envoie pas plus de X octets à la fois car ma mémoire tampon est pleine".
 ### 4. Intégrité et Urgence
 - **Checksum (16 bits) :** Vérifie que l'en-tête **et** les données n'ont pas été modifiés.
 - **Urgent Pointer (16 bits) :** Très peu utilisé aujourd'hui, il servait à indiquer que certaines données dans le segment devaient être traitées prioritairement.
 ---
 ### Le point de vue Cybersécurité 🛡️
 Le TCP est au cœur de nombreuses analyses :
 - **TCP Connect Scan :** Un attaquant tente d'ouvrir une connexion complète (SYN -> SYN/ACK -> ACK) pour voir si un port est ouvert.
 - **SYN Flood :** Une attaque DoS (Déni de Service) consistant à envoyer des milliers de segments SYN sans jamais répondre au SYN/ACK, saturant ainsi les ressources du serveur.
 - **Détournement de session (Hijacking) :** Si un attaquant arrive à deviner le prochain **Sequence Number**, il peut injecter des données malveillantes dans une connexion existante.
 ## Étude de cas : Anomalie et Sécurité (Le Scan "Christmas Tree")
 Sur cette capture, nous observons un comportement qui contredit tout ce que nous avons vu sur le cycle de vie normal de TCP.
 ![](Pasted%20image%2020260308135822.png)
 Ce que vous voyez est une **violation flagrante de la RFC 793** (la spécification officielle de TCP).
 ### 1. L'Anomalie des Flags (Le "Sapin de Noël")
 Regardez le cadre rouge dans les détails du paquet 2 :
 - **Flags : 0x03b (FIN, SYN, PSH, ACK, URG)**.
 - **Le problème :** Dans une communication normale, ces flags ne sont **jamais** activés tous ensemble. Activer `SYN` (ouverture) et `FIN` (fermeture) simultanément est une contradiction logique pure.
 - **Pourquoi ce nom ?** On l'appelle "Christmas Tree" car, comme un arbre de Noël, le paquet est "éclairé" par tous les flags possibles.
 - **Caractériser l'attaque :** C'est un _Xmas Scan_. L'attaquant cherche à contourner les pare-feu qui ne filtrent que les paquets `SYN`. Comme ce paquet n'a pas que le flag `SYN`, certains vieux équipements pourraient le laisser passer.
 ### 2. Le Comportement du Serveur (Le Reset)
 Observez les lignes sur fond rouge (paquets 1, 3, 5, etc.) :
 - **Source : 10.0.0.2** (Le serveur) répond systématiquement par un flag **[RST]**.
 - **Interprétation :** Le serveur reçoit un paquet totalement incohérent. Sa pile TCP ne sait pas comment traiter une demande qui veut à la fois "commencer", "pousser des données" et "finir". La plupart des piles TCP répondent `RST` à un paquet invalide non pas par "sécurité", mais par **conformité à la norme**. La RFC 793 stipule qu'un segment arrivant sur une connexion inexistante ou fermée doit générer un `RST`. C'est précisément cette "obéissance" à la norme que l'attaquant exploite pour le fingerprinting.
 ### 3. Diagnostic de Cybersécurité
 Ce que vous voyez ici n'est pas un transfert de données, mais une tentative de **Fingerprinting (Reconnaissance)** :
 - Un attaquant envoie ces paquets bizarres pour voir comment le système d'exploitation du serveur réagit.
 - Selon que le serveur répond par un `RST` ou qu'il ignore le paquet (Drop), l'attaquant peut deviner s'il s'agit d'un système Windows, Linux ou d'un pare-feu spécifique.
 Notez que dans un vrai scan de type "Xmas", ce sont généralement les flags `FIN`, `URG` et `PSH` qui sont utilisés (les "lumières" de l'arbre). Le flag `SYN` est souvent **exclu** du scan Xmas classique, car un paquet avec `SYN` est traité différemment par les pare-feu. Si `SYN` est présent avec `FIN`, c'est une variante encore plus agressive.
 ### 4. Actions Techniques (La Réponse)
 #### **A. Au niveau du Pare-feu (Firewall/IPS)**
 La meilleure réaction n'est pas de répondre `RST`, mais de devenir **invisible**.
 - **Passer en mode "Drop" (ou Deny) :** Configurez votre pare-feu pour qu'il jette silencieusement ces paquets invalides au lieu de laisser le serveur répondre.
 - **Règle de filtrage :** Bloquer toute combinaison de flags TCP qui ne respecte pas la machine à états (ex: `SYN` et `FIN` ensemble, ou aucun flag du tout).
 #### **B. Au niveau du Système d'Exploitation (Hardening)**
 - **Limitation de débit (Rate Limiting) :** Si vous recevez trop de paquets `RST` ou de tentatives de connexion invalides en une seconde, bannissez temporairement l'IP source (via un outil comme _Fail2Ban_ ou une règle d'IPS).
 - **Mise à jour de la pile TCP :** Les systèmes modernes ignorent ou bloquent mieux ces anomalies, mais une pile réseau mal configurée peut révéler trop d'informations sur sa version via ses réponses.
 ## Configurer Fail2Ban contre les Scans Anormaux
 Pour que Fail2Ban réagisse, il faut d'abord que votre pare-feu (ici `iptables`) enregistre les paquets suspects dans un fichier log (généralement `/var/log/messages` ou `/var/log/syslog`).
 ### 1. La règle de log (Préalable)
 Avant Fail2Ban, on demande au pare-feu de marquer les scans "Christmas Tree" :
 ```toml
 # Log les paquets avec des combinaisons de flags invalides
 iptables -A INPUT -p tcp --tcp-flags ALL FIN,SYN,PSH,ACK,URG -j LOG --log-prefix "TCP-XMAS-SCAN: "
 ```
 ### 2. Le filtre Fail2Ban (`/etc/fail2ban/filter.d/tcp-scans.conf`)
 Ce fichier définit ce que Fail2Ban doit chercher dans les logs. On utilise une expression régulière (regex) pour repérer le préfixe que nous avons créé.
 ```toml
 [Definition]
 # On cherche l'IP source (SRC=...) associée à notre préfixe de log
 failregex = TCP-XMAS-SCAN: .* SRC=<HOST>
 ignoreregex =
 ```
 ### 3. La "Jail" Fail2Ban (`/etc/fail2ban/jail.local`)
 C'est ici que l'on définit la punition (le bannissement).
 ```toml
 [tcp-xmas-protection]
 enabled  = true
 filter   = tcp-scans
 logpath  = /var/log/messages
 port     = all
 # Si on détecte 3 tentatives (maxretry) en 1 minute (findtime)
 findtime  = 60
 maxretry  = 3
 # On bannit l'IP pendant 1 heure
 bantime   = 3600
 action    = iptables-multiport[name=TCP-XMAS, port="all", protocol=tcp]
 ```
 - **Réactivité :** Dès que l'attaquant dépasse le seuil de 3 paquets suspects (comme on le voit sur votre capture où il y a plus de 10 échanges en 0.1 seconde), il est coupé.
 - **Dissuasion :** Le `bantime` de 1 heure décourage les outils de scan automatisés qui cherchent des cibles faciles.
 - **Protection des ressources :** En bannissant au niveau du pare-feu, le serveur ne perd plus de temps à générer des paquets `RST`, ce qui économise du CPU et de la bande passante.
 | Étape         | Outil      | Rôle                                                        |
 | ------------- | ---------- | ----------------------------------------------------------- |
 | **Détection** | `iptables` | Identifie les flags anormaux et écrit dans le log.          |
 | **Analyse**   | `Fail2Ban` | Compte le nombre d'alertes par IP dans le temps.            |
 | **Sanction**  | `iptables` | Ajoute une règle de blocage automatique pour l'IP coupable. |
 ### Synthèse de la posture de sécurité
 |Type de Réponse|Effet sur l'Attaquant|Recommandation|
 |---|---|---|
 |**Le serveur répond RST** (ce qu'on voit sur l'image)|L'attaquant sait que le serveur est **actif** mais que le port est peut-être fermé ou protégé.|**Moyen.** On donne trop d'infos.|
 |**Le Firewall "Drop" (silence)**|L'attaquant ne reçoit rien. Il ne sait pas si le serveur existe ou si le paquet a été perdu.|**Excellent.** C'est la posture de "discrétion".|
 |**Bannissement (Blacklist)**|L'IP de l'attaquant est bloquée pour 24h sur tous les services.|**Idéal.** Pour stopper la reconnaissance.|
 ---
--- a/articles/2026/openldap
+++ b/articles/2026/openldap
@@ -0,0 +1,299 @@
 ---
 title: "OpenLDAP : Installer et configurer sous Debian 13 (Trixie)"
 description: OpenLDAP est le "répertoire téléphonique" haute performance du monde informatique. C'est une implémentation libre et open source du protocole LDAP (Lightweight Directory Access Protocol).
 tags: [ldap, openldap, Debian_13]
 date: 2026-02-22 09:21
 lastmod: 2026-02-22 09:50
 type:
  - article
 category:
  - "[[Guide]]"
  - "[[Logiciels et Outils]]"
 status: brouillon
 ---
 # OpenLDAP : Installer et configurer sous Debian 13 (Trixie)
 Bonjour, je suis [Cédrix](Cédrix.md). Dans ce guide, nous allons déployer **OpenLDAP**, la solution de référence pour l'unification des identités en environnement Linux.
 L'objectif est simple : en finir avec la gestion manuelle des comptes sur chaque machine. Nous allons mettre en place un **annuaire centralisé** qui servira de "source de vérité" unique pour tous les services de votre réseau (serveurs, VPN, applications web, etc.).
 ## Introduction
 Au lieu de créer un compte utilisateur sur chaque serveur, chaque application (VPN, Wi-Fi, Nextcloud, GitLab, serveurs Linux) interroge OpenLDAP pour savoir :
 1. "Est-ce que cet utilisateur existe ?"
 2. "Son mot de passe est-il correct ?"
 3. "A-t-il le droit d'accéder à cette ressource ?"
 > [!INFO] Le saviez-vous ?
 > Microsoft Active Directory (AD) repose en grande partie sur les mêmes concepts que LDAP, mais OpenLDAP est sa version libre, plus légère et extrêmement flexible.
 Contrairement à une base de données relationnelle (comme MySQL ou PostgreSQL) qui est optimisée pour l'écriture et les relations complexes, OpenLDAP est une **base de données hiérarchique** optimisée pour la **lecture rapide** et la **recherche**.
 - **Lecture (90%) :** Consulter une fiche utilisateur, vérifier un mot de passe.
 - **Écriture (10%) :** Modifier un numéro de téléphone ou créer un nouveau compte.
 Pour définir OpenLDAP, il faut comprendre ces trois éléments :
 - **Le Modèle d'Information :** Tout est objet (un utilisateur, une imprimante, un groupe). Chaque objet appartient à une `objectClass` qui définit ses attributs (nom, email, mot de passe).
 - **Le Modèle de Nommage (DIT) :** Les données sont organisées en arbre (_Directory Information Tree_). On identifie un objet par son **DN** (_Distinguished Name_), son adresse unique dans l'arbre (ex: `cn=jean,ou=users,dc=acegrp,dc=lan`).
 - **Le Protocole de Communication :** Il définit comment un client (une application) "parle" au serveur pour extraire ou modifier des informations.
 Même à l'ère du Cloud, OpenLDAP reste indispensable pour :
 - **L'indépendance :** Vous gardez le contrôle total de vos identités sans dépendre d'un fournisseur tiers (SaaS).
 - **L'interopérabilité :** Quasiment tous les logiciels professionnels au monde savent "parler" LDAP.
 - **La performance :** Capable de gérer des millions d'entrées avec un temps de réponse de quelques millisecondes.
 Voici le décodage des acronymes que vous rencontrerez partout :
 ---
 ###  DC : Domain Component (Le Domaine)
 Le **DC** représente les composants de votre nom de domaine. C'est la racine de votre annuaire.
 - Pour `acegrp.lan`, on sépare le nom au niveau du point.
 - On obtient deux composants : `dc=acegrp` et `dc=lan`.
 - Ensemble, ils forment la base de votre annuaire (le **Base DN**).
 ### OU : Organizational Unit (Le Tiroir)
 L'**OU** est un conteneur qui sert à regrouper des objets de même nature. C'est l'équivalent d'un dossier dans votre explorateur de fichiers.
 - `ou=users` : pour ranger les humains.
 - `ou=groups` : pour ranger les droits d'accès.
 - `ou=computers` : pour ranger le parc matériel.
 ### CN : Common Name (L'Objet)
 Le **CN** désigne généralement l'objet final (l'individu ou le groupe). C'est le nom "commun" par lequel on identifie l'entrée.
 - Si vous avez un utilisateur nommé Jean Dupont, son CN sera souvent `cn=jdupont`.
 - Pour un groupe d'administrateurs, ce sera `cn=admins`.
 ---
 ### DN : L'adresse complète (Le chemin)
 Le **DN** (_Distinguished Name_) est la concaténation de tous ces éléments. C'est l'équivalent d'un chemin de fichier (ex: `C:\Users\Jean\Documents`). **Il se lit de droite à gauche**, du plus précis au plus général.
 > **Exemple concret :** Si Jean Dupont (`cn=jdupont`) est dans le dossier des utilisateurs (`ou=users`) de votre entreprise (`dc=acegrp,dc=lan`), son adresse unique est : `dn: cn=jdupont,ou=users,dc=acegrp,dc=lan`
 #### Tableau récapitulatif
 | Acronyme | Nom Complet         | Rôle                           | Exemple                  |
 | -------- | ------------------- | ------------------------------ | ------------------------ |
 | **DC**   | Domain Component    | Définit la racine (le domaine) | `dc=acegrp`              |
 | **OU**   | Organizational Unit | Organise les objets (dossier)  | `ou=users`               |
 | **CN**   | Common Name         | Nom de l'objet précis          | `cn=jdupont`             |
 | **DN**   | Distinguished Name  | Adresse complète et unique     | `cn=jdupont,ou=users...` |
 | **SN**   | Surname             | Nom de famille (attribut)      | `Dupont`                 |
 ---
 #### Pourquoi est-ce important ?
 Lorsque vous configurerez une application tierce (comme un VPN ou Nextcloud) pour se connecter à votre OpenLDAP, elle vous demandera presque toujours deux choses :
 1. **Le Base DN :** `dc=acegrp,dc=lan` (Où dois-je commencer à chercher ?)
 2. **Le Bind DN :** `cn=admin,dc=acegrp,dc=lan` (Avec quel compte je me connecte pour avoir le droit de lire l'annuaire ?)
 ## 1. Prérequis et Installation
 L'utilisation d'un conteneur **LXC** est idéale pour OpenLDAP : elle offre une isolation parfaite, une empreinte mémoire dérisoire (moins de 50 Mo au repos) et permet des sauvegardes par "snapshots" avant chaque modification structurelle.
 Pour un conteneur LXC dédié à **OpenLDAP**, les besoins en ressources sont particulièrement modestes. OpenLDAP est réputé pour sa stabilité et sa faible consommation, ce qui en fait un candidat parfait pour la virtualisation légère.
 Voici les recommandations pour dimensionner votre machine LXC sous Debian 13 :
 ### Ressources Matérielles (Sizing)
 | **Ressource** | **Minimum (Lab)** | **Recommandé (Prod)** | **Note**                                                                           |
 | ------------- | ----------------- | --------------------- | ---------------------------------------------------------------------------------- |
 | **CPU**       | 1 vCPU            | 1 ou 2 vCPU           | Le calcul des condensats (hashes) de mots de passe est la seule tâche gourmande.   |
 | **RAM**       | 256 Mo            | **512 Mo à 1 Go**     | OpenLDAP met en cache la base de données en RAM pour plus de rapidité.             |
 | **Disque**    | 2 Go              | **8 Go**              | La base de données LDAP est très compacte. Prévoyez de l'espace pour les **logs**. |
 | **Swap**      | 512 Mo            | 512 Mo                | Par précaution, bien que LDAP sature rarement la RAM.                              |
 ---
 ### Configuration Réseau et Système
 Avant de lancer l'installation de `slapd`, assurez-vous que ces trois piliers sont en place :
 #### A. Adresse IP Statique
 Comme mentionné précédemment, un annuaire ne doit jamais changer d'IP. Dans votre configuration LXC (via Proxmox ou en ligne de commande), fixez l'adresse :
 - **Exemple :** `192.168.1.10/24` avec sa passerelle.
 #### B. Résolution de nom (Hostname & FQDN)
 L'installeur de Debian utilise le nom d'hôte pour configurer le domaine LDAP par défaut.
 - Modifiez `/etc/hostname` pour refléter le nom du serveur (ex: `ldap-server`).
 - Modifiez `/etc/hosts` pour lier l'IP au nom complet :
    `192.168.1.10 ldap-server.acegrp.lan ldap-server`
 #### C. Synchronisation Temporelle
 Le protocole LDAP est souvent utilisé avec **Kerberos** ou pour de la réplication. Une horloge désynchronisée peut corrompre les logs ou empêcher l'authentification.
 - Vérifiez que le conteneur est à l'heure (il hérite généralement de l'heure de l'hôte LXC, mais assurez-vous que l'hôte utilise `NTP`).
 ---
 ### Pourquoi LXC plutôt qu'une VM ?
 Le choix du LXC pour OpenLDAP est stratégique pour la maintenance :
 1. **Sauvegardes instantanées :** Un "snapshot" de 512 Mo de RAM se fait en quelques secondes avant de modifier un schéma LDAP complexe.
 2. **Partage de ressources :** Si votre LDAP est peu sollicité, il ne consommera virtuellement rien sur votre hôte Proxmox/LXC, contrairement à une VM qui "réserve" sa mémoire.
 3. **Accès direct aux fichiers :** En cas de corruption majeure (rare avec le moteur MDB), il est plus facile d'accéder au système de fichiers du conteneur depuis l'hôte.
 ### Installation des paquets
 Connectez-vous à votre conteneur et mettez à jour les dépôts, puis installez les outils nécessaires :
 ```Bash
 apt update && apt install slapd ldap-utils -y
 ```
 **Détails des paquets :**
 - **`slapd` (Standalone LDAP Daemon) :** C'est le serveur proprement dit. Il gère la base de données, les requêtes de recherche et l'authentification.
 - **`ldap-utils` :** Un ensemble d'outils en ligne de commande indispensables pour interagir avec le serveur (ajouter, supprimer, modifier ou chercher des entrées).
 > **Note :** Durant l'installation, un mot de passe administrateur vous sera demandé. Il servira à créer le compte `admin` par défaut. Ne l'oubliez pas, il est crucial pour l'étape suivante.
 ---
 ## 2. Configuration du domaine (DIT)
 Par défaut, Debian configure LDAP en se basant sur le nom d'hôte (FQDN). Pour définir précisément notre structure de domaine `acegrp.lan`, nous utilisons l'outil de reconfiguration assistée.
 ```Bash
 dpkg-reconfigure -plow slapd
 ```
 **Répondez aux questions comme suit :**
 1. **Omettre la configuration du serveur ?** `Non` (Nous voulons créer une base exploitable immédiatement).
 2. **Nom de domaine :** `acegrp.lan` (C'est ce qui définit votre "Base DN" : `dc=acegrp,dc=lan`).
 3. **Nom de l'organisation :** `acegrp`
 4. **Mot de passe administrateur :** Saisissez un mot de passe robuste.
 5. **Base de données à utiliser :** `MDB` (Le moteur de stockage le plus performant et recommandé).
 6. **Supprimer la base si slapd est purgé ?** `Non` (Sécurité pour vos données en cas de réinstallation du paquet).
 7. **Déplacer l'ancienne base de données ?** `Oui`.
 ---
 ## 3. Création de la structure (OU)
 Un annuaire LDAP ne contient pas d'utilisateurs "en vrac". On utilise des **Unités Organisationnelles (OU)**, semblables à des dossiers, pour classer les objets.
 - **`ou=users` :** Regroupe les comptes des utilisateurs.
 - **`ou=groups` :** Regroupe les groupes de sécurité (ex: admins, RH, dev).
 ### Création du fichier LDIF
 Le format **LDIF** (LDAP Data Interchange Format) est le standard pour modifier l'annuaire. Vous pouvez créer ce fichier dans votre répertoire personnel (ex: `/root/structure.ldif`).
 ```Bash
 nano ~/structure.ldif
 ```
 Copiez-y le contenu suivant :
 ```Plaintext
 dn: ou=users,dc=acegrp,dc=lan
 objectClass: organizationalUnit
 ou: users
 dn: ou=groups,dc=acegrp,dc=lan
 objectClass: organizationalUnit
 ou: groups
 ```
 ### Application de la structure
 Utilisez la commande `ldapadd` pour injecter ces données dans l'annuaire :
 ```Bash
 ldapadd -x -D "cn=admin,dc=acegrp,dc=lan" -W -f ~/structure.ldif
 ```
 - `-x` : Utilise l'authentification simple.
 - `-D` : Définit le "Distinguished Name" (DN) avec lequel on se connecte (ici l'admin).
 - `-W` : Demande le mot de passe de manière sécurisée.
 - `-f` : Indique le fichier source.
 ---
 ## 4. Test et Vérification
 Pour vérifier que vos "tiroirs" sont bien créés, interrogez l'annuaire :
 ```Bash
 ldapsearch -x -b "dc=acegrp,dc=lan" "(objectClass=organizationalUnit)"
 ```
 L'option `-b` (base) définit le point de départ de la recherche. Vous devriez voir s'afficher vos deux nouvelles unités `users` et `groups`.
 ---
 ## 5. Sécurité et Réseau
 ### Ouverture du pare-feu
 Le protocole LDAP utilise par défaut le port **389**. Si vous utilisez `ufw` dans votre conteneur ou sur votre hôte Proxmox/LXC, ouvrez le port :
 ```Bash
 ufw allow 389/tcp
 ```
 ### Prochaine étape conseillée
 Pour le moment, vos données transitent en clair sur le réseau. Pour une mise en production, la prochaine étape logique est l'activation du **LDAPS (port 636)** ou de **STARTTLS** pour chiffrer les échanges.
--- a/articles/2026/publier
+++ b/articles/2026/publier
@@ -3,14 +3,11 @@ title: 'Bâtir son "Jardin Numérique" : de la prise de notes locale à la publi
 description: Contrairement à un blog classique où les articles meurent dans les archives, un jardin numérique est une base de connaissance vivante, interconnectée et évolutive.
 type:
  - article
-tags:
+tags: [digital-garden, SSG, Git]
  - digital-garden
  - SSG
  - Git
 category:
  - "[[Guide]]"
 date: 2026-02-21 14:22
-lastmod: 2026-02-21 15:57
+lastmod: 2026-02-22 00:56
 status: brouillon
 ---
@@ -33,6 +30,8 @@ Aujourd'hui, le cœur de ce système repose sur un choix technique crucial : le
 > **Le bémol :** le Markdown n'est pas un outil de mise en page "artistique". C'est un format structurel. Si l'on cherche à faire du graphisme complexe sur chaque page, ce n'est pas l'outil idéal.
 **Choses à faire :** apprendre le markdown
 ---
 ## 2. L'architecte : Obsidian
@@ -54,6 +53,7 @@ Pour gérer ces fichiers Markdown, **Obsidian** s'impose comme l'outil de réfé
 - La synchronisation entre plusieurs appareils demande une configuration spécifique (via Git ou un service tiers).
 **Choses à faire :** installer obsidian, synchroniser avec un dépôt Git
 ---
--- a/articles/2026/utiliser
+++ b/articles/2026/utiliser
@@ -0,0 +1,286 @@
 ---
 title: "Utiliser PGP sous Linux : Signez vos fichiers avec Thunderbird"
 description: "Apprenez à utiliser votre clé OpenPGP Thunderbird pour signer des fichiers (PDF, archives) sous Linux. Guide complet : export, import GPG et signature détachée."
 tags: [OpenPGP, Thunderbird, Linux, GPG]
 date: 2026-03-13 08:36
 lastmod: 2026-03-13 09:01
 type:
  - article
 category:
  - "[[Guide]]"
 status: brouillon
 ---
 # Utiliser PGP sous Linux : Signez vos fichiers avec Thunderbird
 ## Introduction
 Imaginez que vous puissiez apposer un sceau de cire inviolable sur chacun de vos documents numériques, garantissant à la fois votre identité et l'intégrité de vos fichiers. Longtemps réservée aux experts de la cryptographie, cette sécurité — portée par le standard **OpenPGP** — est désormais à la portée de tous.
 Si vous utilisez **Thunderbird**, vous détenez peut-être déjà cette puissance sans le savoir. Depuis sa version 78, le célèbre client mail a intégré nativement les outils de chiffrement, transformant une configuration autrefois laborieuse en une simple formalité.
 ### Pourquoi sauter le pas aujourd'hui ?
 Posséder une clé GPG dans Thunderbird, c'est un peu comme avoir un stylo plume de haute sécurité : c'est élégant, c'est gratuit, et cela devient vite indispensable une fois qu'on a goûté à la tranquillité d'esprit qu'elle procure. Si votre clé n'est pas encore créée, c'est le moment idéal pour forger votre identité numérique.
 Avant de passer à la signature concrète de vos fichiers, assurons-nous que votre arsenal est prêt. Voici comment vérifier en un clin d'œil si votre clé sommeille déjà dans les réglages de Thunderbird.
 ## Vérifier la présence de votre clé dans Thunderbird
 Avant de passer à la pratique, la première question à se poser est simple : Thunderbird a-t-il déjà une clé en mémoire pour vous ? Depuis que le logiciel gère OpenPGP par défaut, il se peut que vous en ayez configuré une sans même vous en souvenir.
 Pour voir si une clé est déjà associée à votre compte :
 1. Ouvrez Thunderbird et allez dans les **Paramètres du compte** (clic droit sur votre adresse mail dans la colonne de gauche).
 2. Dans le menu latéral, cliquez sur **Chiffrement de bout en bout**.
 3. Regardez la section **OpenPGP**.
    - Si vous voyez une suite de chiffres et de lettres (une "empreinte" ou Fingerprint) sous "Technologies de chiffrement", c'est que vous avez déjà une clé configurée.
    - Si c'est vide, vous n'avez pas encore de clé active pour ce compte.
 ## Gérer vos clés (Le gestionnaire OpenPGP)
 Une fois votre clé identifiée, vous pouvez en gérer les détails via le **Gestionnaire de clés OpenPGP**. C'est ici que Thunderbird centralise vos propres clés et celles de vos correspondants.
 Pour y accéder :
 1. Allez dans le menu principal (les trois barres horizontales **≡**).
 2. Sélectionnez **Outils** puis **Gestionnaire de clés OpenPGP**.
 ## Créer votre première clé OpenPGP
 Pour générer votre identité numérique directement dans Thunderbird, suivez ces étapes :
 1. **Lancez l'assistant :** Retournez dans les **Paramètres du compte** > **Chiffrement de bout en bout**.
 2. **Ajouter une clé :** Cliquez sur le bouton **Ajouter une clé...**.
 3. **Générer :** Sélectionnez l'option **Créer une nouvelle clé OpenPGP** puis cliquez sur **Continuer**.
 4. **Configuration :**
    - **Identité :** Vérifiez que votre adresse e-mail est la bonne.
    - **Validité :** Par défaut, Thunderbird propose une durée de 3 ans. Vous pouvez la modifier selon vos besoins.
    - **Paramètres avancés :** Le type de clé par défaut (ECC) est moderne et recommandé.
 5. **Confirmer :** Cliquez sur **Générer la clé**. Une fenêtre de confirmation apparaîtra : validez pour terminer l'opération.
 ### À savoir après la création
 Une fois la clé générée, elle apparaît avec son **empreinte numérique** dans vos paramètres. Thunderbird gère désormais cette clé en interne.
 Cependant, comme nous l'avons vu précédemment, cette clé reste pour l'instant confinée au logiciel de messagerie. Pour l'utiliser avec la commande `gpg` dans votre terminal et signer des fichiers locaux, il faudra passer par l'étape d'exportation.
 ## Le cloisonnement des clés
 Il est important de noter une distinction technique : **Thunderbird et votre système d'exploitation ne partagent pas la même base de données.**
 - **Thunderbird** utilise son propre stockage interne.
 - **Le terminal (la commande `gpg`)** utilise généralement le dossier système `~/.gnupg`.
 Par défaut, ces deux environnements sont étanches. Si vous souhaitez utiliser une clé créée dans Thunderbird pour signer des fichiers via votre terminal, il est nécessaire de créer un pont : vous devrez **exporter la clé** depuis Thunderbird pour l'**importer** manuellement dans votre trousseau système.
 ## Exporter la clé vers le système
 Pour que vos commandes `gpg` (comme `--clearsign`) fonctionnent dans votre terminal, vous devez extraire la clé de Thunderbird pour l'intégrer à votre trousseau système.
 ### Côté Thunderbird
 L'objectif est de créer un fichier temporaire contenant votre identité numérique :
 - Allez dans **Outils** > **Gestionnaire de clés OpenPGP**.
 - Faites un **clic droit** sur votre clé personnelle.
 - Choisissez **Exporter la ou les clés secrètes vers un fichier**.
 - Enregistrez le fichier sous le nom `ma_cle_privee.asc`.
 > **Attention :** Ce fichier est extrêmement sensible. Il contient votre clé secrète. Ne le partagez jamais et ne l'envoyez pas par e-mail.
 ###  Côté Terminal
 Il faut maintenant importer ce fichier dans votre environnement GPG système :
 - Ouvrez votre terminal et lancez la commande suivante :
    ```Bash
    gpg --import ma_cle_privee.asc
    ```
 - Une fois l'importation réussie, **supprimez immédiatement le fichier .asc** pour ne pas laisser traîner une copie de votre clé secrète sur votre disque dur.
 ### Vérification
 Pour confirmer que la manipulation a fonctionné, demandez à GPG la liste des clés privées disponibles :
 ```Bash
 gpg --list-secret-keys
 ```
 Si votre nom et votre adresse e-mail s'affichent, votre terminal est désormais prêt à signer des documents avec votre clé Thunderbird.
 ## Signer vos fichiers sans les modifier
 Maintenant que votre terminal reconnaît votre clé Thunderbird, vous pouvez signer n'importe quel document (un PDF, une image ou une archive) sans toucher au fichier original. Pour cela, nous allons utiliser la méthode de la **signature détachée**.
 ### La commande de signature
 Ouvrez votre terminal dans le dossier où se trouve votre document et lancez la commande suivante :
 ```Bash
 gpg --armor --detach-sign mon_fichier.pdf
 ```
 ### Le résultat : deux fichiers valent mieux qu'un
 Après avoir saisi votre mot de passe (celui de votre clé Thunderbird), GPG va générer un second fichier nommé `mon_fichier.pdf.asc`.
 - **Le fichier original :** `mon_fichier.pdf` reste intact et parfaitement lisible par n'importe quel lecteur PDF.
 - **La signature :** `mon_fichier.pdf.asc` est un petit fichier texte qui contient la preuve mathématique de l'authenticité du premier.
 Cette technique est idéale pour le partage de documents officiels ou techniques :
 1. **Intégrité préservée :** Vous ne modifiez pas l'octet de votre fichier source.
 2. **Liberté pour le destinataire :** Votre correspondant télécharge le fichier original normalement. S'il souhaite vérifier que vous en êtes bien l'auteur, il lui suffit d'utiliser le petit fichier `.asc` joint.
 3. **Compatibilité totale :** Cela fonctionne avec tous les types de fichiers, pas seulement le texte.
 ## Comment votre destinataire vérifie-t-il la signature ?
 Une fois que vous avez envoyé le fichier original (`mon_fichier.pdf`) et sa signature (`mon_fichier.pdf.asc`), votre correspondant peut vérifier l'intégrité du document en une seule commande.
 ### La commande de vérification
 Le destinataire doit placer les deux fichiers dans le même dossier et taper :
 ```Bash
 gpg --verify mon_fichier.pdf.asc mon_fichier.pdf
 ```
 ### Comprendre le résultat
 Le terminal renverra alors un message indiquant l'état de la signature :
 1. **"Bonne signature" (Good signature) :** C'est le signal vert. Le fichier est exactement celui que vous avez signé, aucun octet n'a été modifié. Le terminal affichera également votre nom et votre adresse e-mail.
 2. **"MAUVAISE signature" (BAD signature) :** Alerte rouge. Soit le fichier a été altéré après votre signature (corruption de données ou tentative de modification), soit la signature ne correspond pas à ce document.
 ### Une précision importante : la confiance
 Si c'est la première fois que votre correspondant vérifie l'une de vos signatures, il verra probablement un message d'avertissement indiquant que la clé n'est pas "certifiée par une autorité de confiance".
 C'est normal : cela signifie simplement que GPG a bien vérifié la **validité mathématique** de la signature, mais qu'il ne peut pas encore confirmer à 100 % que cette clé appartient bien à "Jean Dupont" sans une étape supplémentaire de certification. Pour un usage courant et grand public, le message "Bonne signature" est déjà la preuve que le fichier n'a pas été piraté.
 ## Partager votre clé publique
 La clé publique est votre "carte d'identité numérique". Sans elle, votre ami peut voir que le fichier est signé, mais il ne peut pas prouver que c'est _vous_ qui l'avez signé.
 ### Exporter la clé publique depuis Thunderbird
 Le processus est presque identique à l'export de la clé secrète, mais sans le danger :
 1. Retournez dans **Outils** > **Gestionnaire de clés OpenPGP**.
 2. Faites un clic droit sur votre clé.
 3. Choisissez cette fois : **Exporter la ou les clés publiques vers un fichier**.
 4. Enregistrez-le sous le nom `ma_cle_publique.asc`.
 ### Envoyer la clé
 Vous pouvez maintenant envoyer ce fichier `.asc` à votre ami par e-mail, par messagerie instantanée, ou même le publier sur votre site web. Il n'y a aucun risque de sécurité à diffuser ce fichier.
 ### Côté destinataire : l'importation
 Pour que votre ami puisse vérifier vos futurs documents, il doit intégrer votre clé à son propre système. Il lui suffit d'ouvrir son terminal et de taper :
 ```Bash
 gpg --import ma_cle_publique.asc
 ```
 Une fois cette manipulation faite, son ordinateur "connaît" officiellement votre identité numérique. Désormais, chaque fois qu'il lancera la commande `gpg --verify` sur l'un de vos fichiers, le terminal ne se contentera plus de dire que la signature est mathématiquement correcte : il affichera explicitement votre nom, confirmant que le document provient bien de vous.
 ## Vérifier l'identité : Le "Fingerprint" (Empreinte)
 Envoyer une clé par e-mail, c'est bien, mais comment votre ami peut-il être sûr qu'un pirate n'a pas intercepté l'envoi pour remplacer votre clé par la sienne ? Pour lever le doute, on utilise l'**empreinte numérique** (le _Fingerprint_).
 ### La rencontre de vive voix (Le top de la sécurité)
 Si vous voyez votre ami physiquement, c'est la méthode infaillible.
 - Ouvrez chacun votre terminal ou votre gestionnaire Thunderbird.
 - Comparez de vive voix la suite de chiffres et de lettres qui compose l'**empreinte** de votre clé.
 - Si les deux suites sont identiques, votre ami peut "signer" votre clé sur son ordinateur pour confirmer qu'il vous fait confiance à 100 %.
 ### Le croisement des canaux (La méthode pratique)
 Si vous ne pouvez pas vous voir, utilisez la stratégie du **multicanal**. C'est une technique simple pour éviter les interceptions :
 - Envoyez le fichier de votre clé (`.asc`) par **e-mail**.
 - Envoyez l'empreinte de la clé (le texte court de 40 caractères) via un **autre canal** : un SMS, une boucle Signal/WhatsApp, ou même l'afficher sur votre profil LinkedIn ou votre site personnel.
 Si un attaquant parvient à pirater votre boîte mail, il peut remplacer votre fichier de clé. Mais il est extrêmement improbable qu'il puisse _aussi_ pirater votre téléphone pour modifier le SMS que vous envoyez au même moment.
 En comparant l'empreinte reçue par mail avec celle reçue par SMS, votre ami a la certitude absolue qu'il possède votre **véritable identité numérique**.
 ## Comment afficher une empreinte
 L'empreinte est une suite unique de 40 caractères qui résume votre clé. C'est elle que vous devez comparer avec votre ami.
 ### Option 1 : Via l'interface de Thunderbird
 C'est la méthode la plus simple pour la lire à haute voix ou faire une capture d'écran :
 1. Allez dans **Paramètres du compte** > **Chiffrement de bout en bout**.
 2. Sous la section **OpenPGP**, vous verrez directement votre clé s'afficher avec une suite de caractères du type : `0x1234 5678 90AB...`
 3. Cliquez sur **Détails de la clé** pour l'afficher en grand et pouvoir la copier-coller.
 ### Option 2 : Via le Terminal (plus rapide pour un copier-coller)
 Si vous avez déjà importé votre clé dans votre système (comme vu précédemment), tapez simplement cette commande :
 ```Bash
 gpg --fingerprint votre@email.com
 ```
 Le terminal affichera alors un bloc d'informations. La ligne qui nous intéresse est celle intitulée **Empreinte de la clé** (ou _Key fingerprint_). Elle ressemble à ceci : `A1B2 C3D4 E5F6 G7H8 I9J0 K1L2 M3N4 O5P6 Q7R8 S9T0`
 ---
 ## Le test de vérité
 Une fois que vous avez cette suite de caractères, transmettez-la à votre ami (par SMS, Signal, ou de vive voix). Votre ami, de son côté, tape la même commande sur son ordinateur :
 ```Bash
 gpg --fingerprint votre@email.com
 ```
 **Si les deux suites sont rigoureusement identiques, la sécurité est totale.** Votre ami sait que la clé publique qu'il a importée est bien la vôtre, et non celle d'un imposteur.
--- a/20260308135822.png
+++ b/20260308135822.png
--- a/20260308142720.png
+++ b/20260308142720.png
--- a/20260308142917.png
+++ b/20260308142917.png
--- a/20260308143044.png
+++ b/20260308143044.png
--- a/20260308171916.png
+++ b/20260308171916.png
--- a/20260308172102.png
+++ b/20260308172102.png
--- a/20260313124448.png
+++ b/20260313124448.png
Author	SHA1	Message	Date
Cédrix	036bd6c995	add gscan2pdf : 2026-03-13 12:45:33	2026-03-13 12:45:33 +01:00
Cédrix	e50f900ba9	vault backup: 2026-03-13 09:01:21	2026-03-13 09:01:21 +01:00
Cédrix	ed2a6e0ab2	vault backup: 2026-03-12 21:19:17	2026-03-12 21:19:17 +01:00
Cédrix	0d66cc8991	vault backup: 2026-03-12 20:49:17	2026-03-12 20:49:17 +01:00
Cédrix	e177166362	vault backup: 2026-03-11 18:41:56	2026-03-11 18:41:56 +01:00
Cédrix	c0b6d77a42	vault backup: 2026-03-11 18:28:18	2026-03-11 18:28:18 +01:00
Cédrix	d9b5947a3d	vault backup: 2026-03-11 01:42:22	2026-03-11 01:42:22 +01:00
Cédrix	8330c2ff9e	vault backup: 2026-03-11 00:42:21	2026-03-11 00:42:21 +01:00
Cédrix	6b38351bc6	vault backup: 2026-03-10 08:14:50	2026-03-10 08:14:50 +01:00
Cédrix	1158950ba6	vault backup: 2026-03-10 08:12:18	2026-03-10 08:12:18 +01:00
Cédrix	5ffb7346bf	vault backup: 2026-03-10 07:59:48	2026-03-10 07:59:48 +01:00
Cédrix	081fcafcfb	vault backup: 2026-03-10 07:51:11	2026-03-10 07:51:11 +01:00
Cédrix	2f3b27e894	vault backup: 2026-03-08 21:46:41	2026-03-08 21:46:41 +01:00
Cédrix	237f95b0cb	vault backup: 2026-03-08 21:16:41	2026-03-08 21:16:41 +01:00
Cédrix	4c253e2ce5	vault backup: 2026-03-08 18:46:36	2026-03-08 18:46:37 +01:00
Cédrix	67bfdd7378	vault backup: 2026-03-08 18:16:35	2026-03-08 18:16:35 +01:00
Cédrix	7776689c23	vault backup: 2026-03-08 17:46:34	2026-03-08 17:46:34 +01:00
Cédrix	c27a1fae2e	vault backup: 2026-03-08 17:16:34	2026-03-08 17:16:34 +01:00
Cédrix	bd17601b11	add tcp article: 2026-03-08 14:35:24	2026-03-08 14:35:24 +01:00
Cédrix	6b7b830b78	vault backup: 2026-03-08 14:35:16	2026-03-08 14:35:16 +01:00
Cédrix	a9f7dac640	vault backup: 2026-03-08 14:05:16	2026-03-08 14:05:16 +01:00
Cédrix	38b8567964	vault backup: 2026-03-04 23:11:20	2026-03-04 23:11:20 +01:00
Cédrix	f1370deb26	vault backup: 2026-03-04 22:56:03	2026-03-04 22:56:03 +01:00
Cédrix	5bfdd47fd4	vault backup: 2026-03-04 22:26:03	2026-03-04 22:26:03 +01:00
Cédrix	fa0d32bf3b	vault backup: 2026-03-04 14:26:00	2026-03-04 14:26:00 +01:00
Cédrix	c49547e562	vault backup: 2026-03-02 11:56:05	2026-03-02 11:56:05 +01:00
Cédrix	44031ddfd2	vault backup: 2026-03-02 09:26:05	2026-03-02 09:26:05 +01:00
Cédrix	b5636a7b5f	vault backup: 2026-02-28 16:19:38	2026-02-28 16:19:38 +01:00
Cédrix	f7ff4527fc	vault backup: 2026-02-28 12:53:09	2026-02-28 12:53:09 +01:00
Cédrix	bd311566fe	vault backup: 2026-02-28 01:41:39	2026-02-28 01:41:39 +01:00
Cédrix	576b0dc6c0	vault backup: 2026-02-28 00:41:38	2026-02-28 00:41:38 +01:00
Cédrix	8591b642ef	vault backup: 2026-02-28 00:11:38	2026-02-28 00:11:38 +01:00
Cédrix	1a10194cc9	vault backup: 2026-02-27 23:11:38	2026-02-27 23:11:38 +01:00
Cédrix	e274005be3	vault backup: 2026-02-27 22:41:37	2026-02-27 22:41:37 +01:00
Cédrix	867469b1fe	vault backup: 2026-02-27 19:41:37	2026-02-27 19:41:37 +01:00
Cédrix	9d196557b7	ajout de ds940dw : 2026-02-27 14:01:53	2026-02-27 14:01:53 +01:00
Cédrix	d8d20349d8	vault backup: 2026-02-27 10:40:48	2026-02-27 10:40:48 +01:00
Cédrix	ca9e823a11	kobo : 2026-02-26 18:55:49	2026-02-26 18:55:49 +01:00
Cédrix	1c5ff64319	vault backup: 2026-02-26 18:52:56	2026-02-26 18:52:56 +01:00
Cédrix	0a5d0e975c	vault backup: 2026-02-23 19:51:43	2026-02-23 19:51:43 +01:00
Cédrix	f30d7b3d32	vault backup: 2026-02-23 01:51:14	2026-02-23 01:51:14 +01:00
Cédrix	851895a2d3	vault backup: 2026-02-22 17:21:13	2026-02-22 17:21:13 +01:00
Cédrix	a4c6de9a65	ajout de openldap: 2026-02-22 09:50:34	2026-02-22 09:50:34 +01:00
Cédrix	692365b3e2	vault backup: 2026-02-22 09:21:23	2026-02-22 09:21:23 +01:00
Cédrix	318a0874ed	vault backup: 2026-02-22 00:15:48	2026-02-22 00:15:48 +01:00
Cédrix	a85d7ad570	vault backup: 2026-02-22 00:14:09	2026-02-22 00:14:09 +01:00
Cédrix	95dfe4d7e2	vault backup: 2026-02-21 17:31:49	2026-02-21 17:31:49 +01:00
Cédrix	8ae222dfb1	Suppression du dossier suivi par erreur et mise à jour du gitignore	2026-02-21 17:26:19 +01:00