Comment protéger un fichier zip avec un mot de passe à l’aide d’un script UNIX ?

1. Utilisation de l'option `-p` (Least Secure - non recommandé pour les données sensibles) :

```bash

#!/bin/bash

ZIP_FILE="mon_archive.zip"

MOT DE PASSE="mon_secret_password"

FILES_TO_ZIP="fichier1.txt fichier2.pdf répertoire1"

zip -p "$MOT DE PASSE" "$ZIP_FILE" "$FILES_TO_ZIP"

echo "Fichier zip '$ZIP_FILE' créé avec un mot de passe (méthode moins sécurisée)."

```

* Explication :

* `zip -p "$PASSWORD" "$ZIP_FILE" "$FILES_TO_ZIP"` :Cette commande crée le fichier zip.

* `-p "$PASSWORD"` :Spécifie le mot de passe directement sur la ligne de commande. C'est là le problème !

* `"$ZIP_FILE"` :Le nom du fichier zip à créer.

* `"$FILES_TO_ZIP"` :Les fichiers et répertoires que vous souhaitez inclure dans l'archive zip. Utilisez des guillemets pour gérer les espaces dans les noms de fichiers.

* Risque de sécurité : Cette méthode est la *moins* sécurisée. Le mot de passe est transmis directement en tant qu'argument de ligne de commande. Cela signifie:

* Visible dans la liste des processus : Toute personne ayant accès à la liste des processus du système (commande `ps`) peut voir le mot de passe.

* Stocké dans l'historique du shell : Le mot de passe peut être enregistré dans le fichier historique du shell (par exemple, `.bash_history`).

2. Utilisation de l'option `-e` avec une invite de mot de passe interactive (mieux) :

```bash

#!/bin/bash

ZIP_FILE="mon_archive.zip"

FILES_TO_ZIP="fichier1.txt fichier2.pdf répertoire1"

zip -e "$ZIP_FILE" "$FILES_TO_ZIP"

echo "Fichier zip '$ZIP_FILE' créé avec un mot de passe (invite interactive)."

```

* Explication :

* `zip -e "$ZIP_FILE" "$FILES_TO_ZIP"` :

* `-e` :Active le cryptage. La commande `zip` vous demandera de saisir et de vérifier le mot de passe de manière interactive.

* Amélioration de la sécurité : C'est mieux que `-p` car le mot de passe n'est pas stocké sur la ligne de commande. Il est saisi directement à l'invite.

* Limites :

* Non scriptable : Nécessite une interaction humaine pour saisir le mot de passe, ce qui le rend inadapté aux scripts entièrement automatisés.

3. Utilisation de l'option `-P` (légèrement meilleure, toujours pas idéale pour les données sensibles) :

```bash

#!/bin/bash

ZIP_FILE="mon_archive.zip"

MOT DE PASSE="mon_secret_password"

FILES_TO_ZIP="fichier1.txt fichier2.pdf répertoire1"

zip -P "$MOT DE PASSE" "$ZIP_FILE" "$FILES_TO_ZIP"

echo "Fichier zip '$ZIP_FILE' créé avec un mot de passe (P majuscule - moins sécurisé que p minuscule)."

```

* Explication : `-P` est similaire à `-p` mais traite le mot de passe comme une chaîne littérale et n'y interprète aucun métacaractère shell.

* Sécurité : Légèrement meilleur que `-p` car il évite une interprétation involontaire du shell, mais le mot de passe est *toujours* sur la ligne de commande et vulnérable à l'exposition de la liste des processus et de l'historique. Évitez cela pour les données vraiment sensibles.

4. Utilisation de `openssl` pour un cryptage plus sécurisé (recommandé pour les données sensibles) :

Cette approche utilise « openssl » pour créer une archive cryptée de manière sécurisée. Ceci est généralement considéré comme une méthode plus robuste pour protéger les données sensibles par rapport au cryptage « zip » intégré.

