1. Übersicht
Cloud Data Loss Prevention (DLP) ist ein vollständig verwalteter Dienst, mit dem Sie sensible Daten ermitteln, klassifizieren und schützen können. In diesem Codelab werden einige der grundlegenden Funktionen der Cloud DLP API vorgestellt und verschiedene Möglichkeiten gezeigt, wie sie zum Schutz von Daten verwendet werden kann.
Aufgaben
- Strings und Dateien mit DLP auf übereinstimmende infoTypes prüfen
- Techniken zur De-Identifikation kennenlernen und Daten mit DLP de-identifizieren
- Daten re-identifizieren, die mit formaterhaltender Verschlüsselung (Format-Preserving Encryption, FPE) de-identifiziert wurden
- Mit DLP infoTypes aus Strings und Bildern entfernen
Voraussetzungen
- Ein Google Cloud-Projekt mit eingerichteter Abrechnung. Wenn Sie noch kein Konto haben, müssen Sie eins erstellen.
2. Einrichtung
Dieses Codelab kann vollständig auf der Google Cloud Platform ausgeführt werden, ohne dass eine lokale Installation oder Konfiguration erforderlich ist.
Cloud Shell
In diesem Codelab stellen wir verschiedene Cloud-Ressourcen und -Dienste über die Befehlszeile über Cloud Shell bereit und verwalten sie.
Laden Sie das Companion-Projekt-Repository herunter:
git clone https://github.com/googleapis/nodejs-dlp
Nachdem Sie den Projektcode heruntergeladen haben, wechseln Sie in das Verzeichnis „samples“ und installieren Sie die erforderlichen Node.js-Pakete:
cd samples && npm install
Verwenden Sie das richtige Projekt, indem Sie es mit dem folgenden gcloud-Befehl festlegen:
gcloud config set project [PROJECT_ID]
APIs aktivieren
Die folgenden APIs müssen für unser Projekt aktiviert sein:
- Cloud Data Loss Prevention API: Bietet Methoden zum Erkennen, zur Risikoanalyse und zur De-Identifizierung von Fragmenten von datenschutzrechtlich sensiblen Daten in Text, Bildern und Google Cloud-Speicher-Repositories.
- Cloud Key Management Service (KMS) API: Google Cloud KMS ermöglicht Kunden die Verwaltung von Verschlüsselungsschlüsseln und die Ausführung kryptografischer Vorgänge mit diesen Schlüsseln.
Aktivieren Sie die erforderlichen APIs mit dem folgenden gcloud-Befehl:
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. Strings und Dateien prüfen
Das Verzeichnis „samples“ des im vorherigen Schritt heruntergeladenen Projekts enthält mehrere JavaScript-Dateien, die die verschiedenen Funktionen von Cloud DLP nutzen. inspect.js prüft einen bereitgestellten String oder eine Datei auf sensible infoTypes.
Um dies zu testen, können Sie die Option string und einen Beispiel-String mit potenziell sensiblen Informationen angeben:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
Die Ausgabe sollte die Ergebnisse für den jeweils übereinstimmenden infoType enthalten, einschließlich:
Angebot: In der Vorlage wird Folgendes angegeben:
InfoType: Der für diesen Teil des Strings erkannte infoType. Eine vollständige Liste der möglichen infoTypes finden Sie hier. Standardmäßig wird inspect.js nur nach den Infotypen CREDIT_CARD_NUMBER, PHONE_NUMBER und EMAIL_ADDRESS durchsucht.
Wahrscheinlichkeit: Die Ergebnisse werden nach der Wahrscheinlichkeit kategorisiert, dass sie eine Übereinstimmung darstellen. Die Wahrscheinlichkeit kann zwischen VERY_UNLIKELY und VERY_LIKELY liegen.
Die Ergebnisse für die obige Anfrage sind:
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Ebenso können wir Dateien auf infoTypes prüfen. Sehen Sie sich die Beispieldatei accounts.txt an:
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
Führen Sie inspect.js noch einmal aus, dieses Mal mit der Dateioption:
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
Das Ergebnis:
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
Bei beiden Arten von Anfragen konnten wir die Ergebnisse nach Wahrscheinlichkeit oder Informationstyp einschränken. Beispiel:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
Wenn Sie VERY_LIKELY als Mindestwahrscheinlichkeit angeben, werden alle Übereinstimmungen unter VERY_LIKELY ausgeschlossen:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Die vollständigen Ergebnisse ohne die Einschränkung wären:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Ebenso können wir den Informationstyp angeben, nach dem wir suchen:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
Wenn der angegebene Informationstyp gefunden wird, wird nur dieser zurückgegeben:
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Unten sehen Sie die asynchrone Funktion, die die API verwendet, um die Eingabe zu prüfen:
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
Die für die obigen Parameter angegebenen Argumente werden verwendet, um ein Anfrageobjekt zu erstellen. Diese Anfrage wird dann an die Funktion inspectContent übergeben, um eine Antwort zu erhalten, die die folgende Ausgabe erzeugt:
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. De-Identifikation
Neben der Prüfung und Erkennung sensibler Daten kann Cloud DLP auch die De-Identifikation durchführen. Als De-Identifikation wird der Prozess bezeichnet, bei dem identifizierende Informationen aus Daten entfernt werden. Die API erkennt sensible Daten, die durch infoTypes definiert sind, und verwendet dann eine De-Identifikationstransformation, um die Daten zu maskieren, zu löschen oder anderweitig zu verschleiern.
deid.js demonstriert die Anonymisierung auf verschiedene Weise. Die einfachste Methode zur Anonymisierung ist die Verwendung einer Maske:
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
Bei einer Maske ersetzt die API die Zeichen des übereinstimmenden infoTypes durch ein anderes Zeichen, standardmäßig durch *. Die Ausgabe sieht so aus:
My order number is F12312399. Email me at *****************************
Die E‑Mail-Adresse im String ist verschleiert, während die beliebige Bestellnummer intakt ist. (Benutzerdefinierte infoTypes sind möglich, werden in diesem Codelab aber nicht behandelt.)
Sehen wir uns die Funktion an, die die DLP API verwendet, um Daten mit einer Maske zu de-identifizieren:
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Auch hier werden diese Argumente verwendet, um ein Anfrageobjekt zu erstellen. Dieses Mal wird sie der Funktion deidentifyContent bereitgestellt:
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);
Mit formaterhaltender Verschlüsselung de-identifizieren
Die DLP API bietet auch die Möglichkeit, Werte sensibler Daten mit einem kryptografischen Schlüssel zu verschlüsseln.
Zuerst erstellen wir mit Cloud KMS einen Schlüsselbund:
gcloud kms keyrings create dlp-keyring --location global
Jetzt können wir einen Schlüssel erstellen, mit dem wir die Daten verschlüsseln:
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
Die DLP API akzeptiert einen verpackten Schlüssel, der mit dem von uns erstellten KMS-Schlüssel verschlüsselt ist. Wir können einen zufälligen String generieren, der umbrochen wird. Wir benötigen diese Informationen später, um die Identität noch einmal zu bestätigen:
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
Jetzt können wir den String mit unserem KMS-Schlüssel verschlüsseln. Dadurch wird eine Binärdatei generiert, die den verschlüsselten String als Chiffretext enthält:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
Mit deid.js können wir die Telefonnummer im folgenden Beispielstring jetzt mithilfe von Verschlüsselung anonymisieren:
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
In der Ausgabe wird der String mit den übereinstimmenden infoTypes zurückgegeben, die durch einen verschlüsselten String ersetzt werden. Vorangestellt ist der infoType, der durch das Flag „-s“ angegeben wird:
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Sehen wir uns die Funktion an, mit der wir den String anonymisieren:
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Die Argumente werden verwendet, um ein cryptoReplaceFfxFpeConfig-Objekt zu erstellen:
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
Das cryptoReplaceFfxFpeConfig-Objekt wird wiederum in der Anfrage an die API über die Funktion deidentifyContent verwendet:
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);
Daten re-identifizieren
Um die Daten zu re-identifizieren, verwendet die DLP API den Chiffretext, den wir im vorherigen Schritt erstellt haben:
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
Die Ausgabe ist der Originalstring ohne Schwärzungen oder Angabe des Ersatztyps:
My client's cell is 9006492568
Die Funktion, die zum Reidentifizieren von Daten verwendet wird, ähnelt der Funktion, die zum Anonymisieren verwendet wird:
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Auch hier werden die Argumente in einer Anfrage an die API verwendet, diesmal für die Funktion 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);
Datumsangaben mit der Datumsverschiebung de-identifizieren
In bestimmten Kontexten können Datumsangaben als sensible Daten gelten, die wir möglicherweise verschleiern möchten. Mit der Datumsverschiebung können wir Datumsangaben um einen zufälligen Wert verschieben, ohne die Reihenfolge und Dauer eines Zeitraums zu ändern. Jedes Datum in einem Satz wird um einen Zeitraum verschoben, der sich eindeutig auf diesen Eintrag bezieht. Sehen Sie sich zuerst die CSV-Beispieldatei mit Datumsdaten an, um die Anonymisierung durch Datumsverschiebung zu veranschaulichen:
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
Die Daten enthalten zwei Felder, auf die wir eine Datumsverschiebung anwenden könnten: birth_date und register_date. deid.js akzeptiert einen Unter- und einen Oberwert, um einen Bereich zu definieren, aus dem eine zufällige Anzahl von Tagen ausgewählt wird, um die Datumsangaben zu verschieben:
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
Eine Datei mit dem Namen datesShifted.csv wird generiert. Die Datumsangaben darin werden zufällig um eine Anzahl von Tagen zwischen 30 und 90 verschoben. Hier ein Beispiel für die generierte Ausgabe:
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
Wir konnten auch angeben, welche Datumsspalte in der CSV-Datei verschoben werden soll. Das Feld birth_date Das Feld register_date bleibt unverändert.
Sehen wir uns die Funktion an, die die Anonymisierung mit einer Datumsverschiebung verarbeitet:
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Diese Funktion kann einen umschlossenen Schlüssel und einen Schlüsselnamen akzeptieren, ähnlich wie bei der De-Identifikation mit FPE. So haben wir die Möglichkeit, einen Verschlüsselungsschlüssel für die Re-Identifikation einer Datumsverschiebung anzugeben. Mit den von uns bereitgestellten Argumenten wird ein „dateShiftConfig“-Objekt erstellt:
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. Strings und Bilder entfernen
Eine weitere Methode zum Verschleiern sensibler Informationen ist das Unkenntlichmachen. Beim Unkenntlichmachen wird eine Übereinstimmung durch den Infotyp ersetzt, mit dem sie übereinstimmt. redact.js zeigt das Entfernen von Inhalten:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
In der Ausgabe wird die Beispiel-Kreditkartennummer durch den infoType CREDIT_CARD_NUMBER ersetzt:
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
Das ist nützlich, wenn Sie sensible Informationen unsichtbar machen wollen, aber trotzdem den Typ der unkenntlich gemachten Informationen erkennen möchten. Ensprechend kann die DLP API auch Informationen in Bildern unkenntlich machen, die Text enthalten. Sehen wir uns dazu ein Beispielbild an:
resources/test.png
So machen Sie die Telefonnummer und E‑Mail-Adresse im obigen Bild unkenntlich:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
Wie angegeben, wird ein neues Bild mit dem Namen „redacted.png“ generiert, in dem die angeforderten Informationen geschwärzt sind:
Hier die Funktion, die zum Unkenntlichmachen von Text in einem String verwendet wird:
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Und hier die Anfrage, die an die Funktion deidentifyContent gesendet wird:
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
Hier die Funktion zum Unkenntlichmachen von Informationen in einem Bild:
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
Und hier die Anfrage, die an die Funktion redactImage gesendet wird:
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. Bereinigen
Wir haben uns angesehen, wie wir mit der DLP API sensible Informationen in unseren Daten maskieren, de-identifizieren und entfernen können. Jetzt ist es an der Zeit, alle Ressourcen zu entfernen, die wir in unserem Projekt erstellt haben.
Projekt löschen
Rufen Sie in der GCP Console die Seite Cloud Resource Manager auf:
Wählen Sie in der Projektliste das Projekt aus, in dem wir gearbeitet haben, und klicken Sie auf Löschen. Sie werden aufgefordert, die Projekt-ID einzugeben. Geben Sie sie ein und klicken Sie auf Herunterfahren.
Alternativ können Sie das gesamte Projekt direkt über Cloud Shell mit gcloud löschen:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. Glückwunsch!
Hurra! Geschafft! Cloud DLP ist ein leistungsstarkes Tool, das Zugriff auf eine leistungsfähige Plattform für die Prüfung, Klassifizierung und De-Identifikation sensibler Daten bietet.
Behandelte Themen
- Wir haben gesehen, wie die Cloud DLP API verwendet werden kann, um Strings und Dateien auf mehrere infoTypes zu prüfen.
- Wir haben gelernt, wie die DLP API Strings mit einer Maske de-identifizieren kann, um Daten zu verbergen, die mit InfoTypes übereinstimmen.
- Wir haben die DLP API verwendet, um Daten mit einem Verschlüsselungsschlüssel zu de-identifizieren und dann wieder zu identifizieren.
- Wir haben die DLP API verwendet, um Daten in einem String und einem Bild unkenntlich zu machen.