Chiffrer des données d'application

Cet article montre comment utiliser Cloud Key Management Service pour chiffrer directement les données d'application sur un client, avant de les transmettre sur un réseau.

Dans cet exemple, les données chiffrées sont transmises à Google Cloud et stockées dans un bucket Cloud Storage. Cloud Storage est également compatible avec le chiffrement automatique côté serveur à l'aide de clés de chiffrement gérées par le client, qui automatise l'ensemble de ce processus. Pour protéger les données d'application avant de les transmettre à Google Cloud, nous vous recommandons d'utiliser la bibliothèque Tink.

La bibliothèque Tink est une bibliothèque multiplate-forme multilingue qui fournit des API simples et à l'épreuve des usages abusifs pour les tâches de cryptographie courantes. Compatible avec Java, Python, C++, Go, Objective-C et d'autres langages, ainsi que des services de stockage d'objets et de base de données relationnelles, elle peut être utilisée pour chiffrer les données avant leur entrée dans les datastores Google Cloud.

Dans ce tutoriel, vous allez chiffrer un fichier à l'aide de Cloud KMS avant de l'importer dans un bucket. Ensuite, vous téléchargez et déchiffrez les mêmes données afin de pouvoir les lire sur le client.

Lorsque vous suivez ces instructions, vos clés et toutes les opérations cryptographiques restent dans Google Cloud, et vous devez utiliser Cloud KMS pour le déchiffrement. Le chiffrement symétrique brut vous permet de chiffrer ou de déchiffrer des données localement sur site, ou de déplacer des données chiffrées entre différentes bibliothèques et différents fournisseurs de services, sans avoir à les déchiffrer au préalable.

Avant de commencer

Au sein de votre organisation Google Cloud, vous devez disposer des autorisations nécessaires pour créer des projets, activer la facturation, créer des utilisateurs et gérer les autorisations au sein de ces projets. Le rôle roles/resourcemanager.organizationAdmin accorde ces autorisations.

Prérequis

Nous vous recommandons d'utiliser deux projets et deux utilisateurs pour assurer la séparation des tâches. Si vous suivez la procédure décrite dans cette rubrique, les utilisateurs et services qui gèrent les clés de chiffrement sont distincts de ceux qui les utilisent. Un projet contient et gère les clés. L'autre projet stocke les données chiffrées dans un bucket Cloud Storage et les déchiffre selon les besoins.

Créer des projets

Vous pouvez créer des projets dans la console Google Cloud. Pour obtenir des instructions détaillées, consultez le guide de démarrage rapide d'Identity and Access Management.

Au sein de l'organisation :

Créez un projet Google Cloud contenant le bucket Cloud Storage utilisé pour stocker les secrets. Ces derniers seront stockés en tant qu'objets dans le bucket. Dans les étapes ci-dessous, ce projet est appelé my-storage-project.
Vous pouvez éventuellement créer un deuxième projet Google Cloud afin de gérer les clés Cloud KMS utilisées pour chiffrer et déchiffrer le secret. Dans les étapes ci-dessous, ce projet est appelé my-kms-project.

Vous pouvez choisir d'utiliser le même projet Google Cloud pour my-storage-project et my-kms-project.
Pour chaque projet, activez l'API Cloud KMS et la facturation en suivant les étapes de la section Avant de commencer du guide de démarrage rapide de Cloud KMS.

Créer des utilisateurs

Vous créez des utilisateurs et leur attribuez des rôles dans la console Google Cloud. Pour obtenir des instructions détaillées, consultez le guide de démarrage rapide d'Identity and Access Management.

Cette procédure crée deux utilisateurs. key-admin gère les clés de chiffrement, et key-user peut chiffrer et déchiffrer les données à l'aide des clés.

Exécutez cette procédure dans le projet my-kms-project.

Créez l'utilisateur key-admin. Pour créer des utilisateurs, vous devez disposer du rôle roles/resourcemanager.organizationAdmin pour le projet my-kms-project.
Attribuez à key-admin le rôle Identity and Access Management roles/cloudkms.admin. key-admin peut créer et gérer des clés.
Créez l'utilisateur key-user.
Accordez à key-user le rôle IAM roles/cloudkms.cryptoKeyEncrypterDecrypter. key-user peut utiliser des clés pour chiffrer et déchiffrer des données.

Remarque : Vous pouvez faire en sorte qu'un utilisateur ne puisse que procéder au chiffrement ou au déchiffrement, au lieu de pouvoir effectuer les deux opérations. Ces autorisations sont fournies par les rôles IAM roles/cloudkms.cryptoKeyEncrypter et roles/cloudkms.cryptoKeyDecrypter. Par exemple, une application peut ne pas avoir besoin de chiffrer les données, et un utilisateur peut ne pas avoir besoin de les déchiffrer.

