1. Panoramica
Cloud Data Loss Prevention (DLP) è un servizio completamente gestito progettato per aiutare a scoprire, classificare e proteggere le informazioni sensibili. Questo codelab presenterà alcune delle funzionalità di base dell'API Cloud DLP e dimostrerà i vari modi in cui può essere utilizzata per proteggere i dati.
Attività previste
- Usa la prevenzione della perdita di dati per controllare stringhe e file per individuare i tipi di informazioni corrispondenti
- Scopri di più sulle tecniche di anonimizzazione e utilizza la prevenzione della perdita di dati per anonimizzare i dati
- Scopri come reidentificare i dati anonimizzati utilizzando la crittografia con protezione del formato (FPE)
- Utilizza la DLP per oscurare i tipi di informazioni da stringhe e immagini
Che cosa ti serve
- Un progetto Google Cloud in cui è configurata la fatturazione. Se non ne hai uno, dovrai crearlo.
2. Preparazione
Questo codelab può essere eseguito completamente su Google Cloud senza alcuna installazione o configurazione locale.
Cloud Shell
Nel corso di 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 companion:
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 le API
Queste sono le API che dovremo abilitare nel nostro progetto:
- API Cloud Data Loss Prevention: fornisce metodi per il rilevamento, l'analisi dei rischi e l'anonimizzazione di frammenti sensibili alla privacy in testi, immagini e repository di archiviazione di Google Cloud Platform
- API Cloud Key Management Service (KMS): Google Cloud KMS consente ai clienti di gestire le chiavi di crittografia ed eseguire operazioni crittografiche 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. Ispeziona stringhe e file
La directory di esempio del progetto scaricata nel passaggio precedente contiene diversi file JavaScript che utilizzano le diverse funzionalità di Cloud DLP. inspect.js ispeziona una stringa o un file fornito per individuare i tipi di informazioni sensibili.
Per verificarlo, 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 dovrebbe indicare i risultati per ogni tipo di informazioni corrispondenti, 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 il controllo solo per i tipi di informazioni CREDIT_CARD_NUMBER, PHONE_NUMBER e EMAIL_ADDRESS
Probabilità: i risultati vengono classificati in base alla probabilità di rappresentare ciascuna una corrispondenza. La probabilità può variare da VERY_UNLIKELY a VERY_LIKELY.
I risultati per la 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
Analogamente, possiamo controllare i file per trovare tipi di informazioni. Guarda il 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, vengono escluse tutte le corrispondenze inferiori a VERY_LIKELY:
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
Analogamente, 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
Viene restituito solo il tipo di informazioni specificato, se trovato:
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 sopra riportati vengono utilizzati per creare un oggetto di richiesta. Questa richiesta viene quindi fornita alla funzione inspectContent per ottenere una risposta che generi 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 come definiti dai tipi di informazioni, quindi utilizza una trasformazione di anonimizzazione per mascherare, eliminare o oscurare in altro modo i dati.
deid.js dimostrerà l'anonimizzazione in diversi modi. Il metodo di anonimizzazione più semplice è con 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 sostituisce i caratteri del tipo di informazioni corrispondenti con un carattere diverso, * per impostazione predefinita. L'output sarà:
My order number is F12312399. Email me at *****************************
Nota che l'indirizzo email nella stringa è offuscato, mentre il numero d'ordine arbitrario è intatto. (I tipi di informazioni personalizzate sono possibili, ma non rientrano nell'ambito di questo codelab).
Vediamo la funzione che utilizza l'API DLP per anonimizzare con una maschera:
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Ancora una volta, questi argomenti vengono utilizzati per creare un oggetto di 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);
Anonimizza 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 con wrapping e criptata con la chiave KMS che abbiamo creato. Possiamo generare una stringa casuale che verrà sottoposta a wrapping. Ne avremo bisogno in seguito per identificare nuovamente:
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 crittografato:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
Con deid.js ora possiamo anonimizzare il numero di telefono nella stringa di esempio seguente mediante 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 precedute dal tipo di informazioni indicato dal flag -s:
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Diamo un'occhiata alla funzione che stiamo utilizzando per anonimizzare la stringa:
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Gli argomenti vengono utilizzati per creare 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);
Reidentifica i dati
Per identificare nuovamente i dati, l'API DLP utilizzerà il testo crittografato che abbiamo 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 tipo surrogato indicato:
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);
Anonimizza le date con variazione di data
In determinati contesti, le date possono essere considerate dati sensibili che potremmo voler offuscare. Lo scostamento delle date ci consente di spostare le date di un incremento casuale, preservando la sequenza e la durata di un determinato periodo di tempo. Ogni data di un insieme viene spostata di un periodo di tempo univoco per quella voce. Per dimostrare l'anonimizzazione tramite 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 di data: birth_date e register_date. deid.js accetterà un valore del limite inferiore e un valore del limite superiore per definire un intervallo e selezionare un numero casuale di giorni entro il quale 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 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 siamo stati anche in grado di specificare quale colonna della data nel file CSV volevamo spostare. Campo birth_date Il campo register_date rimane invariato.
Diamo un'occhiata alla funzione che gestisce l'anonimizzazione con un dateshift:
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Tieni presente che questa funzione potrebbe accettare una chiave con 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 forniti 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. L'oscuramento sostituirà una corrispondenza con il tipo di informazioni identificati come corrispondenti. redact.js dimostra 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 il tipo di informazioni che vengono rimosse. In modo simile, l'API DLP può oscurare le informazioni nelle 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 qui 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 da una stringa:
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Questa è 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
) {
...}
Questa è 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. È arrivato il momento di ripulire il nostro progetto dalle risorse che abbiamo creato.
Eliminare il progetto
Nella console Google Cloud, vai alla pagina Cloud Resource Manager:
Nell'elenco dei progetti, seleziona quello a cui abbiamo lavorato e fai clic su Elimina. Ti verrà chiesto di digitare l'ID progetto. Inseriscilo e fai clic su Arresta.
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 dà accesso a una potente 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 imparato come l'API DLP può anonimizzare le stringhe con una maschera per nascondere i tipi di informazioni sulla corrispondenza dei dati
- Abbiamo utilizzato l'API DLP per utilizzare una chiave di crittografia per anonimizzare e quindi identificare nuovamente i dati
- Abbiamo utilizzato l'API DLP per oscurare i dati in una stringa e in un'immagine