1. Przegląd
Cloud Data Loss Prevention (DLP) to usługa w pełni zarządzana, która pomaga wykrywać, klasyfikować i chronić informacje poufne. W tym module dowiesz się o podstawowych możliwościach interfejsu Cloud DLP API i poznasz różne sposoby jego wykorzystania do ochrony danych.
Co musisz zrobić
- Używanie DLP do sprawdzania ciągów znaków i plików pod kątem pasujących typów informacji
- Dowiedz się więcej o technikach deidentyfikacji i używaj DLP do deidentyfikacji danych
- Dowiedz się, jak ponownie identyfikować dane, które zostały pozbawione cech umożliwiających identyfikację za pomocą szyfrowania z zachowaniem formatu
- Używanie DLP do redagowania typów informacji z ciągów znaków i obrazów
Czego potrzebujesz
- projekt Google Cloud ze skonfigurowanymi rozliczeniami; Jeśli nie masz konta, musisz je utworzyć.
2. Przygotowania
Ten przewodnik można w całości uruchomić na Google Cloud Platform bez konieczności instalowania ani konfigurowania czegokolwiek lokalnie.
Cloud Shell
W tym module praktycznym będziemy udostępniać różne zasoby i usługi w chmurze oraz nimi zarządzać za pomocą wiersza poleceń w Cloud Shell.
Pobierz repozytorium projektu towarzyszącego:
git clone https://github.com/googleapis/nodejs-dlp
Po pobraniu kodu projektu przejdź do katalogu samples i zainstaluj wymagane pakiety Node.js:
cd samples && npm install
Upewnij się, że używasz właściwego projektu, ustawiając go za pomocą tego polecenia gcloud:
gcloud config set project [PROJECT_ID]
Włączanie interfejsów API
Oto interfejsy API, które musimy włączyć w naszym projekcie:
- Cloud Data Loss Prevention API – udostępnia metody wykrywania, analizy ryzyka i deidentyfikacji poufnych fragmentów w tekstach, obrazach i repozytoriach Google Cloud Platform.
- Cloud Key Management Service (KMS) API – Google Cloud KMS umożliwia klientom zarządzanie kluczami szyfrowania i wykonywanie operacji kryptograficznych z użyciem tych kluczy.
Włącz wymagane interfejsy API za pomocą tego polecenia gcloud:
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. Sprawdzanie ciągów tekstowych i plików
Katalog samples projektu pobranego w poprzednim kroku zawiera kilka plików JavaScript, które korzystają z różnych funkcji Cloud DLP. inspect.js sprawdzi podany ciąg znaków lub plik pod kątem typów informacji poufnych.
Aby to przetestować, możesz podać opcję string i przykładowy ciąg znaków z potencjalnie poufnymi informacjami:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
Dane wyjściowe powinny zawierać wyniki dla każdego dopasowanego typu informacji, w tym:
Oferta: szablon określa
InfoType: typ informacji wykryty w tej części ciągu znaków. Pełną listę możliwych typów informacji znajdziesz tutaj. Domyślnie inspect.js sprawdza tylko typy informacji CREDIT_CARD_NUMBER, PHONE_NUMBER i EMAIL_ADDRESS.
Prawdopodobieństwo: wyniki są podzielone na kategorie na podstawie prawdopodobieństwa, że każdy z nich stanowi dopasowanie. Prawdopodobieństwo może wynosić od VERY_UNLIKELY do VERY_LIKELY.
Wyniki powyższej prośby o polecenie to:
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Podobnie możemy sprawdzać pliki pod kątem typów informacji. Zapoznaj się z przykładowym plikiem accounts.txt:
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
Uruchom ponownie polecenie inspect.js, tym razem z opcją pliku:
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
Wyniki:
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
W przypadku obu rodzajów zapytań możemy ograniczyć wyniki według prawdopodobieństwa lub typu informacji. Na przykład:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
Jeśli jako minimalne prawdopodobieństwo określisz VERY_LIKELY, wszystkie dopasowania o wartości mniejszej niż VERY_LIKELY zostaną wykluczone:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Pełne wyniki bez ograniczeń wyglądałyby tak:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Podobnie możemy określić typ informacji, które sprawdzamy:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
Jeśli zostanie znaleziony określony typ informacji, zwracany jest tylko on:
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Poniżej znajduje się funkcja asynchroniczna, która używa interfejsu API do sprawdzania danych wejściowych:
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
Argumenty podane w przypadku powyższych parametrów służą do tworzenia obiektu żądania. Ta prośba jest następnie przekazywana do funkcji inspectContent, aby uzyskać odpowiedź, która jest naszym wynikiem:
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. Deidentyfikacja
Oprócz sprawdzania i wykrywania danych wrażliwych usługa Cloud DLP może przeprowadzać deidentyfikację. Deidentyfikacja to proces usuwania z danych informacji umożliwiających identyfikację. Interfejs API wykrywa dane wrażliwe zdefiniowane przez typy informacji, a następnie używa transformacji deidentyfikującej do maskowania, usuwania lub innego ukrywania danych.
deid.js zademonstruje usuwanie danych umożliwiających identyfikację na kilka sposobów. Najprostsza metoda deidentyfikacji to maskowanie:
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
W przypadku maski interfejs API zastąpi znaki pasującego typu informacji innym znakiem, domyślnie *. Dane wyjściowe będą wyglądać tak:
My order number is F12312399. Email me at *****************************
Zwróć uwagę, że adres e-mail w ciągu znaków jest zamaskowany, a dowolny numer zamówienia jest nienaruszony. (Niestandardowe typy informacji są możliwe, ale wykraczają poza zakres tych ćwiczeń z programowania).
Oto funkcja, która używa interfejsu DLP API do deidentyfikacji za pomocą maski:
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Te argumenty są ponownie używane do utworzenia obiektu żądania. Tym razem jest ona przekazywana do funkcji 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);
Usuwanie identyfikacji za pomocą szyfrowania z zachowaniem formatu
Interfejs DLP API umożliwia też szyfrowanie wartości danych wrażliwych za pomocą klucza kryptograficznego.
Zacznij od utworzenia pęku kluczy za pomocą Cloud KMS:
gcloud kms keyrings create dlp-keyring --location global
Teraz możemy utworzyć klucz, którego użyjemy do zaszyfrowania danych:
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
Interfejs DLP API zaakceptuje klucz obudowany zaszyfrowany przy użyciu utworzonego przez nas klucza KMS. Możemy wygenerować losowy ciąg znaków, który zostanie opakowany. Będziemy tego później potrzebować, aby ponownie zidentyfikować:
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
Teraz możemy zaszyfrować ciąg znaków za pomocą klucza KMS. Spowoduje to wygenerowanie pliku binarnego zawierającego zaszyfrowany ciąg znaków w postaci tekstu zaszyfrowanego:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
Za pomocą funkcji deid.js możemy teraz usunąć z poniższego ciągu przykładowego numer telefonu, stosując szyfrowanie:
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
Dane wyjściowe będą zawierać ciąg znaków z dopasowanymi typami informacji zastąpionymi zaszyfrowanym ciągiem znaków, przed którym będzie się znajdować typ informacji wskazany przez flagę -s:
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Przyjrzyjmy się funkcji, której używamy do anonimizacji ciągu znaków:
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Argumenty służą do tworzenia obiektu cryptoReplaceFfxFpeConfig:
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
Obiekt cryptoReplaceFfxFpeConfig jest z kolei używany w żądaniu do interfejsu API za pomocą funkcji 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);
Ponowna identyfikacja danych
Aby ponownie zidentyfikować dane, interfejs DLP API użyje tekstu szyfrowanego utworzonego w poprzednim kroku:
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
Dane wyjściowe będą oryginalnym ciągiem znaków bez redakcji ani wskazanego typu zastępczego:
My client's cell is 9006492568
Funkcja używana do ponownej identyfikacji danych jest podobna do funkcji używanej do ich deidentyfikacji:
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Argumenty są ponownie używane w żądaniu do interfejsu API, tym razem w funkcji 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);
Anonimizacja dat za pomocą przesunięcia daty
W określonych kontekstach daty mogą być uznawane za dane wrażliwe, które warto zamaskować. Przesuwanie dat umożliwia przesuwanie dat o losowy przyrost, przy jednoczesnym zachowaniu kolejności i długości okresu. Każda data w zbiorze jest przesuwana o czas unikalny dla danego wpisu. Aby zademonstrować usuwanie danych umożliwiających identyfikację za pomocą przesunięcia daty, najpierw zapoznaj się z przykładowym plikiem CSV zawierającym dane dotyczące dat:
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
Dane zawierają 2 pola, do których możemy zastosować przesunięcie daty: birth_date i register_date. Plik deid.js będzie akceptować wartość dolną i górną, aby zdefiniować zakres, z którego można wybrać losową liczbę dni, o którą zostaną przesunięte daty:
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
Zostanie wygenerowany plik o nazwie datesShifted.csv, w którym daty zostaną losowo przesunięte o liczbę dni z zakresu od 30 do 90. Oto przykład wygenerowanych danych wyjściowych:
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
Zwróć uwagę, że mogliśmy też określić, którą kolumnę dat w pliku CSV chcieliśmy przesunąć. Pole birth_date pozostaje bez zmian.register_date
Przyjrzyjmy się funkcji, która obsługuje usuwanie danych umożliwiających identyfikację za pomocą przesunięcia daty:
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Zwróć uwagę, że ta funkcja może akceptować klucz opakowany i nazwę klucza, podobnie jak deidentyfikacja z użyciem FPE, dzięki czemu mamy możliwość podania klucza szyfrowania w celu ponownej identyfikacji przesunięcia daty. Podane przez nas argumenty tworzą obiekt 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. Redagowanie ciągów tekstowych i obrazów
Inną metodą maskowania informacji poufnych jest redagowanie. Redakcja zastąpi dopasowanie typem informacji, z którym zostało zidentyfikowane. redact.js demonstruje redagowanie:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
W wyniku numer próbnej karty kredytowej zostanie zastąpiony typem informacji CREDIT_CARD_NUMBER:
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
Jest to przydatne, jeśli chcesz ukryć informacje wrażliwe, ale nadal identyfikować typ usuwanych informacji. Interfejs DLP API może w podobny sposób usuwać informacje z obrazów zawierających tekst. Aby to zilustrować, spójrzmy na przykładowy obraz:
resources/test.png
Aby usunąć numer telefonu i adres e-mail z obrazu powyżej:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
Zgodnie z podaną specyfikacją zostanie wygenerowany nowy obraz o nazwie redacted.png, na którym żądane informacje będą zamazane:
Oto funkcja, która służy do usuwania informacji z ciągu znaków:
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Oto żądanie, które zostanie przekazane do funkcji deidentifyContent:
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
Oto funkcja do redagowania obrazu:
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
Oto żądanie, które zostanie przekazane do funkcji 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. Czyszczenie danych
Sprawdziliśmy, jak możemy używać interfejsu DLP API do maskowania, anonimizowania i usuwania informacji poufnych z naszych danych. Teraz musimy usunąć z projektu wszystkie utworzone zasoby.
Usuwanie projektu
W konsoli GCP otwórz stronę Cloud Resource Manager:
Na liście projektów wybierz projekt, nad którym pracowaliśmy, i kliknij Usuń. Pojawi się prośba o wpisanie identyfikatora projektu. Wpisz go i kliknij Wyłącz.
Możesz też usunąć cały projekt bezpośrednio z Cloud Shell za pomocą gcloud:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. Gratulacje!
Super! Udało się! Cloud DLP to zaawansowane narzędzie, które zapewnia dostęp do platformy do inspekcji, klasyfikowania i deidentyfikacji danych wrażliwych.
Omówione zagadnienia
- Dowiedzieliśmy się, jak za pomocą interfejsu Cloud DLP API można sprawdzać ciągi znaków i pliki pod kątem różnych typów informacji.
- Dowiedzieliśmy się, jak interfejs DLP API może usuwać tożsamość ciągów znaków za pomocą maski, aby ukryć dane pasujące do typów informacji.
- Użyliśmy interfejsu DLP API, aby za pomocą klucza szyfrowania usunąć identyfikatory z danych, a następnie je przywrócić.
- Użyliśmy interfejsu DLP API, aby usunąć dane z ciągu znaków i obrazu.