Visão geral do Cloud Data Loss Prevention

1. Visão geral

O Cloud Data Loss Prevention (DLP) é um serviço totalmente gerenciado projetado para ajudar a descobrir, classificar e proteger informações sensíveis. Este codelab apresenta alguns dos recursos básicos da API Cloud DLP e demonstra as várias maneiras como ela pode ser usada para proteger dados.

O que você aprenderá

  • Usar a DLP para inspecionar strings e arquivos para 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)
  • Usar a DLP para encobrir tipos de informações de strings e imagens

O que é necessário

  • Um projeto do Google Cloud com o faturamento configurado. Se não tiver, você vai precisar criar uma.

2. Etapas da configuração

Este codelab pode ser executado totalmente no Google Cloud Platform sem qualquer instalação ou configuração local.

Cloud Shell

Neste codelab, vamos provisionar e gerenciar diferentes recursos e serviços de nuvem usando a linha de comando com o Cloud Shell.

Faça o download do repositório do projeto complementar:

git clone https://github.com/googleapis/nodejs-dlp

Depois de fazer o download do código do projeto, mude para o diretório de exemplos e instale os pacotes Node.js necessários:

cd samples && npm install

Para verificar se o projeto correto está sendo usado, configure-o com o seguinte comando gcloud:

gcloud config set project [PROJECT_ID]

Ativar APIs

Estas são as APIs que precisamos ativar no projeto:

  • API Cloud Data Loss Prevention: oferece métodos para detecção, análise de risco e desidentificação de fragmentos 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 amostras do projeto salvo na etapa anterior contém vários arquivos JavaScript que usam a funcionalidade diferente do Cloud DLP. O inspect.js inspecionará a string ou o arquivo fornecido em busca de tipos de informações sensíveis.

Para testar isso, forneça a opção string e um exemplo de string 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 saída deve informar as descobertas de cada tipo de informação correspondente, que inclui:

Citação: o modelo especifica

InfoType: o tipo de informação detectado para essa parte da string. Confira uma lista completa dos possíveis tipos de informação aqui. Por padrão, inspect.js inspecionará apenas os tipos de informação CREDIT_CARD_NUMBER, PHONE_NUMBER E EMAIL_ADDRESS

Probabilidade: os resultados são categorizados com base na probabilidade de cada um representar uma 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 tipos de informações nos arquivos. Confira o arquivo de amostra 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 serão excluídas:

Findings:
        Quote: 900-649-2568
        Info type: PHONE_NUMBER
        Likelihood: VERY_LIKELY

Os resultados completos, sem essa 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 encontrado:

Findings:
        Quote: anthony@somedomain.com
        Info type: EMAIL_ADDRESS
        Likelihood: LIKELY

Confira abaixo 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. Em seguida, essa solicitação é fornecida à função inspectContent para receber uma resposta que resulta na nossa 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 confidenciais, o Cloud DLP pode realizar a desidentificação. A desidentificação é o processo de remover informações de identificação dos dados. A API detecta dados sensíveis conforme definidos pelos 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 *****************************

O endereço de e-mail na string fica ofuscado, e o número de pedido arbitrário permanece intacto. Tipos de informações personalizadas são possíveis, mas estão fora do escopo deste codelab.

Vamos conferir 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, ele é fornecido à 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 de preservação de formato

A API DLP também oferece a capacidade de criptografar valores de dados confidenciais 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 usaremos para criptografar os dados:

gcloud kms keys create dlp-key \
--purpose='encryption' \
--location=global \
--keyring=dlp-keyring

A API DLP aceita uma chave encapsulada e criptografada com a chave KMS que criamos. Podemos gerar uma string aleatória que será unida. Precisaremos dele mais tarde para reidentificar:

export AES_KEY=`head -c16 < /dev/random | base64 -w 0`

Agora podemos criptografar a string com nossa chave KMS. Isso gera um arquivo binário que contém a string criptografada como texto criptografado:

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 tipos de informação correspondentes substituídos por uma string criptografada e precedidos pelo tipo de informação indicado pela flag -s:

