1. Visão geral
O Cloud Data Loss Prevention (DLP) é um serviço totalmente gerenciado criado para ajudar a descobrir, classificar e proteger informações sensíveis. Este codelab vai apresentar alguns dos recursos básicos da API DLP do Cloud e demonstrar as várias maneiras de usá-la para proteger dados.
O que você aprenderá
- Usar a DLP para inspecionar strings e arquivos em busca de tipos de informações correspondentes
- Aprender sobre técnicas de desidentificação e usar a DLP para desidentificar dados
- Saiba como reidentificar dados que foram desidentificados usando criptografia com preservação de formato (FPE, na sigla em inglês)
- Usar o DLP para encobrir tipos de informações de strings e imagens
O que é necessário
- Um projeto na nuvem do Google Cloud com o faturamento configurado. Se você não tiver uma, crie uma.
2. Etapas da configuração
Este codelab pode ser executado completamente no Google Cloud Platform sem instalação ou configuração local.
Cloud Shell
Ao longo deste codelab, vamos provisionar e gerenciar diferentes recursos e serviços de nuvem usando a linha de comando pelo Cloud Shell.
Faça o download do repositório do projeto complementar:
git clone https://github.com/googleapis/nodejs-dlp
Depois de baixar o código do projeto, mude para o diretório de exemplos e instale os pacotes necessários do Node.js:
cd samples && npm install
Defina o projeto correto com o seguinte comando gcloud:
gcloud config set project [PROJECT_ID]
Ativar APIs
Estas são as APIs que precisamos ativar no nosso projeto:
- API Cloud Data Loss Prevention: oferece métodos para detecção, análise de risco e desidentificação de fragmentos com informações confidenciais em textos, imagens e repositórios de armazenamento do Google Cloud Platform.
- API Cloud Key Management Service (KMS): o Google Cloud KMS permite que os clientes gerenciem chaves de criptografia e realizem operações criptográficas com essas chaves.
Ative as APIs necessárias com o seguinte comando gcloud:
gcloud services enable dlp.googleapis.com cloudkms.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
3. Inspecionar strings e arquivos
O diretório de exemplos do projeto baixado na etapa anterior contém vários arquivos JavaScript que usam as diferentes funcionalidades do Cloud DLP. O inspect.js inspeciona uma string ou um arquivo fornecido em busca de tipos de informações sensíveis.
Para testar isso, forneça a opção string e uma string de exemplo com algumas informações potencialmente sensíveis:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'My email address is jenny@somedomain.com and you can call me at 555-867-5309'
A resposta informa as descobertas para cada tipo de informação correspondente, incluindo:
Citação: o modelo especifica
InfoType: o tipo de informação detectado para essa parte da string. Confira uma lista completa dos tipos de informações possíveis aqui. Por padrão, o inspect.js só inspeciona os infoTypes CREDIT_CARD_NUMBER, PHONE_NUMBER E EMAIL_ADDRESS.
Probabilidade: os resultados são categorizados com base na probabilidade de representarem alguma correspondência. A probabilidade pode variar de VERY_UNLIKELY a VERY_LIKELY.
As descobertas da solicitação de comando acima são:
Findings:
Quote: jenny@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Quote: 555-867-5309
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Da mesma forma, podemos inspecionar arquivos em busca de tipos de informações. Confira o arquivo de exemplo accounts.txt:
resources/accounts.txt
My credit card number is 1234 5678 9012 3456, and my CVV is 789.
Execute inspect.js novamente, desta vez com a opção de arquivo:
node inspect.js -c $GOOGLE_CLOUD_PROJECT file resources/accounts.txt
Resultados:
Findings:
Quote: 5678 9012 3456
Info type: CREDIT_CARD_NUMBER
Likelihood: VERY_LIKELY
Para qualquer tipo de consulta, podemos limitar os resultados por probabilidade ou tipo de informação. Exemplo:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -m VERY_LIKELY
Ao especificar VERY_LIKELY como a probabilidade mínima, todas as correspondências menores que VERY_LIKELY são excluídas:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Os resultados completos sem a limitação seriam:
Findings:
Quote: 900-649-2568
Info type: PHONE_NUMBER
Likelihood: VERY_LIKELY
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Da mesma forma, podemos especificar o tipo de informação que estamos verificando:
node inspect.js -c $GOOGLE_CLOUD_PROJECT \ string 'Call 900-649-2568 or email me at anthony@somedomain.com' \ -t EMAIL_ADDRESS
Somente o tipo de informação especificado será retornado se for encontrado:
Findings:
Quote: anthony@somedomain.com
Info type: EMAIL_ADDRESS
Likelihood: LIKELY
Abaixo está a função assíncrona que usa a API para inspecionar a entrada:
inspect.js
async function inspectString(
callingProjectId,
string,
minLikelihood,
maxFindings,
infoTypes,
customInfoTypes,
includeQuote
) {
...
}
Os argumentos fornecidos para os parâmetros acima são usados para construir um objeto de solicitação. Essa solicitação é fornecida à função inspectContent para receber uma resposta que resulta na saída:
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. Desidentificação
Além de inspecionar e detectar dados sensíveis, o Cloud DLP pode realizar a desidentificação. A desidentificação é o processo de remover informações de identificação pessoal dos dados. A API detecta dados sensíveis conforme definidos por tipos de informações e usa uma transformação de desidentificação para mascarar, excluir ou ocultar os dados.
O deid.js vai demonstrar a desidentificação de várias maneiras. O método mais simples de desidentificação é com uma máscara:
node deid.js deidMask -c $GOOGLE_CLOUD_PROJECT \ "My order number is F12312399. Email me at anthony@somedomain.com"
Com uma máscara, a API substitui os caracteres do tipo de informação correspondente por um caractere diferente, * por padrão. A saída será:
My order number is F12312399. Email me at *****************************
Observe que o endereço de e-mail na string está ofuscado, enquanto o número de pedido arbitrário está intacto. InfoTypes personalizados são possíveis, mas estão fora do escopo deste codelab.
Confira a função que usa a API DLP para desidentificar com uma máscara:
deid.js
async function deidentifyWithMask(
callingProjectId,
string,
maskingCharacter,
numberToMask
) {
...
}
Mais uma vez, esses argumentos são usados para construir um objeto de solicitação. Desta vez, eles são fornecidos à função 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);
Desidentificar com criptografia com preservação de formato
A API DLP também oferece a capacidade de criptografar valores de dados sensíveis usando uma chave criptográfica.
Vamos começar usando o Cloud KMS para criar um keyring:
gcloud kms keyrings create dlp-keyring --location global
Agora podemos criar uma chave que será usada para criptografar os dados:
gcloud kms keys create dlp-key \ --purpose='encryption' \ --location=global \ --keyring=dlp-keyring
A API DLP aceita uma chave encapsulada criptografada com a chave do KMS que criamos. Podemos gerar uma string aleatória que será encapsulada. Vamos precisar disso mais tarde para reidentificar:
export AES_KEY=`head -c16 < /dev/random | base64 -w 0`
Agora podemos criptografar a string com nossa chave do KMS. Isso vai gerar um arquivo binário que contém a string criptografada como texto cifrado:
echo -n $AES_KEY | gcloud kms encrypt \ --location global \ --keyring dlp-keyring \ --key dlp-key \ --plaintext-file - \ --ciphertext-file ./ciphertext.bin
Usando deid.js, agora podemos desidentificar o número de telefone na string de exemplo abaixo usando criptografia:
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
A saída vai retornar a string com os infoTypes correspondentes substituídos por uma string criptografada e precedida pelo infoType indicado pela flag -s:
My client's cell is PHONE_NUMBER(10):vSt55z79nR
Confira a função que estamos usando para desidentificar a string:
deid.js
async function deidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
Os argumentos são usados para construir um objeto cryptoReplaceFfxFpeConfig:
deid.js
const cryptoReplaceFfxFpeConfig = {
cryptoKey: {
kmsWrapped: {
wrappedKey: wrappedKey,
cryptoKeyName: keyName,
},
},
commonAlphabet: alphabet,
};
if (surrogateType) {
cryptoReplaceFfxFpeConfig.surrogateInfoType = {
name: surrogateType,
};
}
O objeto cryptoReplaceFfxFpeConfig é usado na solicitação à API pela função 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);
Reidentificar dados
Para reidentificar os dados, a API DLP vai usar o texto criptografado que criamos na etapa anterior:
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
A saída será a string original sem redações ou tipo substituto indicado:
My client's cell is 9006492568
A função usada para reidentificar dados é semelhante à usada para desidentificá-los:
deid.js
async function reidentifyWithFpe(
callingProjectId,
string,
alphabet,
surrogateType,
keyName,
wrappedKey
) {
...
}
E mais uma vez, os argumentos são usados em uma solicitação à API, desta vez para a função 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);
Desidentificar datas com mudança de data
Em determinados contextos, as datas podem ser consideradas dados sensíveis que talvez queiramos ofuscar. Com a mudança de data, podemos alterar datas por um incremento aleatório, preservando a sequência e a duração de um período. Cada data em um conjunto é alterada por um período de tempo exclusivo para essa entrada. Para demonstrar a desidentificação por mudança de data, primeiro confira o arquivo CSV de exemplo que contém dados de data:
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
Os dados contêm dois campos em que podemos aplicar uma mudança de data: birth_date e register_date. O deid.js aceita um valor de limite inferior e um valor de limite superior para definir um intervalo e selecionar um número aleatório de dias para mudar as datas:
node deid.js deidDateShift -c $GOOGLE_CLOUD_PROJECT resources/dates.csv datesShifted.csv 30 90 birth_date
Um arquivo chamado datesShifted.csv será gerado com as datas alteradas aleatoriamente por um número de dias entre 30 e 90. Confira um exemplo da saída gerada:
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
Perceba que também foi possível especificar qual coluna de data no arquivo CSV queríamos mudar. O campo birth_date e o campo register_date permanecem inalterados.
Confira a função que processa a desidentificação com uma mudança de data:
deid.js
async function deidentifyWithDateShift(
callingProjectId,
inputCsvFile,
outputCsvFile,
dateFields,
lowerBoundDays,
upperBoundDays,
contextFieldId,
wrappedKey,
keyName
) {
...
}
Essa função pode aceitar uma chave encapsulada e um nome de chave, semelhante à desidentificação com FPE. Assim, temos a opção de fornecer uma chave de criptografia para reidentificar uma mudança de data. Os argumentos fornecidos criam um objeto 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. Encobrir strings e imagens
Outro método de ofuscação de informações sensíveis é o encobrimento. A redação substitui uma correspondência pelo infoType com o qual ela foi identificada. redact.js demonstra a redação:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ string "Please refund the purchase to my credit card 4012888888881881" \ -t 'CREDIT_CARD_NUMBER'
A resposta substitui o número de cartão de crédito de exemplo pelo InfoType CREDIT_CARD_NUMBER:
Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]
Isso é útil se você quiser ocultar informações sensíveis, mas identificar o tipo de informação que está sendo removida. A API DLP pode fazer o mesmo com informações em imagens que contêm texto. Para demonstrar, vamos analisar uma imagem de exemplo:
resources/test.png
Para encobrir o número de telefone e o endereço de e-mail da imagem acima:
node redact.js -c $GOOGLE_CLOUD_PROJECT \ image resources/test.png ./redacted.png \ -t PHONE_NUMBER -t EMAIL_ADDRESS
Conforme especificado, uma nova imagem chamada redacted.png será gerada ocultando as informações solicitadas:
Esta é a função usada para encobrir uma string:
redact.js
async function redactText(
callingProjectId,
string,
minLikelihood,
infoTypes
) {
...}
Esta é a solicitação que será fornecida à função deidentifyContent:
redact.js
const request = {
parent: dlp.projectPath(callingProjectId),
item: {
value: string,
},
deidentifyConfig: {
infoTypeTransformations: {
transformations: [replaceWithInfoTypeTransformation],
},
},
inspectConfig: {
minLikelihood: minLikelihood,
infoTypes: infoTypes,
},
};
Esta é a função para editar uma imagem:
redact.js
async function redactImage(
callingProjectId,
filepath,
minLikelihood,
infoTypes,
outputPath
) {
...}
Esta é a solicitação que será fornecida à função 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. Limpar
Já vimos como usar a API DLP para mascarar, desidentificar e encobrir informações sensíveis dos nossos dados. Agora é hora de limpar nosso projeto de todos os recursos que criamos.
Excluir o projeto
No Console do GCP, acesse a página Cloud Resource Manager:
Na lista de projetos, selecione o projeto em que estamos trabalhando e clique em Excluir. Você precisará digitar o ID do projeto. Depois de fazer isso, clique em Desligar.
Outra opção é excluir todo o projeto diretamente no Cloud Shell com gcloud:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
7. Parabéns!
Uhu! Você conseguiu! O Cloud DLP é uma ferramenta poderosa que fornece acesso a uma plataforma avançada de inspeção, classificação e desidentificação de dados sensíveis.
O que aprendemos
- Vimos como a API DLP do Cloud pode ser usada para inspecionar strings e arquivos em busca de vários tipos de informações.
- Aprendemos como a API DLP pode desidentificar strings com uma máscara para ocultar dados que correspondem a tipos de informações.
- Usamos a API DLP para usar uma chave de criptografia e desidentificar e depois reidentificar dados.
- Usamos a API DLP para encobrir dados de uma string e de uma imagem.