Chiffrer vos dossiers sensibles pour les stocker sur votre Cloud préféré sans danger
Published: 2022-10-14 18:09:34

Photo de couverture par [Erik Mclean](https://unsplash.com/@introspectivedsgn?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) sur [Unsplash](https://unsplash.com/s/photos/lock?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)

---

Récemment, j'ai fait face à une problématique concernant la protection de mes données. Je souhaitais conserver des fichiers que je considère comme sensible sur Google Drive, mais je n'ai pas une grande confiance en ce dernier pour stocker ce genre de données. Je vous partage ainsi aujourd'hui une méthode que j'utilise pour chiffrer facilement vos fichiers afin de pouvoir les stoker où vous le voulez.

TLDR : 
```zsh
$ brew install gnupg # Install gnupg on macOS
$ export GPG_TTY=$(tty) # Evite l'erreur indiquant un probléme d'ioctl

##-- Compression + Chiffrement
$ tar -cvzf - <dossier_à_compresser> | gpg -c > <nom_du_tar_compresser_et_chiffrer> # Création d'une archive compressée et chiffrée
# Ex: tar -cvzf - test_file | gpg -c > test_files.tar.gz.gpg

##-- Déchiffrement + décompression
$ gpg -d <archive_chiffrer_a_dechiffrer> | tar xvzf - -C <chemin_ou_mettre_archive> # Déchiffre et décompresse l'archive dans le chemin donné
# Ex: gpg -d test_files.tar.gz.gpg | tar xvzf - -C ./test_file
```


### Ma problématique en détail

Comme j'ai pu rapidement l'énoncé, mon but est de pouvoir stocker des fichiers "sensibles" (chacun définis ce qu'il considère comme sensible ou non) sur différent Clouds Providers. À titre personnel, je me méfie de Google Drive et de ce qu'il peut faire avec mes données (analyse, revente pseudo-anonymiser...). 
Cette réticence n'est pas spécifique à Google, mais aussi à tous les autres Cloud Providers propriétaires et privées. Par ailleurs, je vous conseille de dupliquer la sauvegarde de vos données sur deux Clouds différents, vous mettant à l'abri si l'un de ces derniers décide de fermer ses portes (un peu comme hubiC 😉).

Mon idée était donc d'essayer de trouver un moyen de chiffrer et de déchiffrer mes fichiers rapidement et facilement, en utilisant une chaine de caractères comme clef (chiffrement symétrique).

### Les dépendances nécessaires

Pour pouvoir chiffrer nos données, nous allons utiliser la commande _tar_ coupléé avec l'utilitaire _GnuPG 2.0_. L'ensemble des commandes seront réalisé sur macOS, mais sont naturellement adaptables à tous systèmes Unix et Windows.

#### Installer GnuPG 2.0

```zsh
$ brew install gnupg
# Pour les machines Linux basés sur debian
# sudo apt-get install gnupg
```
Voilà, nous venons d'installer l'ensemble des dépendances nécessaires, car la commande _tar_ est déjà présentes sur macOS (et Linux). 🥳 

#### Un premier exemple sans compresser le dossier (pour bien comprendre ce qu'il se passe)

Nous allons commencer par essayer de transformer un dossier en un fichier _tar_ non compressé. Nous allons ensuite le chiffrer et observer la différence entre les deux fichiers pour observer si notre chiffrement est utile.

**1) Commençons par créer un dossier et quelques fichiers de test**
```zsh
$ mkdir test_folders # Créons notre dossier pour contenir les fichier
$ cd test_folders # Direction notre dossier fraichement créé
$ for i in $(seq 10); do echo "Mon fichier numéro $i" > fichier_$i; done # Création de 10 fichiers 
$ ls # On vérifie que l'on a nos fichier créés
# fichier_1	fichier_10	fichier_2	fichier_3	 
 fichier_4	fichier_5	fichier_6	fichier_7	 
 fichier_8	fichier_9
```

**2) Créons une archive tar**

Nous avons ainsi un dossier d'exemple prêt à être regroupé en un fichier _tar_.
```zsh
$ tar -cvf test_folders.tar test_folders/ # Créons une archive tar nommé test_folders.tar à partir du dossier test_folders
```
La commande précédente nous permet de créer une archive _tar_ (*test_folders.tar*) à partir du dossier source *test_folders*. 
Les options de la commande _tar_ :

- **-c** : Créer une nouvelle archive
- **-v** : Active le mode verbeux
- **-f** : Définis le nom de notre archive