Créer un bucket de stockage

Exécutez cette procédure dans le projet my-storage-project.

Créez un bucket de stockage appelé my-bucket.
Accordez à key-user le rôle roles/storage.objectAdmin pour le bucket de stockage my-bucket.

Créer une clé de chiffrement

Effectuez cette procédure en tant qu'utilisateur key-admin dans le projet my-kms-project.

Créez un trousseau de clés appelé storage. Le nom du trousseau de clés est unique au projet. Un trousseau de clés ne peut pas être renommé ni supprimé. Utilisez la Google Cloud CLI pour créer un trousseau de clés.
```
gcloud kms keyrings create storage \
  --location global
```
Créez une clé nommée my-key dans le trousseau de clés storage, à des fins de chiffrement. Le nom d'une clé est unique au trousseau de clés. Une clé ne peut pas être renommée ni supprimée, mais ses versions peuvent être détruites. Utilisez la Google Cloud CLI pour créer la clé. Une version de clé initiale est créée automatiquement et devient la version principale.
```
gcloud kms keys create my-key \
 --location global \
 --keyring storage \
 --purpose encryption
```

Vous pouvez en savoir plus sur la création de trousseaux de clés et de clés.

Chiffrer le fichier contenant le code secret

Exécutez cette procédure en tant qu'utilisateur key-user, en utilisant les deux projets.

Sur votre machine locale, créez un fichier nommé my-secret.txt, qui contient le texte "This is my secret".
```
echo "This is my secret" > my-secret.txt
```
Chiffrez my-secret.txt à l'aide de la clé my-key dans le projet my-kms-project. Écrivez le fichier chiffré dans mysecret.txt.encrypted.
```
gcloud kms encrypt \
 --location global \
 --keyring storage \
 --key my-key \
 --plaintext-file my-secret.txt \
 --ciphertext-file my-secret.txt.encrypted
```
Pour en savoir plus sur le chiffrement des données, consultez le guide de démarrage rapide du chiffrement des données.

Utilisez plutôt raw-encrypt pour le chiffrement symétrique brut.
Importez le fichier my-secret.txt.encrypted chiffré dans le bucket de stockage my-bucket du projet my-storage-project. Vous pouvez utiliser la commande gsutil.
```
gsutil cp my-secret.txt.encrypted gs://my-storage-bucket
```
Vous pouvez en savoir plus sur l'importation d'objets dans un bucket de stockage.
[Facultatif] Supprimez le fichier en texte brut my-secret.txt de la machine locale. Cette pratique est recommandée pour les fichiers contenant des données sensibles non chiffrées.

Le bucket de stockage my-storage-bucket contient désormais le fichier my-secret.txt.encrypted, qui est chiffré à l'aide de la clé my-key.

Déchiffrer le fichier contenant le code secret

Effectuez ces étapes en tant qu'utilisateur key-user, en utilisant les deux projets.

Téléchargez le fichier my-secret.txt.encrypted à partir du bucket de stockage my-bucket. Vous pouvez utiliser la commande gsutil.
```
gsutil cp gs://my-storage-bucket/my-secret.txt.encrypted .
```
Vous pouvez en savoir plus sur le téléchargement d'objets à partir d'un bucket de stockage.
Essayez de lire le fichier à l'aide d'une commande telle que less ou d'un éditeur de texte. Notez qu'il ne s'agit pas d'un fichier au format texte brut.
Déchiffrez my-secret.txt.encrypted et enregistrez les données déchiffrées dans un nouveau fichier en texte brut appelé my-secret.txt.decrypted, en utilisant la même clé que celle utilisée pour chiffrer my-secret.txt.
```
gcloud kms decrypt --location global \
 --keyring storage \
 --key my-key \
 --ciphertext-file my-secret.txt.encrypted \
 --plaintext-file my-secret.txt.decrypted
```
Pour en savoir plus sur le déchiffrement des données, consultez le guide de démarrage rapide du chiffrement des données.

Utilisez plutôt raw-decrypt pour le chiffrement symétrique brut.
Lisez le fichier my-secret.txt.decrypted à l'aide de la commande cat. Son contenu est identique au contenu d'origine du fichier my-secret.txt.
```
cat my-secret.txt.decrypted
```
```
This is my secret.
```
[Facultatif] Supprimez les fichiers my-secret.txt.encrypted et my-secret.txt.decrypted de la machine locale.

Nettoyer

Pour procéder au nettoyage, supprimez tous les fichiers que vous avez créés sur la machine locale, puis supprimez les projets [MY_KMS_PROJECT] et [MY_STORAGE_PROJECT].

Étapes suivantes

Consultez la section Gestion de code secret.
Consultez la section Séparation des tâches.
Découvrez comment attribuer, modifier et révoquer les accès à des ressources.
Découvrez comment créer un compte de service.