InfoTypes e detectores de InfoType

A Proteção de Dados Sensíveis usa tipos de informações, ou infoTypes, para definir o que será verificado. Os infoTypes são tipos de dados confidenciais, como nome, endereço de e-mail, número de telefone, número de identificação, número de cartão de crédito e assim por diante. Um detector de infoType é o mecanismo de detecção correspondente que corresponde aos critérios de correspondência de um infoType.

Observação: se você estiver procurando uma lista atualizada de todos os detectores de infoType integrados, consulte Referência do detector de InfoType.

Práticas recomendadas para selecionar infoTypes

Entender seus dados é uma das primeiras etapas críticas para protegê-los. Como prática recomendada, colete, armazene e processe apenas as informações necessárias para os negócios. Ao identificar os dados que você está processando, é possível tomar decisões fundamentadas para sua empresa, usuários e postura de segurança e privacidade de dados.

Alguns dos seus casos de uso comercial podem exigir determinadas informações sensíveis, e outros não. Não há uma solução única que seja compatível com todos os casos de uso. Por isso, a Proteção de Dados Sensíveis oferece controle flexível sobre os tipos de dados a serem verificados. Se você estiver usando infoTypes para desidentificação ou mascaramento, também terá controle sobre quando e como os dados são transformados.

Importante : os detectores de infoType integrados não são um método de detecção perfeitamente preciso. Por exemplo, eles não podem garantir a conformidade com os requisitos regulatórios. Você precisa decidir quais dados são sensíveis e como protegê-los da melhor forma. O Google recomenda que você teste as configurações para garantir que elas atendam aos seus requisitos.

Diretrizes gerais

Considere as seguintes diretrizes gerais ao selecionar infoTypes.

Usar infoTypes gerais em vez de específicos

Se você não precisar que os resultados da verificação mostrem os infoTypes específicos que foram detectados, use infoTypes gerais em vez de infoTypes específicos nas configurações de inspeção. Para informações sobre as vantagens de usar detectores de infoType gerais nas suas solicitações, consulte Detectores de infoType gerais e específicos nesta página.

Para uma lista completa de infoTypes gerais e os infoTypes específicos que eles incluem, consulte InfoTypes gerais.

Informações sensíveis que você não precisa coletar

Cada serviço da sua empresa precisa coletar apenas os dados necessários. Por exemplo, alguns serviços da sua empresa não precisam coletar informações financeiras. Para esses serviços, considere ativar detectores de infoType, como CREDIT_CARD_NUMBER, FINANCIAL_ACCOUNT_NUMBER e outros infoTypes na categoria de setor FINANCE.

Informações que você precisa coletar, mas não quer compartilhar com toda a equipe

Pode haver casos de uso válidos para coletar informações pessoais, mas você não deve compartilhá-las amplamente com sua equipe. Por exemplo, um cliente que abre um tíquete de suporte pode fornecer dados de contato para que você possa entrar em contato com ele para resolver problemas. Você não quer que todos os membros da equipe que visualizam o tíquete vejam as informações de identificação pessoal (PII). Ative detectores de infoType, como PHONE_NUMBER, EMAIL_ADDRESS e outros infoTypes na categoria de tipo PII.

Categorias de dados sensíveis que estão sob regulamentações do setor, de privacidade de dados ou jurisdicionais

Alguns tipos de informações são considerados sensíveis devido à forma como são emitidos ou ao uso que pode ser feito deles. Em outros casos, as informações contextuais e demográficas são consideradas uma categoria protegida. Esses tipos de informação podem ter restrições adicionais sobre como são coletados, usados e gerenciados. Considere ativar os detectores de infoType nas seguintes categorias:

• Categoria de tipo SPII, GOVERNMENT_ID e DEMOGRAPHIC
• Categoria de setor HEALTH

Como escolher entre infoTypes semelhantes

Considere o seguinte ao escolher entre detectores de infoType semelhantes.

Passaportes

Se você não precisar verificar identificadores de passaporte de um país específico, escolha o detector generalizado: PASSPORT.

Alguns detectores de passaporte específicos de países, como UK_PASSPORT, estão disponíveis. No entanto, alguns detectores de passaporte específicos de cada país só podem identificar passaportes com formatos específicos ou com a presença de pistas contextuais.

Nomes pessoais

Ao procurar nomes de pessoas, use PERSON_NAME na maioria dos casos de uso em vez de FIRST_NAME ou LAST_NAME.

