markdown
Copier

# 🔐 EncFS - Chiffrement de fichiers

## 📌 Description
**EncFS** est un outil de **chiffrement transparente** de fichiers en espace utilisateur (FUSE). Il permet de créer un **système de fichiers chiffré** monté dans un répertoire, accessible comme un dossier normal, mais dont le contenu est **totalement chiffré** sur le disque.

Ce guide explique comment :
- Installer EncFS.
- Créer un conteneur chiffré sur un **support amovible** (clé USB, carte SD).
- Automatiser le montage/démontage via un script (`coffre`).

---

---

## 🛠 Prérequis
   Composant          | Description                                                                 |
 |--------------------|-----------------------------------------------------------------------------|
 | **Système Linux**  | Compatible avec **FUSE** (la plupart des distributions modernes).       |
 | **Droits root**    | Nécessaire pour installer des paquets et configurer des scripts système. |
 | **Support amovible** | Clé USB ou carte SD (formatée ou non).                                   |
 | **FUSE**           | Généralement installé par défaut. Sinon : `sudo apt install fuse`.     |

---

## 🚀 Installation

### 1️⃣ Installer EncFS
```bash
sudo apt install encfs
```

📁 Préparation des répertoires
1️⃣ Créer les répertoires
Dans votre répertoire personnel, créez :
```bash
mkdir ~/encrypted  # Répertoire chiffré (stockage des données)
mkdir ~/decrypted  # Répertoire déchiffré (accès aux données)
```


2️⃣ Formater le support amovible (optionnel)
Si vous souhaitez stocker la clé de chiffrement (passphrase.bin) sur un support amovible (ex: clé USB ou carte SD) :
```bash
dd if=/dev/urandom of=/media/xavier/Secure/passphrase.bin bs=16k count=1
```

⚠️ Attention :

Remplacez /media/xavier/Secure/ par le chemin vers votre support amovible.
Cette commande écrase le fichier passphrase.bin s'il existe déjà.


🔒 Création du conteneur EncFS
1️⃣ Initialiser le conteneur
Exécutez la commande suivante pour lier les répertoires encrypted et decrypted :
```bash
encfs ~/encrypted ~/decrypted
```

2️⃣ Choisir le mode de sécurité

Sélectionnez le mode p (paranoïaque) pour une sécurité maximale.
Définissez un mot de passe temporaire (sera remplacé par passphrase.bin plus tard).

🔑 Génération de la passphrase
1️⃣ Générer passphrase.bin
Utilisez ssh-keygen pour créer une clé RSA qui servira de passphrase :
```bash
ssh-keygen -t rsa -f passphrase.bin
```


💡 Où placer passphrase.bin ?

Sur un support amovible (recommandé) : /media/$USER/Usb/passphrase.bin.
Ou dans un répertoire sécurisé de votre système.


2️⃣ Associer passphrase.bin au conteneur EncFS
Exécutez la commande suivante pour lier la passphrase au conteneur :
```bash
echo -n "Enter current password: " && read -s PASSWORD && (echo \$PASSWORD && base64 -w 0 passphrase.bin) | encfsctl autopasswd ~/.encrypted
```

⚠️ Explications :

read -s PASSWORD : Demande votre mot de passe temporaire (celui défini lors de la création du conteneur).
base64 -w 0 passphrase.bin : Encode la passphrase pour une utilisation sécurisée.


3️⃣ Monter le conteneur avec passphrase.bin
Désormais, vous pouvez monter le conteneur sans mot de passe :
```bash
base64 -w 0 passphrase.bin | encfs -S ~/.encrypted ~/decrypted
```


4️⃣ Démontage manuel
Pour fermer l'accès au conteneur :
```bash
fusermount -u ~/decrypted
```

🤖 Automatisation via le script coffre
1️⃣ Préparer le script


Créez un fichier nommé coffre dans /usr/local/sbin/ :
```bash
sudo nano /usr/local/sbin/coffre
```


Collez le contenu suivant (exemple de script) :
```bash
#!/bin/bash

MOUNT_POINT="\$HOME/decrypted"
ENCRYPTED_DIR="\$HOME/encrypted"
PASSPHRASE_FILE="/media/\$USER/SECURE/passphrase.bin"

case "\$1" in
    open)
        if [ -f "\$PASSPHRASE_FILE" ]; then
            base64 -w 0 "\$PASSPHRASE_FILE" | encfs -S "\$ENCRYPTED_DIR" "\$MOUNT_POINT"
            echo "✅ Coffre ouvert : \$MOUNT_POINT"
        else
            echo "❌ Fichier passphrase.bin introuvable sur le support amovible."
            exit 1
        fi
        ;;
    close)
        fusermount -u "\$MOUNT_POINT"
        echo "🔒 Coffre fermé."
        ;;
    *)
        echo "Usage: coffre {open|close}"
        exit 1
        ;;
esac
```

Rendez le script exécutable :
```bash
sudo chmod +x /usr/local/sbin/coffre
```

2️⃣ Labeliser le support amovible

Insérez votre clé USB ou carte SD.


Vérifiez son label avec :
```bash
lsblk -o NAME,LABEL,MOUNTPOINT
```


Si nécessaire, labelisez-le en SECURE :
```bash
sudo e2label /dev/sdX1 SECURE
```


⚠️ Remplacez /dev/sdX1 par le périphérique réel (ex: /dev/sdb1).


Montez le support (si ce n'est pas automatique) :
```bash
mkdir -p /media/\$USER/SECURE
sudo mount LABEL=SECURE /media/\$USER/SECURE
```

3️⃣ Utilisation du script

  
      Commande
      Action
   
      coffre open
      Monte le conteneur chiffré (nécessite que passphrase.bin soit présent sur le support amovible).
     
      coffre close
      Démonte le conteneur.
 
⚠️ Limitations et Sécurité
  
      Point à vérifier
      Description
     
      Support amovible
      Le script coffre suppose que le support est monté sur /media/$USER/SECURE/.
    
      Permissions
      Assurez-vous que l'utilisateur a les droits pour monter/démonter FUSE.
       
      Sauvegarde de passphrase.bin
      Perte = données inaccessibles ! Conservez une copie sécurisée.
        
      Chiffrement du support
      Le support contenant passphrase.bin n'est pas chiffré par défaut. Utilisez LUKS pour le sécuriser.
    


📜 Licence
Ce guide et les scripts associés sont sous licence MIT. Vous êtes libre de les utiliser, modifier et distribuer.