Tokeniser des données de titulaire de carte sensibles conformément à la norme PCI DSS

Last reviewed 2023-05-05 UTC

Ce tutoriel explique comment configurer un service de tokenisation de carte de paiement à accès contrôlé dans Cloud Functions. Pour configurer le service, cet article utilise les services Google Cloud suivants : Identity and Access Management (IAM) et Cloud Key Management Service (KMS).

La tokenisation est le processus qui consiste à remplacer des informations sensibles telles que des données de carte de crédit par une valeur d'espace réservé anodine, ou jeton. La Partie 3 de la norme de sécurité des données de l'industrie des cartes de paiement (PCI DSS, Payment Card Industry Data Security Standard) exige que la plupart des données stockées sur une carte de crédit soient traitées comme des informations sensibles.

Un jeton en soi est inutile, sauf pour rechercher des données tokenisées dans un contexte spécifique. Toutefois, vous devez toujours vous assurer que vos jetons ne contiennent aucune information propre aux utilisateurs et qu'ils ne sont pas directement déchiffrables. Ainsi, si vous perdez le contrôle des jetons de carte de paiement de vos clients, personne ne peut les utiliser pour compromettre les données des titulaires de cartes.

Un service de traitement des informations sensibles

De nombreux services et plates-formes vous permettent de stocker votre environnement de données de titulaire de carte (CDE, Cardholder Data Environment). Ce tutoriel présente un exemple de déploiement à l'aide de Cloud Functions et décrit les étapes qui vous aident à obtenir une solution prête pour la production.

Cloud Functions est une plate-forme sans serveur qui héberge et exécute du code. Elle offre un emplacement idéal pour lancer rapidement une application à autoscaling. Sachez que, dans un environnement de stockage conforme à la norme PCI DSS, vous devez limiter l'ensemble du trafic entrant et sortant aux connexions autorisées. À l'heure actuelle, Cloud Functions ne permet pas d'appliquer des contrôles aussi précis. Par conséquent, vous devez mettre en œuvre des contrôles compensatoires ailleurs (comme dans votre application) ou choisir une autre plate-forme. Le service de tokenisation peut être exécuté de manière conteneurisée, à l'aide d'un groupe d'instances géré à autoscaling ou d'un cluster Kubernetes, par exemple. Ces environnements de production incluent des contrôles complets du réseau VPC et sont préférables.

Cloud KMS est le service de gestion de clés de Google Cloud. Il héberge vos clés de chiffrement, les alterne régulièrement, et chiffre ou déchiffre les données de compte stockées.

IAM est utilisé dans ce tutoriel pour fournir un contrôle strict sur toutes les ressources utilisées dans le service de tokenisation. Vous devez disposer d'un compte de service spécial dont les jetons expirent fréquemment pour accorder l'accès à Cloud KMS et exécuter la fonction de tokenisation.

La figure suivante illustre l'architecture de l'application de tokenisation que vous créez dans ce tutoriel.

architecture de l'application de tokenisation

Objectifs

Créez un compte de service.
Configurer Cloud KMS
Créer deux fonctions Cloud Functions
Créer un jeton d'authentification.
Appeler la fonction de tokenisation.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Dans Google Cloud Console, accédez à la page de sélection du projet.

Accéder au sélecteur de projet
Pour commencer à créer un projet Google Cloud, cliquez sur Créer un projet.
Attribuez un nom à votre projet. Notez l'ID de projet que vous avez généré.
Modifiez les autres champs si nécessaire.
Pour créer le projet, cliquez sur Créer.

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Activer les API Cloud Build, Cloud Functions, and Cloud KMS.
Activer les API

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Créer le compte de service

Le compte de service d'exécution par défaut pour Cloud Functions dispose du rôle d'éditeur, qui permet un accès étendu à de nombreux services Google Cloud. Bien qu'il s'agisse du moyen le plus rapide de développer des fonctions, Google recommande de n'utiliser le compte de service par défaut que pour les tests et le développement. Vous pouvez créer un compte de service pour limiter les API que la fonction peut utiliser conformément au principe du moindre privilège. Pour créer un compte de service, procédez comme suit :

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez votre projet.
Cliquez sur Créer un compte de service.
Dans le champ Nom du compte de service, saisissez Tokenization Service User. Cloud Console remplit le champ ID du compte de service en fonction de ce nom.
Facultatif : dans le champ Description du compte de service, saisissez une description du compte de service.
Cliquez sur Créer et continuer.
Cliquez sur Sélectionner un rôle, puis sélectionnez Chiffreur/Déchiffreur de CryptoKey Cloud KMS.
Pour terminer la création du compte de service, cliquez sur OK.