PERSON_NAME é um detector de nomes de pessoas. Isso inclui nomes de uma única palavra e nomes completos. Esse detector tenta detectar, por exemplo, nomes como Jane, Jane Smith e Jane Marie Smith usando várias tecnologias, incluindo o processamento de linguagem natural. FIRST_NAME e LAST_NAME são subconjuntos desse detector que tentam identificar partes de um nome. As descobertas desses detectores são sempre subconjuntos de descobertas de PERSON_NAME.

Datas e horas

Se você não precisar verificar todas as datas, use um detector de datas segmentado, como DATE_OF_BIRTH. Esse detector tenta identificar o contexto que indica que a data está relacionada ao nascimento de uma pessoa.

O detector DATE tenta encontrar todas as datas, independentemente do contexto. Ele também sinaliza datas relativas, como hoje ou ontem. Da mesma forma, TIME tenta encontrar todos os carimbos de data/hora.

Locais

Se você não precisar verificar todos os locais, use STREET_ADDRESS em vez do detector LOCATION. O detector STREET_ADDRESS tenta encontrar endereços totalmente qualificados, que geralmente são mais precisos do que locais genéricos e podem ser considerados mais sensíveis.

O detector de infoType LOCATION tenta encontrar qualquer local, independentemente do contexto, por exemplo, Paris ou Canadá.

Detectores de infoType que exigem contexto

Muitos detectores de infoType exigem que pistas contextuais estejam presentes antes de identificar uma correspondência. Se um detector de infoType integrado não estiver sinalizando itens que você espera que sejam sinalizados, porque não há pistas contextuais próximas a esses itens, use GENERIC_ID ou um detector de infoType personalizado.

Tipos de informações sem uma definição comum do setor

Alguns tipos de informações não têm uma definição comum no setor. Exemplos: números de histórico médico, números de conta, PINs e códigos de segurança. Para esses tipos, considere usar infoTypes como GENERIC_ID, FINANCIAL_ACCOUNT_NUMBER e MEDICAL_RECORD_NUMBER. Esses detectores usam uma combinação de detecção de entidade e contexto para encontrar elementos potencialmente sensíveis.

Observação: se você definir o nível de probabilidade mínima de GENERIC_ID como um valor menor que POSSIBLE, poderá sinalizar a maioria das entidades numéricas e alfanuméricas nos dados.

Detectores de infoType de latência mais alta

• Evite ativar detectores de infoType desnecessários. Embora os infoTypes a seguir sejam úteis em determinados cenários, eles podem fazer com que as solicitações sejam executadas de maneira muito mais lenta do que as solicitações que não os incluem:

  • PERSON_NAME
  • FEMALE_NAME
  • MALE_NAME
  • FIRST_NAME
  • LAST_NAME
  • DATE_OF_BIRTH
  • LOCATION
  • STREET_ADDRESS
  • ORGANIZATION_NAME

• Sempre especifique os detectores de infoType de forma explícita. Não use uma lista de infoTypes vazia.

Como usar infoTypes

A Proteção de Dados Sensíveis usa detectores de infoType na configuração das verificações para determinar o que inspecionar e como transformar as descobertas. Os nomes de infoType também são usados ao exibir ou informar os resultados da verificação.

Por exemplo, se você quiser procurar endereços de e-mail em um bloco de texto, especifique o detector de infoType EMAIL_ADDRESS na configuração de inspeção. Se você quiser editar endereços de e-mail do bloco de texto, especifique EMAIL_ADDRESS na configuração da inspeção e na configuração da desidentificação para indicar como editar ou transformar esse tipo.

Além disso, é possível usar uma combinação de detectores de infoType integrados e detectores de infoType personalizados para excluir um subconjunto de endereços de e-mail das descobertas da verificação. Primeiro, crie um infoType personalizado chamado INTERNAL_EMAIL_ADDRESS e configure-o para excluir endereços de e-mail de teste interno. Em seguida, configure a verificação para incluir descobertas para EMAIL_ADDRESS, mas inclua uma regra de exclusão que exclua todas as descobertas que correspondam a INTERNAL_EMAIL_ADDRESS. Para mais informações sobre regras de exclusão e outros recursos de detectores de infoType personalizados, consulte Como criar detectores de infoType personalizados.