My client's cell is PHONE_NUMBER(10):vSt55z79nR

Vamos dar uma olhada na 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 criar 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, por sua vez, 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 edições ou tipo alternativo indicado:

My client's cell is 9006492568

A função usada para reidentificar dados é semelhante à usada para desidentificar os dados:

deid.js

async function reidentifyWithFpe(
  callingProjectId,
  string,
  alphabet,
  surrogateType,
  keyName,
  wrappedKey
) {
...
}

Mais uma vez, os argumentos são usados em uma solicitação para a 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 certos contextos, as datas podem ser consideradas dados sensíveis que talvez queiramos ofuscar. A mudança de data permite mudar as datas com 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 aquela entrada. Para demonstrar a desidentificação por mudança de data, primeiro confira o exemplo de arquivo CSV 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. deid.js aceitará 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

Também especificamos a coluna de data no arquivo CSV que queremos mudar. O campo birth_date O campo register_date permanece inalterado.

Vejamos a função que lida com a desidentificação com 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, para que possamos fornecer uma chave de criptografia para reidentificar uma mudança de data. Os argumentos que fornecemos 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 para ofuscar informações sensíveis é o encobrimento. Esse recurso vai substituir uma correspondência pelo tipo de informação identificado. redact.js demonstra a edição:

node redact.js -c $GOOGLE_CLOUD_PROJECT \
string "Please refund the purchase to my credit card 4012888888881881" \
-t 'CREDIT_CARD_NUMBER'

A saída substitui o número do cartão de crédito de amostra pelo tipo de informação CREDIT_CARD_NUMBER:

Please refund the purchase on my credit card [CREDIT_CARD_NUMBER]

Isso é útil se você quer ocultar informações sensíveis, mas ainda identificar o tipo de informação que está sendo removida. A API DLP também pode encobrir informações de imagens que contenham texto. Para demonstrar, vamos conferir uma imagem de exemplo:

resources/test.png

bf3719cfeb5676ff.png

Para encobrir o número de telefone e o endereço de e-mail da imagem acima, faça o seguinte:

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 com as informações solicitadas ocultas:

ce023dd95cccc40f.png

Confira a função usada para encobrir uma string:

redact.js

async function redactText(
  callingProjectId, 
  string,
  minLikelihood,
  infoTypes
) {
...}

E esta é a solicitação que será fornecida para a função deidentifyContent:

redact.js

const request = {
    parent: dlp.projectPath(callingProjectId),
    item: {
      value: string,
    },
    deidentifyConfig: {
      infoTypeTransformations: {
        transformations: [replaceWithInfoTypeTransformation],
      },
    },
    inspectConfig: {
      minLikelihood: minLikelihood,
      infoTypes: infoTypes,
    },
  };

Da mesma forma, esta é a função para encobrir uma imagem:

redact.js

async function redactImage(
  callingProjectId,
  filepath,
  minLikelihood,
  infoTypes,
  outputPath
) {
...}

E esta é a solicitação que será fornecida para a 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

Exploramos como podemos usar a API DLP para mascarar, desidentificar e encobrir informações sensíveis dos nossos dados. Agora é hora de limpar todos os recursos que criamos no projeto.

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.

Como alternativa, é possível excluir todo o projeto diretamente no Cloud Shell com a gcloud:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

7. Parabéns!

Uhu! Você conseguiu! O Cloud DLP é uma ferramenta avançada que fornece acesso a uma plataforma avançada de inspeção, classificação e desidentificação de dados confidenciais.

O que aprendemos

  • Vimos como a API Cloud DLP pode ser usada para inspecionar strings e arquivos de vários tipos de informações
  • Aprendemos como a API DLP pode desidentificar strings com uma máscara para ocultar tipos de informações de correspondência de dados
  • Usamos a API DLP com uma chave de criptografia para desidentificar e reidentificar dados
  • Usamos a API DLP para encobrir dados de uma string e de uma imagem