Vous disposez désormais d'un utilisateur de compte de service associé à l'adresse e-mail suivante :
```
tokenization-service-user@YOUR_PROJECT_ID.iam.gserviceaccount.com
```

Configurer Cloud KMS

Dans la console Google Cloud, ouvrez Gestion des clés.

Accéder à la page Clés de chiffrement
Cliquez sur **+ Créer un trousseau de clés **. Dans la boîte de dialogue qui apparaît, procédez comme suit :
1. Nommez le trousseau de clés tokenization-service-kr.
2. Sous Key ring location (Emplacement du trousseau), sélectionnez global. Il s'agit d'un choix courant qui suffit dans le cadre de ce tutoriel. Toutefois, avant de prendre une décision concernant l'architecture de production, assurez-vous de bien comprendre les différences entre les différents emplacements Cloud KMS.
3. Vérifiez vos choix, car vous ne pouvez pas supprimer ni renommer des trousseaux après leur création.
4. Cliquez sur Create (Créer).
Le système crée le trousseau et vous redirige vers la page de création de clé.
Dans la boîte de dialogue Create key (Créer une clé), procédez comme suit :
1. Nommez la clé cc-tokenization.
2. Dans le champ Objectif, sélectionnez Symmetric encrypt/decrypt.
3. Pour Rotation period (Période de rotation), indiquez la valeur de votre choix, puis cliquez sur Create (Créer).
  
  Remarque : Pensez à noter les entrées que vous avez spécifiées. Vous devrez indiquer le nom du projet, le nom du trousseau, l'emplacement de ce dernier et le nom de la clé dans la fonction Cloud Functions.

Créer des fonctions Cloud Functions

Ce tutoriel suppose que vous allez employer Cloud Shell. Si vous utilisez un autre terminal, assurez-vous de disposer de la dernière version de Google Cloud CLI.

Dans Google Cloud Console, ouvrez Cloud Shell :

Accéder à Cloud Shell
Clonez le dépôt du projet GitHub et accédez au dossier de travail :
```
git clone https://github.com/GoogleCloudPlatform/community gcp-community
cd gcp-community/tutorials/pci-tokenizer/
```
Le dossier gcs-cf-tokenizer contient le fichier index.js, qui est la source des deux fonctions Cloud Functions distinctes que vous allez créer. Il comporte également le fichier package.json, qui indique à Cloud Functions les packages à exécuter.
Appliquez la configuration KMS. Copiez le fichier de modèle de configuration et ouvrez-le pour le modifier :
```
cp config/default.json config/local.json
nano config/local.json
```
L'environnement d'exécution Node.js vous oblige à définir explicitement l'ID de projet Google Cloud :
```
"project_id":              "YOUR_PROJECT_ID"
```

Recherchez la configuration KMS et appliquez les valeurs KMS que vous avez créées à la section précédente :

"location":                "global",
"key_ring":                "tokenization-service-kr",
"key_name":                "cc-tokenization"

Déployez la fonction de tokenisation.

gcloud functions deploy tokenize --runtime=nodejs18 --trigger-http \
    --entry-point=kms_crypto_tokenize --memory=256MB \
    --service-account=tokenization-service-user@YOUR_PROJECT_ID.iam.gserviceaccount.com \
    --no-allow-unauthenticated --source=.

Cette fonction transforme les informations de carte de crédit en jeton.

Recherchez la valeur de l'URL sous httpsTrigger dans le résultat de la commande gcloud functions deploy. Stockez la valeur de l'URL dans la variable d'environnement TOK_URL :
```
TOK_URL="TOK_URL"
```
Vous utiliserez la variable d'environnement TOK_URL pour appeler la fonction tokenize.

Déployez la fonction de détokenisation en mode KMS.

gcloud functions deploy detokenize --runtime=nodejs18 --trigger-http \
    --entry-point=kms_crypto_detokenize --memory=256MB \
    --service-account=tokenization-service-user@YOUR_PROJECT_ID.iam.gserviceaccount.com \
    --no-allow-unauthenticated --source=.

Cette fonction inverse le processus de tokenisation.

Recherchez la valeur de l'URL sous httpsTrigger dans le résultat de la commande gcloud functions deploy. Stockez la valeur de l'URL dans la variable d'environnement DETOK_URL :
```
DETOK_URL="DETOK_URL"
```
Vous allez utiliser la variable d'environnement DETOK_URL pour appeler la fonction de détokenisation.

Vous avez créé deux fonctions Cloud Functions distinctes. La première permet de transformer le numéro de carte en jeton, et la seconde d'inverser le processus. Les points d'entrée différents dirigent l'exécution vers la fonction de démarrage appropriée dans le fichier index.js.
Une fois les fonctions déployées, ouvrez la console Cloud Functions.