A Proteção de Dados Sensíveis oferece um conjunto de detectores de infoType integrados que você especifica por nome, cada um listado na Referência de detectores de infoType. Esses detectores usam uma variedade de técnicas para descobrir e classificar cada tipo. Por exemplo, alguns tipos exigem uma correspondência de padrão, alguns podem ter somas de verificação matemáticas, alguns têm restrições especiais de dígitos e outros podem ter prefixos específicos ou contexto sobre as descobertas.

Exemplos

Ao configurar a Proteção de Dados Sensíveis para verificar seu conteúdo, inclua os detectores de infoType que serão usados na configuração da verificação.

Por exemplo, os exemplos de código JSON e de código a seguir demonstram uma solicitação de verificação simples para a API DLP. Observe que o detector PHONE_NUMBER é especificado em inspectConfig, que instrui a Proteção de Dados Sensíveis a verificar a string fornecida em busca de um número de telefone.

C#

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

using System;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;

public class InspectPhoneNumber
{
    public static InspectContentResponse Inspect(
        string projectId,
        string text,
        Likelihood minLikelihood = Likelihood.Possible)
    {
        // Instantiate a client.
        var dlp = DlpServiceClient.Create();

        // Set content item.
        var contentItem = new ContentItem { Value = text };

        // Construct inspect config.
        var inspectConfig = new InspectConfig
        {
            InfoTypes = { new InfoType { Name = "PHONE_NUMBER" } },
            IncludeQuote = true,
            MinLikelihood = minLikelihood
        };

        // Construct a request.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = contentItem,
        };

        // Call the API.
        var response = dlp.InspectContent(request);

        // Inspect the results.
        var resultFindings = response.Result.Findings;

        Console.WriteLine($"Findings: {resultFindings.Count}");

        foreach (var f in resultFindings)
        {
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tInfo type: " + f.InfoType.Name);
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectPhoneNumber demonstrates a simple scan request to the Cloud DLP API.
// Notice that the PHONE_NUMBER detector is specified in inspectConfig,
// which instructs Cloud DLP to scan the given string for a phone number.
func inspectPhoneNumber(w io.Writer, projectID, textToInspect string) error {
	// projectID := "my-project-id"
	// textToInspect := "My phone number is [phone]"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}
	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Create and send the request.
	req := &dlppb.InspectContentRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
		Item: &dlppb.ContentItem{
			DataItem: &dlppb.ContentItem_Value{
				Value: textToInspect,
			},
		},
		InspectConfig: &dlppb.InspectConfig{
			// Specify the type of info the inspection will look for.
			// See https://cloud.google.com/dlp/docs/infotypes-reference
			// for complete list of info types
			InfoTypes: []*dlppb.InfoType{
				{Name: "PHONE_NUMBER"},
			},
			IncludeQuote: true,
		},
	}

	// Send the request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		fmt.Fprintf(w, "receive: %v", err)
		return err
	}

	// Process the results.
	result := resp.Result
	fmt.Fprintf(w, "Findings: %d\n", len(result.Findings))
	for _, f := range result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.Likelihood;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

public class InspectPhoneNumber {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String textToInspect = "My name is Gary and my email is [e-mail]";
    inspectString(projectId, textToInspect);
  }

  // Inspects the provided text.
  public static void inspectString(String projectId, String textToInspect) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {
      // Specify the type and content to be inspected.
      ContentItem item = ContentItem.newBuilder().setValue(textToInspect).build();

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      InfoType infoType = InfoType.newBuilder().setName("PHONE_NUMBER").build();

      // Construct the configuration for the Inspect request.
      InspectConfig config =
          InspectConfig.newBuilder()
              .setIncludeQuote(true)
              .setMinLikelihood(Likelihood.POSSIBLE)
              .addInfoTypes(infoType)
              .build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setItem(item)
              .setInspectConfig(config)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');

// Instantiates a client
const dlp = new DLP.DlpServiceClient();

// The project ID to run the API call under
// const projectId = 'my-project';

// The string to inspect
// const string = 'My email is [e-mail] and my phone number is [phone].';

// The minimum likelihood required before returning a match
// const minLikelihood = 'LIKELIHOOD_UNSPECIFIED';

// The maximum number of findings to report per request (0 = server maximum)
// const maxFindings = 0;

// The infoTypes of information to match
// See https://cloud.google.com/dlp/docs/concepts-infotypes for more information
// about supported infoTypes.
// const infoTypes = [{ name: 'PHONE_NUMBER' }];

// The customInfoTypes of information to match
// const customInfoTypes = [{ infoType: { name: 'DICT_TYPE' }, dictionary: { wordList: { words: ['foo', 'bar', 'baz']}}},
//   { infoType: { name: 'REGEX_TYPE' }, regex: {pattern: '\\(\\d{3}\\) \\d{3}-\\d{4}'}}];

// Whether to include the matching string
// const includeQuote = true;

async function inspectPhoneNumber() {
  // Construct item to inspect
  const item = {value: string};

  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: {
      infoTypes: infoTypes,
      customInfoTypes: customInfoTypes,
      minLikelihood: minLikelihood,
      includeQuote: includeQuote,
      limits: {
        maxFindingsPerRequest: maxFindings,
      },
    },
    item: item,
  };

  // Run request
  const [response] = await dlp.inspectContent(request);
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log('Findings:');
    findings.forEach(finding => {
      if (includeQuote) {
        console.log(`\tQuote: ${finding.quote}`);
      }
      console.log(`\tInfo type: ${finding.infoType.name}`);
      console.log(`\tLikelihood: ${finding.likelihood}`);
    });
  } else {
    console.log('No findings.');
  }
}
inspectPhoneNumber();

