1. Panoramica
Cloud Data Loss Prevention (DLP) è un servizio completamente gestito progettato per aiutarti a scoprire, classificare e proteggere le informazioni sensibili. Questo codelab introdurrà alcune delle funzionalità di base dell'API Cloud DLP e mostrerà i vari modi in cui può essere utilizzata per proteggere i dati.
Attività previste
- Utilizzare DLP per ispezionare stringhe e file alla ricerca di tipi di informazioni corrispondenti
- Scopri le tecniche di anonimizzazione e utilizza DLP per anonimizzare i dati
- Scopri come reidentificare i dati anonimizzati utilizzando la crittografia con protezione del formato (FPE)
- Utilizzare DLP per oscurare i tipi di informazioni da stringhe e immagini
Che cosa ti serve
- Un progetto Google Cloud con la fatturazione configurata. Se non ne hai uno, dovrai crearne uno.
2. Preparazione
Questo codelab può essere eseguito completamente su Google Cloud Platform senza alcuna installazione o configurazione locale.
Cloud Shell
In questo codelab, eseguiremo il provisioning e la gestione di diversi servizi e risorse cloud utilizzando la riga di comando tramite Cloud Shell.
Scarica il repository del progetto complementare:
git clone https://github.com/googleapis/nodejs-dlp
Una volta scaricato il codice del progetto, passa alla directory degli esempi e installa i pacchetti Node.js richiesti:
cd samples && npm install
Assicurati di utilizzare il progetto corretto impostandolo con il seguente comando gcloud:
gcloud config set project [PROJECT_ID]
Abilita API
Ecco le API che dovremo abilitare nel nostro progetto:
- API Cloud Data Loss Prevention: fornisce metodi per il rilevamento, l'analisi del rischio e l'anonimizzazione di frammenti sensibili alla privacy in testo, immagini e repository di archiviazione di Google Cloud
- API Cloud Key Management Service (KMS): Google Cloud KMS consente ai clienti di gestire le chiavi di crittografia ed eseguire operazioni di crittografia con queste chiavi.
Abilita le API richieste con il seguente comando gcloud:
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. Esaminare stringhe e file
La directory samples del progetto scaricato nel passaggio precedente contiene diversi file JavaScript che utilizzano le diverse funzionalità di Cloud DLP. inspect.js ispezionerà una stringa o un file forniti per individuare i tipi di informazioni sensibili.
Per provarlo, puoi fornire l'opzione string e una stringa di esempio con alcune informazioni potenzialmente sensibili:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
L'output deve indicare i risultati per ogni tipo di informazioni corrispondente, tra cui:
Citazione: il modello specifica
InfoType: il tipo di informazioni rilevato per quella parte della stringa. Puoi trovare un elenco completo dei possibili tipi di informazioni qui. Per impostazione predefinita, inspect.js esegue l'ispezione solo per i tipi di informazioni CREDIT_CARD_NUMBER, PHONE_NUMBER E EMAIL_ADDRESS
Probabilità: i risultati vengono classificati in base alla probabilità che ciascuno rappresenti una corrispondenza. La probabilità può variare da VERY_UNLIKELY a VERY_LIKELY.
I risultati della richiesta di comando riportata sopra sono:
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Allo stesso modo, possiamo ispezionare i file per i tipi di informazioni. Dai un'occhiata al file accounts.txt di esempio:
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
Esegui di nuovo inspect.js, questa volta con l'opzione file:
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
Risultati:
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
Per entrambi i tipi di query, potremmo limitare i risultati in base alla probabilità o al tipo di informazioni. Ad esempio:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
Se specifichi VERY_LIKELY come probabilità minima, tutte le corrispondenze inferiori a VERY_LIKELY vengono escluse:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
I risultati completi senza la limitazione sarebbero:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Allo stesso modo, potremmo specificare il tipo di informazioni che stiamo cercando:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
Se trovato, viene restituito solo il tipo di informazioni specificato:
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Di seguito è riportata la funzione asincrona che utilizza l'API per esaminare l'input:
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
Gli argomenti forniti per i parametri precedenti vengono utilizzati per costruire un oggetto richiesta. Questa richiesta viene quindi fornita alla funzione inspectContent per ottenere una risposta che genera il nostro output:
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. Anonimizzazione
Oltre a ispezionare e rilevare i dati sensibili, Cloud DLP può eseguire l'anonimizzazione. L'anonimizzazione è il processo di rimozione delle informazioni identificative dai dati. L'API rileva i dati sensibili definiti dai tipi di informazioni, quindi utilizza una trasformazione di anonimizzazione per mascherare, eliminare o nascondere in altro modo i dati.
deid.js mostrerà la deidentificazione in diversi modi. Il metodo più semplice di deidentificazione è l'utilizzo di una maschera:
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
Con una maschera, l'API sostituirà i caratteri del tipo di informazioni corrispondente con un carattere diverso, * per impostazione predefinita. L'output sarà:
My order number is F12312399. Email me at *****************************
Tieni presente che l'indirizzo email nella stringa è offuscato, mentre il numero d'ordine arbitrario è intatto. I tipi di informazioni personalizzati sono possibili, ma non rientrano nell'ambito di questo codelab.
Vediamo la funzione che utilizza l'API DLP per l'anonimizzazione con una maschera:
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Ancora una volta, questi argomenti vengono utilizzati per creare un oggetto richiesta. Questa volta viene fornito alla funzione 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);
Anonimizzare con la crittografia con protezione del formato
L'API DLP offre anche la possibilità di criptare i valori dei dati sensibili utilizzando una chiave di crittografia.
Inizieremo utilizzando Cloud KMS per creare un keyring:
gcloud kms keyrings create dlp-keyring --location global
Ora possiamo creare una chiave che utilizzeremo per criptare i dati:
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
L'API DLP accetterà una chiave sottoposta a wrapping criptata con la chiave KMS che abbiamo creato. Possiamo generare una stringa casuale che verrà sottoposta a wrapping. Avremo bisogno di queste informazioni in un secondo momento per la reidentificazione:
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
Ora possiamo criptare la stringa con la nostra chiave KMS. Verrà generato un file binario contenente la stringa criptata come testo cifrato:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
Utilizzando deid.js, ora possiamo rimuovere l'identificazione del numero di telefono nella stringa di esempio riportata di seguito utilizzando la crittografia:
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
L'output restituirà la stringa con i tipi di informazioni corrispondenti sostituiti da una stringa criptata e preceduta dal tipo di informazioni indicato dal flag -s:
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Diamo un'occhiata alla funzione che utilizziamo per deidentificare la stringa:
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Gli argomenti vengono utilizzati per costruire un oggetto cryptoReplaceFfxFpeConfig:
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
L'oggetto cryptoReplaceFfxFpeConfig viene a sua volta utilizzato nella richiesta all'API tramite la funzione 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);
Reidentificare i dati
Per reidentificare i dati, l'API DLP utilizzerà il testo cifrato creato nel passaggio precedente:
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
L'output sarà la stringa originale senza oscuramenti o indicazioni del tipo di surrogato:
My client's cell is 9006492568
La funzione utilizzata per reidentificare i dati è simile a quella utilizzata per anonimizzarli:
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Ancora una volta, gli argomenti vengono utilizzati in una richiesta all'API, questa volta alla funzione 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);
Anonimizzare le date con il cambio data
In determinati contesti, le date possono essere considerate dati sensibili che potremmo voler offuscare. Lo spostamento delle date ci consente di spostare le date di un incremento casuale, mantenendo la sequenza e la durata di un periodo di tempo. Ogni data di un insieme viene spostata di un periodo di tempo univoco per quella voce. Per dimostrare la deidentificazione tramite lo spostamento delle date, dai un'occhiata al file CSV di esempio che contiene i dati sulle 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
I dati contengono due campi a cui potremmo applicare uno spostamento della data: birth_date e register_date. deid.js accetterà un valore limite inferiore e un valore limite superiore per definire un intervallo in cui selezionare un numero casuale di giorni in cui spostare le date:
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
Verrà generato un file denominato datesShifted.csv con le date spostate in modo casuale di un numero di giorni compreso tra 30 e 90. Ecco un esempio dell'output generato:
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
Tieni presente che abbiamo anche potuto specificare la colonna della data nel file CSV che volevamo spostare. Il campo birth_date Il campo register_date rimane invariato.
Diamo un'occhiata alla funzione che gestisce la deidentificazione con uno spostamento della data:
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Tieni presente che questa funzione potrebbe accettare una chiave sottoposta a wrapping e un nome di chiave, in modo simile all'anonimizzazione con FPE, in modo da avere la possibilità di fornire una chiave di crittografia per reidentificare uno spostamento di data. Gli argomenti che forniamo creano un oggetto 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. Oscurare stringhe e immagini
Un altro metodo per offuscare le informazioni sensibili è l'oscuramento. La redazione sostituirà una corrispondenza con il tipo di informazioni con cui è stata identificata la corrispondenza. redact.js mostra l'oscuramento:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
L'output sostituisce il numero di carta di credito di esempio con il tipo di informazioni CREDIT_CARD_NUMBER:
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
Questa opzione è utile se vuoi nascondere informazioni sensibili, ma identificare comunque il tipo di informazioni che vengono rimosse. L'API DLP può oscurare in modo simile le informazioni dalle immagini che contengono testo. Per dimostrarlo, diamo un'occhiata a un'immagine di esempio:
resources/test.png
Per oscurare il numero di telefono e l'indirizzo email nell'immagine sopra:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
Come specificato, verrà generata una nuova immagine denominata redacted.png con le informazioni richieste oscurate:
Ecco la funzione utilizzata per oscurare una stringa:
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Ecco la richiesta che verrà fornita alla funzione deidentifyContent:
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
Analogamente, ecco la funzione per oscurare un'immagine:
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
Ecco la richiesta che verrà fornita alla funzione 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. Esegui la pulizia
Abbiamo esplorato come utilizzare l'API DLP per mascherare, anonimizzare e oscurare le informazioni sensibili dai nostri dati. Ora è il momento di pulire il nostro progetto da tutte le risorse che abbiamo creato.
Eliminare il progetto
Nella console di GCP, vai alla pagina Cloud Resource Manager:
Nell'elenco dei progetti, seleziona il progetto su cui abbiamo lavorato e fai clic su Elimina. Ti verrà chiesto di digitare l'ID progetto. Inseriscilo e fai clic su Chiudi.
In alternativa, puoi eliminare l'intero progetto direttamente da Cloud Shell con gcloud:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. Complimenti!
Evvai! Ce l'hai fatta! Cloud DLP è un potente strumento che fornisce l'accesso a una piattaforma di ispezione, classificazione e anonimizzazione dei dati sensibili.
Argomenti trattati
- Abbiamo visto come l'API Cloud DLP può essere utilizzata per ispezionare stringhe e file per più tipi di informazioni
- Abbiamo scoperto come l'API DLP può anonimizzare le stringhe con una maschera per nascondere i dati corrispondenti ai tipi di informazioni
- Abbiamo utilizzato l'API DLP per utilizzare una chiave di crittografia per deidentificare e poi reidentificare i dati
- Abbiamo utilizzato l'API DLP per oscurare i dati da una stringa e da un'immagine