Accéder à la console Cloud Functions
Vérifiez que les fonctions ont bien été créées. Si le processus s'est déroulé correctement, vos deux fonctions apparaissent avec une coche à côté d'elles.

Créer un jeton d'authentification

L'option no-allow-unauthenticated de la commande gcloud functions deploy signifie qu'un appelant qui appelle les fonctions doit présenter un jeton d'authentification pour valider l'identité de l'appelant. L'appelant doit disposer de l'autorisation cloudfunctions.functions.invoke. Les rôles prédéfinis suivants disposent de cette autorisation : Demandeur Cloud Functions, Administrateur Cloud Functions et Développeur Cloud Functions.

Créez le jeton d'authentification :

AUTH_TOKEN=$(gcloud auth print-identity-token)
echo $AUTH_TOKEN

Ces commandes génèrent une chaîne de jeton d'authentification, la stockent dans la variable d'environnement $AUTH_TOKEN, puis affichent le jeton. Vous appellerez ensuite la fonction Cloud que vous avez déployée avec le jeton.

Appeler la fonction de tokenisation

Créez des exemples de données à transmettre à la fonction de tokenisation :

export TOK_CC=4000300020001000
export TOK_MM=11
export TOK_YYYY=2028
export TOK_UID=543210

Générez un jeton d'authentification comme décrit dans la section précédente, puis appelez la fonction de tokenisation :
```
CC_TOKEN=$(curl -s \
-X POST "$TOK_URL" \
-H "Content-Type:application/json" \
-H "Authorization: Bearer $AUTH_TOKEN" \
--data '{"cc": "'$TOK_CC'", "mm": "'$TOK_MM'", "yyyy": "'$TOK_YYYY'", "user_id": "'$TOK_UID'"}' \
)
echo $CC_TOKEN
```
La chaîne de tokenisation représentant les données de carte de crédit s'affiche. Cette chaîne est stockée dans la variable d'environnement CC_TOK. Vous pouvez récupérer les informations associées à la carte en appelant la fonction de détokenisation.

Inversez la tokenisation avec la commande suivante.

DETOK_DATA=$(curl -s \
-X POST "$DETOK_URL" \
-H  "Content-Type:application/json" \
-H "Authorization: Bearer $AUTH_TOKEN" \
--data '{"user_id": "'$TOK_UID'", "token": "'$CC_TOKEN'"}' \
)
echo -e "$DETOK_DATA\n"

Le résultat ressemble à ceci :

{"cc":"4000300020001000","mm":"11","yyyy":"2028","userid":"543210"}

Ces données sont celles qui ont été initialement envoyées à la fonction de tokenisation, déchiffrées, puis récupérées par votre application.

Développer en s'appuyant sur ce tutoriel

L'exemple de code de GitHub est un excellent début, mais il existe d'autres points à prendre en compte avant de passer à l'environnement de production.

Si vous choisissez de tokeniser des cartes de paiement à l'aide de Cloud Functions, vous devrez peut-être approfondir votre démarche pour satisfaire votre évaluateur de sécurité qualifié (QSA) ou votre questionnaire d'auto-évaluation. Plus précisément, les sections 1.2 et 1.3 de la norme PCI DSS exigent un contrôle strict du trafic entrant et sortant. Comme Cloud Functions et App Engine ne fournissent pas de pare-feu configurable dans les deux sens, vous devez créer des contrôles compensatoires ou déployer le service de tokenisation sur Compute Engine ou Google Kubernetes Engine. Si vous souhaitez explorer la conteneurisation, le code GitHub est compatible avec Docker et contient la documentation associée.

Cet exemple de code extrait également les dépendances npm (gestionnaire de packages Node.js) sur le déploiement. Dans votre environnement de production, épinglez toujours les dépendances à des versions approuvées spécifiques. Ajoutez ensuite ces versions à l'application elle-même ou diffusez-les à partir d'un emplacement privé et fiable. Ces deux approches vous aident à prévenir les temps d'arrêt causés par une interruption au niveau du dépôt npm ou par une attaque à l'encontre de la chaîne d'approvisionnement infectant des packages que vous pensiez à l'abri. Si vous précompilez et regroupez l'ensemble de l'application, votre temps de déploiement diminue généralement, ce qui implique des lancements plus rapides et un scaling plus fluide.

Effectuer un nettoyage

Pour nettoyer les ressources individuelles utilisées dans ce tutoriel, vous pouvez supprimer le projet.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Conformité avec la norme de sécurité des données PCI
Utiliser le protocole OAuth 2.0 pour accéder aux API Google
Exigences relatives à la norme PCI DSS
Supplément d'information : tokenisation conforme à la norme PCI DSS
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.