PHP

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Inspect data for phone numbers
 * Demonstrates a simple scan request to the Cloud DLP API. Notice that the PHONE_NUMBER detector is specified in inspectConfig, which instructs Cloud DLP to scan the given string for a phone number.
 *
 * @param string $projectId         The Google Cloud project id to use as a parent resource.
 * @param string $textToInspect     The string to inspect.
 */
function inspect_phone_number(
    // TODO(developer): Replace sample parameters before running the code.
    string $projectId,
    string $textToInspect = 'My name is Gary and my phone number is [phone]'
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $parent = "projects/$projectId/locations/global";

    // Specify what content you want the service to Inspect.
    $item = (new ContentItem())
        ->setValue($textToInspect);

    $inspectConfig = (new InspectConfig())
        // The infoTypes of information to match
        ->setInfoTypes([
            (new InfoType())->setName('PHONE_NUMBER'),
        ])
        // Whether to include the matching string
        ->setIncludeQuote(true)
        ->setMinLikelihood(Likelihood::POSSIBLE);

    // Run request
    $inspectContentRequest = (new InspectContentRequest())
        ->setParent($parent)
        ->setInspectConfig($inspectConfig)
        ->setItem($item);
    $response = $dlp->inspectContent($inspectContentRequest);

    // Print the results
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Quote: %s' . PHP_EOL, $finding->getQuote());
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

Para saber como instalar e usar a biblioteca de cliente da Proteção de Dados Sensíveis, consulte Bibliotecas de cliente da Proteção de Dados Sensíveis.

Para autenticar na Proteção de Dados Sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import google.cloud.dlp


def inspect_phone_number(
    project: str,
    content_string: str,
) -> None:
    """Uses the Data Loss Prevention API to analyze strings for protected data.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        content_string: The string to inspect phone number from.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": "PHONE_NUMBER"}]

    # Construct the configuration dictionary.
    inspect_config = {
        "info_types": info_types,
        "include_quote": True,
    }

    # Construct the `item`.
    item = {"value": content_string}

    # Convert the project id into a full resource id.
    parent = f"projects/{project}"

    # Call the API.
    response = dlp.inspect_content(
        request={"parent": parent, "inspect_config": inspect_config, "item": item}
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

REST

Entrada JSON:

POST https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/content:inspect?key={YOUR_API_KEY}

{
  "item":{
    "value":"My phone number is [phone]"
  },
  "inspectConfig":{
    "includeQuote":true,
    "minLikelihood":"POSSIBLE",
    "infoTypes":{
      "name":"PHONE_NUMBER"
    }
  }
}

Quando você envia a solicitação anterior ao endpoint especificado, a Proteção de Dados Sensíveis retorna o seguinte:

Saída JSON:

{
  "result":{
    "findings":[
      {
        "quote":"[phone]",
        "infoType":{
          "name":"PHONE_NUMBER"
        },
        "likelihood":"VERY_LIKELY",
        "location":{
          "byteRange":{
            "start":"19",
            "end":"33"
          },
          "codepointRange":{
            "start":"19",
            "end":"33"
          }
        },
        "createTime":"2018-10-29T23:46:34.535Z"
      }
    ]
  }
}

É preciso especificar infoTypes específicos listados na referência na configuração de inspeção. Se você não especificar nenhum infoType, a Proteção de Dados Sensíveis vai usar uma lista padrão de infoTypes destinada apenas para fins de teste. A lista padrão pode não ser adequada para seus casos de uso.

Para mais informações sobre como usar os detectores de infoType para verificar conteúdo, consulte um dos tópicos de instruções sobre inspeção, edição ou desidentificação.

Certeza e teste

As descobertas são informadas com uma pontuação de certeza chamada de probabilidade. A pontuação de probabilidade indica até que ponto é provável que uma descoberta corresponda ao tipo. Por exemplo, um tipo pode retornar uma probabilidade menor se corresponder apenas ao padrão e retornar uma probabilidade maior se corresponder ao padrão e tiver contexto positivo ao redor dele. Por esse motivo, é possível perceber que uma única descoberta pode corresponder a vários tipos com menor probabilidade. Além disso, uma descoberta pode não aparecer ou pode ter menos certeza se não corresponder corretamente ou se tiver contexto negativo em torno dela. Por exemplo, uma descoberta pode não ser relatada se corresponder à estrutura do infoType especificado, mas falhar no checksum do infoType. Ou uma descoberta pode corresponder a mais de um infoType, mas ter um contexto que impulsiona um deles e, portanto, só é informado para esse tipo.

Observação: contexto positivo é quando a inclusão de determinados caracteres, palavras ou frases próximos a um padrão potencialmente correspondente indica à Proteção de Dados Sensíveis que uma correspondência com o padrão é mais provável. Da mesma forma, o contexto negativo ocorre quando a inclusão de determinados caracteres, palavras ou frases próximas a um padrão indica que uma correspondência é menos provável.

Se você estiver testando vários detectores, poderá notar que dados falsos ou de amostra não são informados porque esses dados não são aprovados em verificações suficientes.

Tipos de detectores de infoType

A Proteção de Dados Sensíveis inclui vários tipos de detectores de infoType, todos resumidos aqui:

• Os detectores de infoType integrados são incorporados à Proteção de Dados Sensíveis. Eles incluem detectores para tipos de dados sensíveis específicos de países ou regiões, bem como tipos de dados aplicáveis globalmente. InfoTypes gerais também estão disponíveis para ajudar a simplificar as configurações.
• Os detectores de infoType personalizados são aqueles que você mesmo cria. Há três tipos de detectores de infoType personalizados:
  • Os detectores de dicionário personalizado pequeno são listas de palavras simples que a Proteção de Dados Sensíveis usa para fazer correspondências. Use detectores de dicionário personalizados pequenos quando tiver uma lista de até várias dezenas de milhares de palavras ou frases. Os detectores de dicionários personalizados pequenos são preferidos caso você não preveja alterações significativas na sua lista de palavras.
  • Os detectores de dicionário personalizado grande são gerados pela Proteção de Dados Sensíveis usando listas grandes de palavras ou frases armazenadas no Cloud Storage ou no BigQuery. Use detectores de dicionário personalizados grandes quando tiver uma lista grande de palavras ou frases, até dezenas de milhões.
  • Os detectores de expressões regulares (regex) permitem que a Proteção de Dados Sensíveis detecte correspondências com base em um padrão de expressão regular.

Para refinar os resultados da verificação, crie regras de inspeção.

Detectores de infoType integrados

Os detectores de infoType integrados são incorporados à Proteção de Dados Sensíveis e incluem detectores para tipos de dados sensíveis específicos de países ou regiões, como o Numéro d'Inscription au Répertoire (NIR) (FRANCE_NIR) francês, o número da carteira de habilitação do Reino Unido (UK_DRIVERS_LICENSE_NUMBER) e o CPF ou CNPJ dos EUA (US_SOCIAL_SECURITY_NUMBER). Eles também incluem tipos de dados aplicáveis globalmente, como nome de pessoa (PERSON_NAME), números de telefone (PHONE_NUMBER), endereços de e-mail (EMAIL_ADDRESS) e números de cartão de crédito (CREDIT_CARD_NUMBER).

A lista de detectores de infoType integrados está sempre em atualização. Para uma lista completa daqueles que são compatíveis atualmente, consulte Referência dos detectores de infoType.

Também é possível ver uma lista completa de todos os detectores de infoType integrados chamando o método infoTypes.list da Proteção de Dados Sensíveis.

Técnicas de detecção

Para detectar conteúdo que corresponde a infoTypes integrados, a Proteção de Dados Sensíveis usa várias técnicas, incluindo correspondência de padrões, validação de checksum, machine learning e análise de contexto. Por exemplo, para detectar o infoType CREDIT_CARD_NUMBER, a Proteção de Dados Sensíveis verifica os prefixos de emissores conhecidos, valida as somas de verificação, analisa os comprimentos dos caracteres e considera o contexto em que o possível número de cartão de crédito aparece.

A demonstração da Proteção de Dados Sensíveis é um aplicativo baseado na Web que pode ser usado para testar detectores de InfoType integrados.

Importante : os detectores de infoType integrados não são um método de detecção perfeitamente preciso. Por exemplo, eles não podem garantir a conformidade com os requisitos regulatórios. Você precisa decidir quais dados são sensíveis e como protegê-los da melhor forma. O Google recomenda que você teste as configurações para garantir que elas atendam aos seus requisitos.

Suporte ao idioma

Os infoTypes específicos do país são compatíveis com o idioma inglês e os idiomas do respectivo país. A maioria dos infoTypes globais funciona com vários idiomas. Teste a Proteção de Dados Sensíveis com seus dados para verificar se ela atende aos seus requisitos.

Detectores de infoType gerais e específicos

Um detector de infoType geral é um detector definido de forma mais ampla do que os detectores de infoType típicos e pode corresponder a uma ampla variedade de tipos de informações potencialmente sensíveis. Os detectores de infoType gerais são superséries de detectores de infoType específicos que compartilham um atributo ou propósito comum. Por exemplo, o detector de infoType DRIVERS_LICENSE_NUMBER pode detectar conteúdo que corresponde aos infoTypes GERMANY_DRIVERS_LICENSE_NUMBER e CANADA_DRIVERS_LICENSE_NUMBER.

Em muitos casos, os detectores de infoType gerais também podem encontrar correspondências que os detectores de infoType específicos não conseguem. Por exemplo, o detector PASSPORT é melhor para encontrar números de passaporte do que os detectores de passaporte específicos de cada país, que às vezes exigem a presença de pistas contextuais ou conteúdo formatado especificamente.

Na configuração de inspeção, é possível usar um detector de infoType geral em vez de um detector de infoType específico. A Proteção de Dados Sensíveis apresenta os resultados com base no detector especificado na solicitação. Por exemplo, se uma string que você inspeciona corresponder ao infoType GERMANY_DRIVERS_LICENSE_NUMBER e você tiver verificado DRIVERS_LICENSE_NUMBER e GERMANY_DRIVERS_LICENSE_NUMBER na solicitação, você vai receber duas descobertas para a mesma string: uma para DRIVERS_LICENSE_NUMBER e outra para GERMANY_DRIVERS_LICENSE_NUMBER. No entanto, se você tiver verificado apenas DRIVERS_LICENSE_NUMBER na solicitação, o resultado da inspeção vai mostrar apenas a descoberta de DRIVERS_LICENSE_NUMBER.

O uso de um detector de infoType geral tem as seguintes vantagens:

• Em muitos casos, os detectores de infoType gerais têm um recall maior do que os detectores de infoType específicos. Recall é o número de instâncias de verdadeiro positivo em relação ao número total de instâncias relevantes.

• É possível simplificar as solicitações da Proteção de Dados Sensíveis porque não é necessário especificar cada infoType que você precisa verificar. Por exemplo, o detector de infoType GOVERNMENT_ID inclui mais de 100 detectores de infoType diferentes.

• É menos provável que você atinja o limite de 150 detectores de infoType por solicitação.

• Se a Proteção de Dados Sensíveis lançar um novo infoType e o adicionar a um infoType geral que já está especificado nas suas configurações, ela vai incluir automaticamente o novo infoType nas verificações. Não é necessário adicionar manualmente infoTypes recém-lançados às suas configurações atuais.

Os infoTypes gerais e específicos têm uma relação de muitos para muitos. Ou seja, um infoType geral pode incluir muitos infoTypes específicos, e um infoType específico pode pertencer a muitos infoTypes gerais. Para uma lista completa de infoTypes gerais e os infoTypes específicos que eles incluem, consulte InfoTypes gerais.

Detectores de infoType personalizados

Há três tipos de detectores de infoType personalizados:

• Detectores de dicionários personalizados pequenos
• Detectores de dicionários personalizados grandes
• Expressões regulares (regex)

Para refinar os resultados da verificação, crie regras de inspeção.

Detectores de dicionários personalizados pequenos

Use detectores de dicionários personalizados pequenos (também chamados de "detectores de dicionários personalizados regulares") para corresponder a uma lista curta (até várias dezenas de milhares) de palavras ou frases. Um dicionário personalizado pequeno pode atuar como um detector exclusivo próprio.

Os detectores de dicionários personalizados são úteis quando você quer verificar uma lista de palavras ou frases que não são facilmente correspondidas por uma expressão regular ou um detector incorporado. Por exemplo, se você quiser verificar salas de conferência que geralmente são identificadas não por números, mas por nomes, como nomes de estado ou região, pontos de referência, personagens fictícios, entre outros. É possível criar um detector de dicionário personalizado pequeno que contenha uma lista desses nomes de salas. A Proteção de Dados Sensíveis pode verificar seu conteúdo em busca de cada um dos nomes de salas e retornar uma correspondência quando encontrar um deles no contexto. Saiba mais sobre como a Proteção de Dados Sensíveis faz a correspondência de palavras e frases de dicionário na seção Especificações de correspondência de dicionário de Como criar um detector de dicionário personalizado regular.

Para mais detalhes sobre como detectores de infoType personalizados de dicionário pequenos funcionam, bem como para ver exemplos em ação, consulte Como criar um detector de dicionário personalizado regular.

Detectores de dicionários personalizados grandes

Use detectores de dicionários personalizados grandes (também chamados de "detectores de dicionários personalizados armazenados") quando houver mais de algumas palavras ou frases para verificar ou se sua lista de palavras ou frases mudar com frequência. Detectores de dicionários personalizados grandes podem corresponder a até dezenas de milhões de palavras ou frases.

Os detectores de dicionários personalizados grandes são criados de forma diferente dos detectores personalizados de expressões regulares e dos detectores de dicionários personalizados pequenos. Cada dicionário personalizado grande tem dois componentes:

• Uma lista de frases que você cria e define. Essa lista é armazenada como um arquivo de texto no Cloud Storage ou como uma coluna em uma tabela do BigQuery.
• Os arquivos de dicionário gerados, que são criados pela Proteção de Dados Sensíveis com base na sua lista de frases. Os arquivos de dicionário são armazenados no Cloud Storage e incluem uma cópia dos dados da frase de origem e filtros de Bloom, que ajudam na pesquisa e na correspondência. Não é possível editar esses arquivos diretamente.

Depois de criar uma lista de palavras e usar a Proteção de Dados Sensíveis para gerar um dicionário personalizado, inicie ou programe uma verificação usando um detector de dicionário personalizado grande de maneira semelhante a outros detectores de infoType.

Para mais detalhes sobre como os detectores de dicionários personalizados grandes funcionam, bem como exemplos em ação, consulte Como criar um detector de dicionário personalizado armazenado.

Expressões regulares

Um detector de infoType personalizado de expressão regular (regex) permite criar seus próprios detectores de infoType que permitem que a Proteção de Dados Sensíveis detecte correspondências com base em um padrão regex. Por exemplo, se você tiver números de registros médicos no formato ###-#-#####. Será possível definir um padrão de regex como este:

[1-9]{3}-[1-9]{1}-[1-9]{5}

A Proteção de Dados Sensíveis faz a correspondência de itens como este:

123-4-56789

Também é possível especificar uma probabilidade a ser atribuída a cada correspondência de infoType personalizada. Ou seja, quando a Proteção de Dados Sensíveis corresponder à sequência especificada, ela vai atribuir a probabilidade que você indicou. Isso é útil porque, se o regex personalizado definir uma sequência comum o suficiente, ele poderá corresponder facilmente a outra sequência aleatória. Você não quer que a Proteção de Dados Sensíveis rotule cada correspondência como VERY_LIKELY. Isso pode reduzir a confiança nos resultados da verificação e, possivelmente, fazer com que as informações incorretas sejam correspondidas ou desidentificadas.

Para mais informações sobre detectores de infoType personalizados de expressões regulares e para vê-los em ação, consulte Como criar um detector de regex personalizado.

Regras de inspeção

Use regras de inspeção para refinar os resultados retornados pelos detectores de infoType atuais, sejam eles incorporados ou personalizados. As regras de inspeção podem ser úteis quando os resultados retornados pela Proteção de Dados Sensíveis precisam ser aumentados de alguma forma, seja adicionando ou excluindo do detector de infoType atual.

Para mais informações sobre regras de inspeção, consulte Como modificar os detectores de InfoType para refinar os resultados da verificação.

Regras de exclusão

As regras de exclusão permitem diminuir a quantidade ou a precisão das descobertas retornadas adicionando regras a um detector de infoType integrado ou personalizado. Essas regras podem ajudar a reduzir o ruído ou impedir que resultados indesejados sejam retornados por um detector de infoType.

Por exemplo, se você verificar um banco de dados em busca de endereços de e-mail, poderá adicionar uma regra de exclusão na forma de uma regex personalizada que instrui a Proteção de Dados Sensíveis a excluir todas as descobertas que terminam em "@example.com".

Para mais informações sobre regras de exclusão, consulte Como modificar os detectores de InfoType para refinar os resultados da verificação.

Regras de hotword

As regras de hotword permitem aumentar a quantidade ou a precisão das descobertas retornadas adicionando regras a um detector de infoType integrado ou personalizado. As regras de hotword podem ajudá-lo efetivamente a flexibilizar as regras de um detector de infoType atual.

Por exemplo, suponha que você queira verificar nomes de pacientes em um banco de dados médico. É possível usar o detector de infoType PERSON_NAME integrado da Proteção de Dados Sensíveis, mas isso fará com que a Proteção de Dados Sensíveis corresponda a todos os nomes de pessoas, não apenas aos nomes de pacientes. Para corrigir isso, inclua uma regra de hotword na forma de um infoType personalizado de regex que procure a palavra "paciente" dentro de uma determinada proximidade de caracteres do primeiro caractere de possíveis correspondências. Em seguida, é possível atribuir a descobertas correspondentes a esse padrão uma probabilidade de "muito provável", já que elas correspondem aos critérios especiais.

Para mais informações sobre regras de hotword, consulte Como modificar os detectores de InfoType para refinar os resultados da verificação.

Exemplos

Para ter uma ideia melhor de como os infoTypes correspondem às descobertas, observe os seguintes exemplos de correspondência em uma série de dígitos para determinar se eles representam um número de seguro social dos EUA ou um número de identificação de contribuinte individual dos EUA. Lembre-se de que esses exemplos são para detectores de infoType integrados. Ao criar um detector de infoType personalizado, você especifica os critérios que determinam a probabilidade de uma correspondência de verificação.

Exemplo 1

"SSN 222-22-2222"

Informa um alto índice de probabilidade de VERY_LIKELY para um US_SOCIAL_SECURITY_NUMBER porque:

• Ele está no formato padrão de CPF ou CNPJ, o que aumenta a certeza.
• Ele tem contexto próximo ("SSN") que aumenta tendendo a US_SOCIAL_SECURITY_NUMBER.

Exemplo 2

"999-99-9999"

Informa um baixo índice de probabilidade de VERY_UNLIKELY para um US_SOCIAL_SECURITY_NUMBER porque:

• Ele está no formato padrão, o que aumenta a certeza.
• Ele começa com um 9, o que não é permitido em SSNs e diminui a certeza.
• Falta contexto, o que diminui a certeza.

Exemplo 3

"999-98-9999"

Informa um nível de probabilidade de POSSIBLE para um US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER e VERY_UNLIKELY para US_SOCIAL_SECURITY_NUMBER porque:

• Ele tem o formato padrão para US_SOCIAL_SECURITY_NUMBER e US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Começa com 9 e tem outra verificação de dígitos, o que aumenta a certeza de US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Falta qualquer contexto, o que diminui a certeza para ambos.

Regras de ajuste

As regras de ajuste podem ajudar a refinar a precisão da detecção aumentando (também chamado de boosting) ou diminuindo os valores de probabilidade das descobertas com base no contexto em que elas aparecem.

Por exemplo, é possível usar uma regra de ajuste para aumentar os valores de probabilidade de descobertas de GENERIC_ID quando elas aparecem em documentos que correspondem a DOCUMENT_TYPE/CONTEXT/FINANCE.

Para mais informações, consulte Regras de ajuste.

A seguir

A equipe da Proteção de Dados Sensíveis lança novos detectores e grupos de infoType periodicamente. Para saber como ter a lista mais recente de infoTypes integrados, consulte [Como listar detectores de infoType integrados].