```bash

#!/bin/bash

ZIP_FILE="my_archive.zip.enc" # Notez l'extension .enc

FILES_TO_ZIP="fichier1.txt fichier2.pdf répertoire1"

# Créez d'abord une archive tar

tar -czf tmp_archive.tar.gz "$FILES_TO_ZIP"

# Chiffrer l'archive tar avec openssl

openssl enc -aes-256-cbc -salt -in tmp_archive.tar.gz -out "$ZIP_FILE"

# Supprimer l'archive tar temporaire

rm tmp_archive.tar.gz

echo "Archive cryptée '$ZIP_FILE' créée avec openssl."

```

* Explication :

* `tar -czf tmp_archive.tar.gz "$FILES_TO_ZIP"` :Crée une archive tar compressée des fichiers. `tar` est un utilitaire Unix standard pour l'archivage de fichiers et de répertoires. `gzip` compresse l'archive.

* `openssl enc -aes-256-cbc -salt -in tmp_archive.tar.gz -out "$ZIP_FILE"` :crypte l'archive tar à l'aide d'OpenSSL.

* `openssl enc` :appelle la commande de chiffrement OpenSSL.

* `-aes-256-cbc` :Spécifie l'algorithme AES (Advanced Encryption Standard) avec une clé de 256 bits en mode CBC (Cipher Block Chaining). AES-256 est un algorithme de cryptage puissant.

* `-salt` :ajoute un sel aléatoire au mot de passe avant le cryptage. Ceci est *crucial* pour empêcher les attaques de table arc-en-ciel. OpenSSL générera automatiquement le sel.

* `-in tmp_archive.tar.gz` :Spécifie le fichier d'entrée (l'archive tar).