D'ailleurs, pour informations, une archive _tar_ n'est qu'un simple fichier regroupant tous les autres fichiers combinés à quelques metadatas. C'est donc pour cette raison que nous pouvons observer son contenu avec la commande _cat_.
```zsh
$ cat test_folders.tar
test_folders/000755 000766 001750 00000000000 14322264445 013130 5ustar00VALENTIN000000 000000 test_folders/fichier_2000644 000766 001750 00000000026 14322264445 014703 0ustar00VALENTIN000000 000000 Mon fichier numéro 2
test_folders/fichier_5000644 000766 001750 00000000026 14322264445 014706 0ustar00VALENTIN000000 000000 Mon fichier numéro 5
test_folders/fichier_4000644 000766 001750 00000000026 14322264445 014705 0ustar00VALENTIN000000 000000 Mon fichier numéro 4
test_folders/fichier_3000644 000766 001750 00000000026 14322264445 014704 0ustar00VALENTIN000000 000000 Mon fichier numéro 3
test_folders/fichier_6000644 000766 001750 00000000026 14322264445 014707 0ustar00VALENTIN000000 000000 Mon fichier numéro 6
test_folders/fichier_1000644 000766 001750 00000000026 14322264445 014702 0ustar00VALENTIN000000 000000 Mon fichier numéro 1
test_folders/fichier_8000644 000766 001750 00000000026 14322264445 014711 0ustar00VALENTIN000000 000000 Mon fichier numéro 8
test_folders/fichier_9000644 000766 001750 00000000026 14322264445 014712 0ustar00VALENTIN000000 000000 Mon fichier numéro 9
test_folders/fichier_7000644 000766 001750 00000000026 14322264445 014710 0ustar00VALENTIN000000 000000 Mon fichier numéro 7
test_folders/fichier_10000644 000766 001750 00000000027 14322264445 014763 0ustar00VALENTIN000000 000000 Mon fichier numéro 10
```

**3) Chiffrons notre archive**

Nous allons maintenant utiliser _gpg_ pour chiffrer notre archive _tar_.
```zsh
$ export GPG_TTY=$(tty) # Evite l'erreur indiquant un probléme d'ioctl
$ gpg -c test_folders.tar > test_folders.tar.gpg # Chiffrer l'archive tar en une autre archive chiffré
```

Pendant l'exécution de la commande, GPG va vous demander une "passphrase" pour encrypter votre archive. Cette passphrase devra être répété ensuite. Il faut aussi bien noter cette passphrase car vous allez en avoir besoin pour décrypter votre archive. Je vous conseille de stocker cette passphrase dans un gestionnaire de mot de passe.

L'option de _gpg_ :

- **-c** : Créer un nouveaux fichier chiffrer symétriquement

*Note : Pour vous déplacer dans GPG lorsque cette commande vous demande votre passphrase, utiliser la touche _tab_ et _entrer_.* 

Après l'exécution de _gpg_, vous devriez avoir une archive nommée _test_folders.tar.gpg_. Si nous regardons ce nouveau fichier, nous observons que le contenu de ce dernier est illisible. Cela signifie ainsi que notre archive est bien chiffrée.
```zsh
$ cat test_folders.tar.gpg
?-???A?Y?G??Q??]?$???????[|??A?t??j?ļ?]?n?lN?B???M?R???/?ʸ6?S???cr?%?????????L϶??˭^?,?귀F?\E?}?a???u????)T(pI?Qa??ӎ?y?nD^????
                                                                                                                             ?HU???L??T?Wk?,?
??d?V?x?Q$??P?Cn?2l???% ?x??????H?                                                                                                           .???*^D?G?
.???p?Bm6???k٘?U???????????vQ???rPv??W?9????~U
                                             ~#??9(r|`c??@3?E???&?]?4?????V:???
# Exemple avec l'archive chiffré utilisant la passphrase "123456"
``` 

**4) Déchiffrons et décompressons notre archive**

Nous allons maintenant déchiffrer et décompresser notre archive en une seule fois.
```zsh
$ mkdir second_folders # On utilise ce dossier pour stocker les fichiers de notre archive
$ gpg -d test_folders.tar.gpg | tar -xvf - -C second_folders/ # On décrypte le test_folders.tar.gpg puis on exporte les fichier de notre archive dans notre second dossier  

