1. Présentation
Cloud Data Loss Prevention (DLP) est un service entièrement géré conçu pour vous aider à détecter, classer et protéger les informations sensibles. Cet atelier de programmation vous présentera certaines des fonctionnalités de base de l'API Cloud DLP et vous montrera les différentes façons de l'utiliser pour protéger les données.
Objectifs de l'atelier
- Utiliser la protection contre la perte de données pour inspecter les chaînes et les fichiers afin de détecter des infoTypes
- Découvrir les techniques d'anonymisation et utiliser DLP pour anonymiser des données
- Découvrez comment restaurer l'identification des données qui ont été anonymisées à l'aide du chiffrement préservant le format (FPE).
- Utiliser DLP pour masquer des infoTypes dans des chaînes et des images
Prérequis
- Un projet Google Cloud avec la facturation configurée. Si vous n'en avez pas, vous devrez en créer un.
2. Configuration
Cet atelier de programmation peut être exécuté entièrement sur Google Cloud Platform, sans installation ni configuration locales.
Cloud Shell
Tout au long de cet atelier de programmation, nous allons provisionner et gérer différentes ressources et différents services cloud à l'aide de la ligne de commande via Cloud Shell.
Téléchargez le dépôt du projet associé :
git clone https://github.com/googleapis/nodejs-dlp
Une fois le code du projet téléchargé, accédez au répertoire des exemples et installez les packages Node.js requis :
cd samples && npm install
Assurez-vous d'utiliser le bon projet en le définissant avec la commande gcloud suivante :
gcloud config set project [PROJECT_ID]
Activer les API
Voici les API que nous devrons activer dans notre projet :
- API Cloud Data Loss Prevention : fournit des méthodes pour détecter, analyser les risques et anonymiser les fragments de contenu confidentiels et sensibles dans le texte, les images et les dépôts de stockage Google Cloud Platform.
- API Cloud Key Management Service (KMS) : Google Cloud KMS permet aux clients de gérer les clés de chiffrement et d'effectuer des opérations de chiffrement avec ces clés.
Activez les API requises à l'aide de la commande gcloud suivante :
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. Inspecter les chaînes et les fichiers
Le répertoire "samples" du projet téléchargé à l'étape précédente contient plusieurs fichiers JavaScript qui utilisent les différentes fonctionnalités de Cloud DLP. inspect.js inspecte une chaîne ou un fichier fournis pour identifier les infoTypes sensibles.
Pour tester cette option, vous pouvez indiquer l'option string et un exemple de chaîne contenant des informations potentiellement sensibles :
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
Le résultat doit indiquer les conclusions pour chaque type d'information détecté, y compris :
Devis : le modèle spécifie
InfoType : type d'information détecté pour cette partie de la chaîne. Vous trouverez la liste complète des infoTypes possibles sur cette page. Par défaut, inspect.js n'inspecte que les infoTypes CREDIT_CARD_NUMBER, PHONE_NUMBER et EMAIL_ADDRESS.
Probabilité : les résultats sont classés en fonction de la probabilité qu'ils représentent une correspondance. La probabilité peut aller de VERY_UNLIKELY à VERY_LIKELY.
Voici les résultats de la requête de commande ci-dessus :
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
De même, nous pouvons inspecter des fichiers pour y rechercher des infoTypes. Consultez l'exemple de fichier accounts.txt :
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
Exécutez à nouveau inspect.js, cette fois avec l'option de fichier :
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
Résultats :
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
Pour les deux types de requêtes, nous pouvons limiter les résultats par probabilité ou par type d'informations. Exemple :
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
Si vous spécifiez VERY_LIKELY comme probabilité minimale, toutes les correspondances inférieures à VERY_LIKELY sont exclues :
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Voici les résultats complets sans la limitation :
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
De même, nous pouvons spécifier l'infoType que nous recherchons :
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
Seul le type d'informations spécifié est renvoyé, le cas échéant :
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Voici la fonction asynchrone qui utilise l'API pour inspecter l'entrée :
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
Les arguments fournis pour les paramètres ci-dessus servent à construire un objet de requête. Cette requête est ensuite fournie à la fonction inspectContent pour obtenir une réponse qui génère notre résultat :
inspect.js
// Construct item to inspect
const item = {value: string};
// Construct request
const request = {
parent: dlp.projectPath(callingProjectId),
inspectConfig: {
infoTypes: infoTypes,
customInfoTypes: customInfoTypes,
minLikelihood: minLikelihood,
includeQuote: includeQuote,
limits: {
maxFindingsPerRequest: maxFindings,
},
},
item: item,
};
...
...
const [response] = await dlp.inspectContent(request);
4. Anonymisation
Outre l'inspection et la détection des données sensibles, Cloud DLP peut les anonymiser. L'anonymisation est le processus qui consiste à éliminer les informations personnelles contenues dans les données. L'API détecte les données sensibles telles que définies par les infoTypes, puis procède à une transformation pour les masquer, les supprimer ou les dissimuler à des fins d'anonymisation.
deid.js illustrera la désidentification de plusieurs façons. La méthode de désidentification la plus simple consiste à utiliser un masque :
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
Avec un masque, l'API remplace les caractères de l'infoType détecté par un autre caractère, * par défaut. Le résultat sera le suivant :
My order number is F12312399. Email me at *****************************
Notez que l'adresse e-mail de la chaîne est obscurcie, tandis que le numéro de commande arbitraire est intact. (Il est possible de personnaliser les infoTypes, mais ce n'est pas abordé dans cet atelier.)
Examinons la fonction qui utilise l'API DLP pour anonymiser les données à l'aide d'un masque :
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Encore une fois, ces arguments servent à construire un objet de requête. Cette fois, on utilise la fonction deidentifyContent :
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
characterMaskConfig: {
maskingCharacter: maskingCharacter,
numberToMask: numberToMask,
},
},
},
],
},
},
item: item,
};
...
...
const [response] = await dlp.deidentifyContent(request);
Anonymiser des données avec le chiffrement préservant le format
L'API DLP permet également de chiffrer les valeurs de données sensibles à l'aide d'une clé cryptographique.
Nous allons commencer par utiliser Cloud KMS pour créer un trousseau de clés :
gcloud kms keyrings create dlp-keyring --location global
Nous pouvons maintenant créer une clé que nous utiliserons pour chiffrer les données :
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
L'API DLP acceptera une clé encapsulée chiffrée avec la clé KMS que nous avons créée. Nous pouvons générer une chaîne aléatoire qui sera encapsulée. Nous en aurons besoin plus tard pour réidentifier :
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
Nous pouvons maintenant chiffrer la chaîne avec notre clé KMS. Cela génère un fichier binaire contenant la chaîne chiffrée sous forme de texte chiffré :
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
À l'aide de deid.js, nous pouvons désormais anonymiser le numéro de téléphone dans l'exemple de chaîne ci-dessous à l'aide du chiffrement :
node deid.js deidFpe -c $GOOGLE_CLOUD_PROJECT \
"My client's cell is 9006492568" `base64 -w 0 ciphertext.bin` \
projects/${GOOGLE_CLOUD_PROJECT}/locations/global/keyRings/dlp-keyring/cryptoKeys/dlp-key \
-s PHONE_NUMBER
Le résultat renvoie la chaîne avec les infoTypes correspondants remplacés par une chaîne chiffrée et précédés par l'infoType indiqué par l'indicateur -s :
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Examinons la fonction que nous utilisons pour désidentifier la chaîne :
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Les arguments servent à construire un objet cryptoReplaceFfxFpeConfig :
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
L'objet cryptoReplaceFfxFpeConfig est ensuite utilisé dans la requête envoyée à l'API via la fonction deidentifyContent :
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
cryptoReplaceFfxFpeConfig: cryptoReplaceFfxFpeConfig,
},
},
],
},
},
item: item,
};
try {
// Run deidentification request
const [response] = await dlp.deidentifyContent(request);
Réidentifier les données
Pour restaurer l'identification des données, l'API DLP utilisera le texte chiffré que nous avons créé à l'étape précédente :
node deid.js reidFpe -c $GOOGLE_CLOUD_PROJECT \
"<YOUR_DEID_OUTPUT>" \
PHONE_NUMBER `base64 -w 0 ciphertext.bin` \
projects/${GOOGLE_CLOUD_PROJECT}/locations/global/keyRings/dlp-keyring/cryptoKeys/dlp-key
Le résultat sera la chaîne d'origine sans aucune indication de masquage ni de type de substitut :
My client's cell is 9006492568
La fonction utilisée pour réidentifier les données est semblable à celle utilisée pour les anonymiser :
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Encore une fois, les arguments sont utilisés dans une requête envoyée à l'API, cette fois-ci à la fonction reidentifyContent :
deid.js
// Construct deidentification request
const item = {value: string};
const request = {
parent: dlp.projectPath(callingProjectId),
reidentifyConfig: {
infoTypeTransformations: {
transformations: [
{
primitiveTransformation: {
cryptoReplaceFfxFpeConfig: {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
surrogateInfoType: {
name: surrogateType,
},
},
},
},
],
},
},
inspectConfig: {
customInfoTypes: [
{
infoType: {
name: surrogateType,
},
surrogateType: {},
},
],
},
item: item,
};
try {
// Run reidentification request
const [response] = await dlp.reidentifyContent(request);
Anonymiser les dates avec le changement de date
Dans certains contextes, les dates peuvent être considérées comme des données sensibles que nous pouvons vouloir obscurcir. Le décalage de date nous permet de décaler les dates d'un incrément aléatoire tout en préservant la séquence et la durée d'une période. Chaque date d'un ensemble est modifiée à l'aide d'un intervalle de temps unique à cette entrée. Pour illustrer la désidentification par décalage de date, commencez par examiner l'exemple de fichier CSV contenant des données de date :
resources/dates.csv
name,birth_date,register_date,credit_card
Ann,01/01/1980,07/21/1996,4532908762519852
James,03/06/1988,04/09/2001,4301261899725540
Dan,08/14/1945,11/15/2011,4620761856015295
Laura,11/03/1992,01/04/2017,4564981067258901
Les données contiennent deux champs auxquels nous pouvons appliquer un décalage de date : birth_date et register_date. deid.js accepte une valeur de limite inférieure et une valeur de limite supérieure pour définir une plage permettant de sélectionner un nombre aléatoire de jours pour décaler les dates :
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
Un fichier nommé datesShifted.csv sera généré, avec des dates décalées de manière aléatoire d'un nombre de jours compris entre 30 et 90. Voici un exemple de résultat généré :
name,birth_date,register_date,credit_card
Ann,2/6/1980,7/21/1996,4532908762519852
James,5/18/1988,4/9/2001,4301261899725540
Dan,9/16/1945,11/15/2011,4620761856015295
Laura,12/16/1992,1/4/2017,4564981067258901
Notez que nous avons également pu spécifier la colonne de date du fichier CSV que nous souhaitions décaler. Le champ birth_date et le champ register_date restent inchangés.
Examinons la fonction qui gère la désidentification avec un décalage de date :
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Notez que cette fonction peut accepter une clé encapsulée et un nom de clé, comme pour la désidentification avec FPE, afin que nous ayons la possibilité de fournir une clé de chiffrement pour réidentifier un décalage de date. Les arguments que nous fournissons créent un objet dateShiftConfig :
deid.js
// Construct DateShiftConfig
const dateShiftConfig = {
lowerBoundDays: lowerBoundDays,
upperBoundDays: upperBoundDays,
};
if (contextFieldId && keyName && wrappedKey) {
dateShiftConfig.context = {name: contextFieldId};
dateShiftConfig.cryptoKey = {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
};
} else if (contextFieldId || keyName || wrappedKey) {
throw new Error(
'You must set either ALL or NONE of {contextFieldId, keyName, wrappedKey}!'
);
}
// Construct deidentification request
const request = {
parent: dlp.projectPath(callingProjectId),
deidentifyConfig: {
recordTransformations: {
fieldTransformations: [
{
fields: dateFields,
primitiveTransformation: {
dateShiftConfig: dateShiftConfig,
},
},
],
},
},
item: tableItem,
};
5. Masquer des informations dans des chaînes et des images
Une autre méthode d'obscurcissement des informations sensibles est le masquage (redaction). Ce type de masquage consiste à remplacer une information sensible détectée par l'infoType auquel elle correspond. redact.js montre comment masquer des informations :
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
Le numéro de carte de crédit de l'exemple est remplacé par l'infoType CREDIT_CARD_NUMBER :
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
Cette fonctionnalité est utile si vous souhaitez masquer des informations sensibles, tout en identifiant le type d'information supprimée. L'API DLP peut également masquer des informations dans des images contenant du texte. Pour illustrer cela, examinons un exemple d'image :
resources/test.png
Pour masquer le numéro de téléphone et l'adresse e-mail dans l'image ci-dessus :
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
Comme spécifié, une nouvelle image nommée redacted.png sera générée, dans laquelle les informations demandées seront masquées :
Voici la fonction utilisée pour masquer des informations dans une chaîne :
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Voici la requête qui sera fournie à la fonction deidentifyContent :
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
Voici la fonction permettant de masquer des informations dans une image :
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
Voici la requête qui sera fournie à la fonction redactImage :
redact.js
// Construct image redaction request
const request = {
parent: dlp.projectPath(callingProjectId),
byteItem: {
type: fileTypeConstant,
data: fileBytes,
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
imageRedactionConfigs: imageRedactionConfigs,
};
6. Effectuer un nettoyage
Nous avons vu comment utiliser l'API DLP pour masquer, anonymiser et expurger les informations sensibles de nos données. Il est maintenant temps de nettoyer notre projet de toutes les ressources que nous avons créées.
Supprimer le projet
Dans la console GCP, accédez à la page Cloud Resource Manager :
Dans la liste des projets, sélectionnez celui dans lequel vous avez travaillé, puis cliquez sur Supprimer. Vous serez alors invité à saisir l'ID du projet. Saisissez-le, puis cliquez sur Arrêter.
Vous pouvez également supprimer le projet dans son intégralité directement dans Cloud Shell avec gcloud :
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. Félicitations !
Bravo ! Bravo ! Cloud DLP est un outil puissant qui donne accès à une plate-forme permettant d'inspecter, de classer et d'anonymiser des données sensibles.
Points abordés
- Nous avons vu comment l'API Cloud DLP peut être utilisée pour inspecter des chaînes et des fichiers à la recherche de plusieurs infoTypes.
- Nous avons appris comment l'API DLP peut anonymiser des chaînes avec un masque pour masquer les données correspondant aux infoTypes.
- Nous avons utilisé l'API DLP pour dépersonnaliser les données à l'aide d'une clé de chiffrement, puis les réidentifier.
- Nous avons utilisé l'API DLP pour masquer des données dans une chaîne et une image.