* `-out "$ZIP_FILE"` :Spécifie le fichier de sortie (l'archive cryptée). L'extension `.enc` est une convention courante.

* Invite de mot de passe : OpenSSL vous *demandera* le mot de passe sur la ligne de commande. C'est mieux que de le faire passer comme argument.

* Avantages en matière de sécurité :

* Cryptage fort : Utilise AES-256, un algorithme de cryptage très puissant.

* Mot de passe salé : Le salage empêche les attaques précalculées (tables arc-en-ciel) qui tentent de deviner les mots de passe.

* Aucun mot de passe sur la ligne de commande : Le mot de passe est saisi de manière interactive, évitant ainsi son exposition dans les listes de processus ou l'historique du shell.

* Décryptage : Pour décrypter le fichier, utilisez la commande `openssl` suivante (le mot de passe vous sera demandé) :

```bash

openssl enc -d -aes-256-cbc -salt -in my_archive.zip.enc -out tmp_archive.tar.gz

tar -xzf tmp_archive.tar.gz

rm tmp_archive.tar.gz

```

* `-d` :Décrypter

* `-x` :Extraire

5. Utilisation d'un fichier de mot de passe ou d'une variable d'environnement (plus scriptable, avec mises en garde) :

Si vous avez absolument besoin d'une solution scriptable *sans* interaction de l'utilisateur, vous pouvez utiliser un fichier de mot de passe ou une variable d'environnement. Cependant, vous devez comprendre les implications en matière de sécurité.

```bash

#!/bin/bash

ZIP_FILE="mon_archive.zip.enc"

FILES_TO_ZIP="fichier1.txt fichier2.pdf répertoire1"

PASSWORD_FILE="mot de passe.txt"

# Assurez-vous que le fichier de mots de passe existe et dispose des autorisations appropriées (lecture seule pour le propriétaire)

si [ ! -f "$PASSWORD_FILE"]; alors

echo "Erreur :le fichier de mots de passe '$PASSWORD_FILE' est introuvable."

sortie 1

fi

chmod 400 "$PASSWORD_FILE" # Lecture seule pour le propriétaire

# Créez d'abord une archive tar

tar -czf tmp_archive.tar.gz "$FILES_TO_ZIP"

# Chiffrer l'archive tar avec openssl

openssl enc -aes-256-cbc -salt -pass fichier :"$PASSWORD_FILE" -in tmp_archive.tar.gz -out "$ZIP_FILE"

# Supprimer l'archive tar temporaire

rm tmp_archive.tar.gz

echo "Archive cryptée '$ZIP_FILE' créée à l'aide d'openssl (mot de passe du fichier)."

```

* Explication :

* `PASSWORD_FILE="password.txt"` :Définit le chemin d'accès au fichier contenant le mot de passe. Ce fichier est essentiel pour être correctement sécurisé !

* `chmod 400 "$PASSWORD_FILE"` :définit les autorisations sur le fichier de mots de passe en lecture seule pour le propriétaire. Ceci est essentiel pour empêcher tout accès non autorisé.

* `openssl enc -aes-256-cbc -salt -pass file:"$PASSWORD_FILE" ...` :L'option `-pass file:"$PASSWORD_FILE"` indique à OpenSSL de lire le mot de passe à partir du fichier spécifié.

* Considérations de sécurité :

* Protection des fichiers par mot de passe : Le fichier `password.txt` doit être extrêmement bien protégé.

* Stockez-le en dehors de la racine Web (si vous êtes sur un serveur Web).

* Donnez-lui des autorisations restrictives (par exemple, `chmod 400 password.txt` - en lecture seule pour le propriétaire).

* Ne l'archivez pas dans le contrôle de version (Git, etc.).

* Variables d'environnement : Une alternative consiste à stocker le mot de passe dans une variable d'environnement. Utilisez `export PASSWORD=your_secret_password` (mais sachez que cela peut toujours être visible via `ps` ou dans l'historique du shell si vous ne faites pas attention). Ensuite, utilisez `-pass env:PASSWORD` dans la commande `openssl`. Ne codez jamais en dur le mot de passe directement dans le script.

* Gestion des clés : Pour les données hautement sensibles, envisagez d'utiliser des systèmes de gestion de clés (KMS) ou des modules de sécurité matériels (HSM) au lieu de stocker les mots de passe dans des fichiers ou des variables d'environnement.

Considérations importantes et bonnes pratiques :

* Algorithme de cryptage : Utilisez toujours des algorithmes de cryptage puissants comme AES-256. Évitez les algorithmes plus anciens et plus faibles comme le cryptage intégré de ZIP (qui est facilement brisé).

* Salage : Utilisez toujours un sel avec votre mot de passe. L'option `-salt` d'OpenSSL le fait automatiquement.

* Complexité du mot de passe : Choisissez des mots de passe forts et complexes, difficiles à deviner. Utilisez un générateur de mot de passe si nécessaire.

* Rotation des clés : Modifiez (faites pivoter) régulièrement vos clés de cryptage/mots de passe.

* Stockage sécurisé : Protégez vos clés de cryptage/mots de passe avec autant de diligence que vous protégez les données elles-mêmes.

* Principe du moindre privilège : Donnez au script uniquement les autorisations nécessaires pour effectuer sa tâche.

* Audit : Enregistrez lorsque des opérations de chiffrement et de déchiffrement ont lieu à des fins d'audit.

* Gestion des erreurs : Incluez la gestion des erreurs dans votre script pour détecter les problèmes potentiels et empêcher l'exposition des données sensibles.

* Fichiers temporaires : Si vous utilisez des fichiers temporaires (comme dans les exemples `openssl`), assurez-vous de les supprimer en toute sécurité après utilisation. `shred` ou `wipe` peuvent être utilisés pour cela, mais ils nécessitent une utilisation prudente. Le simple fait d'utiliser `rm` laisse les données récupérables.

* Évitez le cryptage intégré de ZIP : Le cryptage intégré à l'utilitaire « zip » est généralement considéré comme faible et doit être évité pour les données sensibles. `openssl` est beaucoup plus sécurisé.

Choisir la bonne méthode :

* Sécurité la plus élevée (et généralement la plus simple) : Utilisez « openssl » et saisissez manuellement le mot de passe à l'invite.

* Scriptable, mais avec des risques : Si vous avez besoin d'une solution scriptable, utilisez `openssl` avec un fichier de mot de passe ou une variable d'environnement, mais *uniquement* si vous pouvez garantir la sécurité du stockage du mot de passe. Comprenez les risques. Pensez à KMS ou HSM pour les données très sensibles.

* Évitez à tout prix `zip -p` et `zip -P` pour les données sensibles.

N'oubliez pas d'adapter ces scripts à vos besoins spécifiques et d'examiner attentivement les implications de sécurité de chaque méthode. Donnez toujours la priorité à la sécurité des données lorsque vous traitez des informations sensibles.