## On retrouve bien toutes notre archive dans notre second dossier
$ ls second_folders/
test_folders
$ ls second_folders/test_folders
fichier_1	fichier_10	fichier_2	fichier_3	fichier_4	fichier_5	fichier_6	fichier_7	fichier_8	fichier_9
$ cat second_folders/test_folders/fichier_1
Mon fichier numéro 1
``` 
La commande `gpg -d <fichier_chiffrer>` nous permet de déchiffrer (avec l'option `-d`) notre archive. _gpg_ nous demande alors notre passphrase. 

La commande `tar -xvf - -C <chemin>` nous permet d'extraire les fichiers contenus dans l'archive (avec l'option `-x`) de manière verbeuse (`-v`) à partir du fichier (`-f`) '-' représentant l'entrée standard dans le dossier représenté par le chemin définis avec l'option `-C`. 

*Note : il est possible que gpg ne vous demande par votre passphrase pour déchiffrer l'archive. Pas de panique, cela ne signifie pas que tout le monde peut déchiffrer votre archive. En réalité, par mesure d'efficacité, gpg stocke dans le cache de votre ordinateur votre passphrase pour vous permettre de ne pas devoir retaper cette dernière plusieurs fois. Pour vérifier mes propos, vous pouvez utiliser l'option `--no-symkey-cache` à chaque appel de gpg. Vous verrez alors que gpg redemande bien la passphrase à chaque utilisation et que vos données sont bien sécurisées.*

Bravo 🎉, vous venez de créer une archive chiffrée à partir d'un dossier puis de la déchiffrer dans la foulée. La dernière étape est maintenant de faire la même chose, mais en compressant notre archive pour économiser de la place dans notre cloud.

**Création d'une archive compressée et chiffrée (et son inverse)**

Par mesure d'efficacité, nous allons maintenant réaliser les opérations précédentes de manière chainées. Pour compresser une archive, rien de plus simple. Il suffit d'ajouter l'option `-z` à la commande _tar_ (à la création de l'archive, **mais** aussi à son extraction).

- Création de notre archive compressée puis chiffrage dans la foulée

```zsh
$ tar -cvzf - test_folders | gpg -c > test_folders.tar.gz.gpg
a test_folders
a test_folders/fichier_2
a test_folders/fichier_5
a test_folders/fichier_4
a test_folders/fichier_3
a test_folders/fichier_6
a test_folders/fichier_1
a test_folders/fichier_8
a test_folders/fichier_9
a test_folders/fichier_7
a test_folders/fichier_10
$ ls test_folders		test_folders.tar.gz.gpg
```

- Déchiffrage de notre archive puis décompression et extraction de cette dernière dans la foulée.

```zsh
$ mkdir second_folders
$ gpg -d test_folders.tar.gz.gpg | tar xvzf - -C ./second_folders
gpg: AES256.CFB encrypted data
gpg: encrypted with 1 passphrase
x test_folders/
x test_folders/fichier_2
x test_folders/fichier_5
x test_folders/fichier_4
x test_folders/fichier_3
x test_folders/fichier_6
x test_folders/fichier_1
x test_folders/fichier_8
x test_folders/fichier_9
x test_folders/fichier_7
x test_folders/fichier_10
$ ls second_folders/test_folders/
fichier_1	fichier_10	fichier_2	fichier_3	fichier_4	fichier_5	fichier_6	fichier_7	fichier_8	fichier_9
```

Et voilà, vous savez maintenant comment générer des archives encryptées et compressées avec une passphrase de votre choix 👏.

### Bonus : vérifier l'intégrité de nos données.

Lorsque l'on stocke des données dans des Clouds, rien ne peut nous assurer que nos fichiers sont intègres (beaucoup d'erreur peuvent intervenir dans le transport). Nous allons donc utiliser le shasum de nos archives pour en créer un fichier à stocker sur notre cloud.
Vous pouvez utiliser la commande `shasum` native ou installer une implémentation `sha256sum` si vous le souhaitez.

```zsh
$ shasum test_folders.tar.gpg | cut -d ' ' -f 1 > sha_sum_for_test_folders
```

Vous n'avez plus qu'à stocker le fichier `sha_sum_for_test_folders` sur vos Clouds providers. Lorsque vous téléchargez votre dossier depuis votre cloud sur votre ordinateur, vous pouvez vérifier son intégrité en téléchargeant aussi le fichier contenant le shasum et en le comparant au shasum de votre archive provenant de votre cloud.
```zsh
$ [ $(shasum test_folders.tar.gpg | cut -d ' ' -f 1) = $(cat ./sha_sum_for_test_folders) ] && echo "Le fichier est intègre 🥳" || echo "Oups.. Le fichier est corrompu 😭"
```

Bravo, vous pouvez maintenant être sûr que vos données sont chiffrés et confidentielle sur votre Cloud et que ces dernières sont aussi intègres 👍.

### Le mot de la fin

Vous savez maintenant comment être maitre dans le chiffrement de vos données et dormir sur vos deux oreilles en sachant que vos données sont illisibles par vos Clouds providers.  

N'hésitez pas à partager l'article, ou à me contacter pour discuter tech si vous le voulez.

Je partage d'autres articles ou des tutos simples pour tous afin d'améliorer l'expérience de vos utilisateurs, le référencement, la sécurité et parfois même le management de vos projets alors n'hésitez pas à me suivre ou à lire d'autre de mes articles ou formations et si vous ne voulez pas…

![GIF Kaamelott cassez vous](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/75mvxvi0okoq70q8drc9.gif)

et bonne journée 🥳

PS : Si vous êtes intéressé par le Dev Front plus spécifiquement, go check @sidali et ses articles / formations faits avec ❤️ (et passion) sur tous ses sujets.
PSS : Si vous êtes intéressé par la Cybersécurité, go check @emiliebout et ses articles / formations faits avec passion (et ❤️) sur tous ses sujets.