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

.obsidian/graph.json

@@ -46,6 +46,6 @@
   "repelStrength": 10,
   "linkStrength": 1,
   "linkDistance": 250,
-  "scale": 1,
+  "scale": 0.9999999999999991,
   "close": true
 }

articles/2026/Comprendre RemoveIPC.md

@@ -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`.**

articles/2026/Déploiement d'Apache Guacamole via Docker sur Debian 12 (Bookworm).md

@@ -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.
+    
+

articles/2026/Déployer DocuSeal sur Debian 13.md

@@ -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.

articles/2026/convertir un fichier mkv en mp4.md

@@ -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".
+

articles/2026/gscan2pdf sous linux mint.md

@@ -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
+```

articles/2026/utiliser pgp sous linux.md

@@ -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.