InfoType e rilevatori di infoType

Sensitive Data Protection utilizza tipi di informazioni, o infoType, per definire cosa analizzare. Un infoType è un tipo di dato sensibile, ad esempio nome, indirizzo email, numero di telefono, numero di identificazione, numero di carta di credito e così via. Un rilevatore di infoType è il meccanismo di rilevamento corrispondente che corrisponde ai criteri di corrispondenza di un infoType.

Best practice per la selezione degli infoType

Comprendere i tuoi dati è uno dei primi passi fondamentali per proteggerli. Come best practice, devi raccogliere, archiviare ed elaborare solo le informazioni per cui hai un'esigenza aziendale. Identificando i dati che gestisci, puoi prendere decisioni informate per la tua attività, i tuoi utenti e la tua postura in materia di sicurezza e privacy dei dati.

Alcuni casi d'uso aziendali potrebbero richiedere determinate informazioni sensibili, altri no. Non esiste una soluzione unica che supporti tutti i casi d'uso. Per questo motivo, Sensitive Data Protection offre un controllo flessibile sui tipi di dati da analizzare. Se utilizzi infoType per l'anonimizzazione o il mascheramento, hai anche il controllo di quando e come vengono trasformati i dati.

Linee guida generali

Quando selezioni gli infoType, tieni presente le seguenti linee guida generali.

Utilizzare infoType generali al posto di infoType specifici

Se non vuoi che i risultati della scansione mostrino gli infoType specifici rilevati, valuta la possibilità di utilizzare infoType generali anziché specifici nelle configurazioni di ispezione. Per informazioni sui vantaggi dell'utilizzo di rilevatori di infoType generali nelle richieste, consulta la sezione Rilevatori di infoType generali e specifici in questa pagina.

Per un elenco completo degli infoType generali e di quelli specifici che includono, vedi infoType generali.

Informazioni sensibili che non devi raccogliere

Ogni servizio della tua attività deve raccogliere solo i dati necessari. Ad esempio, alcuni servizi della tua attività non devono raccogliere informazioni finanziarie. Per questi servizi, valuta la possibilità di attivare i rilevatori di infoType come CREDIT_CARD_NUMBER, FINANCIAL_ACCOUNT_NUMBER e altri infoType nella categoria di settore FINANCE.

Informazioni che devi raccogliere, ma che non vuoi condividere in modo ampio con il tuo team

Potrebbero esistere casi d'uso validi per la raccolta di informazioni personali, ma non dovresti condividerle in modo generico con il tuo team. Ad esempio, un cliente che presenta una ticket di assistenzaa potrebbe fornirti i suoi dati di contatto, in modo che tu possa contattarlo per risolvere eventuali problemi. Non vuoi che tutti i membri del team che visualizzano il ticket vedano le informazioni che consentono l'identificazione personale (PII). Valuta la possibilità di attivare i rilevatori di infoType come PHONE_NUMBER, EMAIL_ADDRESS e altri infoType nella categoria di tipo PII.

Categorie di dati sensibili soggette a normative di settore, sulla privacy o giurisdizionali

Alcuni tipi di informazioni sono considerati sensibili a causa del modo in cui vengono emessi o per cosa possono essere utilizzati. In altri casi, le informazioni contestuali e demografiche sono considerate una categoria protetta. Questi tipi di informazioni potrebbero essere soggetti a ulteriori limitazioni in merito a modalità di raccolta, utilizzo e gestione. Valuta la possibilità di attivare i rilevatori di infoType nelle seguenti categorie:

• Categoria di tipo SPII, GOVERNMENT_ID e DEMOGRAPHIC
• Categoria settore HEALTH

Scegliere tra infoType simili

Quando scegli tra rilevatori di infoType simili, tieni presente quanto segue.

Passaporti

Se non devi eseguire la scansione degli identificatori del passaporto di un paese specifico, scegli il rilevatore generico: PASSPORT.

Sono disponibili alcuni rilevatori di passaporti specifici per paese, come UK_PASSPORT. Tuttavia, alcuni rilevatori di passaporti specifici per paese possono identificare solo passaporti con formati specifici o con la presenza di indizi contestuali.

Nomi di persone

Quando esegui la scansione dei nomi delle persone, utilizza PERSON_NAME per la maggior parte dei casi d'uso anziché FIRST_NAME o LAST_NAME.

PERSON_NAME è un rilevatore per i nomi delle persone. Include nomi di una sola parola e nomi completi. Questo rilevatore tenta di rilevare, ad esempio, nomi come Jane, Jane Smith e Jane Marie Smith utilizzando varie tecnologie, tra cui la comprensione del linguaggio naturale. FIRST_NAME e LAST_NAME sono sottoinsiemi di questo rilevatore che tentano di identificare le parti di un nome. I risultati di questi rilevatori sono sempre sottoinsiemi dei risultati di PERSON_NAME.

Date e ore

Se non devi eseguire la scansione di tutte le date, valuta la possibilità di utilizzare un rilevatore di date mirato come DATE_OF_BIRTH. Questo rilevatore tenta di identificare il contesto che indica che la data è correlata alla nascita di una persona.

Il rilevatore DATE tenta di trovare tutte le date indipendentemente dal contesto. Inoltre, contrassegna le date relative, come oggi o ieri. Allo stesso modo, TIME tenta di trovare tutti i timestamp.

Località

Se non devi eseguire la scansione di tutte le posizioni, valuta l'utilizzo di STREET_ADDRESS anziché del rilevatore LOCATION. Il rilevatore STREET_ADDRESS tenta di trovare indirizzi completi, che di solito sono più precisi delle posizioni generiche e possono essere considerati più sensibili.

Il rilevatore di infoType LOCATION tenta di trovare qualsiasi località indipendentemente dal contesto, ad esempio Parigi o Canada.

Rilevatori di infoType che richiedono il contesto

Molti rilevatori di infoType richiedono la presenza di indizi contestuali prima di identificare una corrispondenza. Se un rilevatore di infoType integrato non segnala gli elementi che ti aspetti vengano segnalati perché non sono presenti indizi contestuali in prossimità di questi elementi, valuta la possibilità di utilizzare GENERIC_ID o un rilevatore di infoType personalizzato.

Tipi di informazioni privi di una definizione comune del settore

Alcuni tipi di informazioni non hanno una definizione comune nel settore. Alcuni esempi sono numeri di cartelle cliniche, numeri di conto, PIN e codici di sicurezza. Per questi tipi, valuta la possibilità di utilizzare infoType come GENERIC_ID, FINANCIAL_ACCOUNT_NUMBER e MEDICAL_RECORD_NUMBER. Questi rilevatori utilizzano una combinazione di rilevamento di entità e contesto per trovare elementi potenzialmente sensibili.

Rilevatori di infoType a latenza più elevata

• Evita di attivare i rilevatori di infoType che non ti servono. Sebbene i seguenti siano utili in determinati scenari, questi infoType possono rallentare notevolmente l'esecuzione delle richieste rispetto a quelle che non li includono:

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

• Specifica sempre in modo esplicito i rilevatori di infoType. Non utilizzare un elenco infoTypes vuoto.

Come utilizzare gli infoType

La protezione dei dati sensibili utilizza i rilevatori di infoType nella configurazione delle scansioni per determinare cosa ispezionare e come trasformare i risultati. I nomi dei tipi di informazioni vengono utilizzati anche per visualizzare o segnalare i risultati della scansione.

Ad esempio, se vuoi cercare indirizzi email in un blocco di testo, devi specificare il rilevatore di infoType EMAIL_ADDRESS nella configurazione dell'ispezione. Se volessi oscurare gli indirizzi email dal blocco di testo, specificheresti EMAIL_ADDRESS sia nella configurazione dell'ispezione sia nella configurazione di deidentificazione per indicare come oscurare o trasformare quel tipo.

Inoltre, potresti utilizzare una combinazione di rilevatori di infoType integrati e personalizzati per escludere un sottoinsieme di indirizzi email dai risultati della scansione. Innanzitutto, crea un infoType personalizzato chiamato INTERNAL_EMAIL_ADDRESS e configuralo in modo da escludere gli indirizzi email di test interni. Puoi quindi configurare la scansione in modo da includere i risultati per EMAIL_ADDRESS, ma includere una regola di esclusione che escluda tutti i risultati che corrispondono a INTERNAL_EMAIL_ADDRESS. Per saperne di più sulle regole di esclusione e su altre funzionalità dei rilevatori di infoType personalizzati, vedi Creazione di rilevatori di infoType personalizzati.

Sensitive Data Protection fornisce un insieme di rilevatori di infoType integrati che specifichi per nome. Ognuno di questi è elencato in Riferimento al rilevatore di infoType. Questi rilevatori utilizzano una serie di tecniche per scoprire e classificare ogni tipo. Ad esempio, alcuni tipi richiedono una corrispondenza di pattern, altri possono avere checksum matematici, altri ancora hanno restrizioni speciali per le cifre e altri possono avere prefissi o contesti specifici intorno ai risultati.

Esempi

Quando configuri Sensitive Data Protection per eseguire la scansione dei tuoi contenuti, includi i rilevatori di infoType da utilizzare nella configurazione della scansione.

Ad esempio, i seguenti esempi di codice e JSON mostrano una semplice richiesta di scansione all'API DLP. Tieni presente che il rilevatore PHONE_NUMBER è specificato in inspectConfig, che indica a Sensitive Data Protection di scansionare la stringa specificata per un numero di telefono.

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;
    }
}

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 (123) 555-6789"

	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
}

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 gary@example.com";
    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());
      }
    }
  }
}

// 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 gary@example.com and my phone number is (223) 456-7890.';

// 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();

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 (415) 555-0890'
): 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()));
        }
    }
}

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.")

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

{
  "item":{
    "value":"My phone number is (415) 555-0890"
  },
  "inspectConfig":{
    "includeQuote":true,
    "minLikelihood":"POSSIBLE",
    "infoTypes":{
      "name":"PHONE_NUMBER"
    }
  }
}

{
  "result":{
    "findings":[
      {
        "quote":"(415) 555-0890",
        "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"
      }
    ]
  }
}

Devi specificare infoType particolari elencati nel riferimento nella configurazione dell'ispezione. Se non specifichi alcun infoType, Sensitive Data Protection utilizza un elenco di infoType predefinito destinato solo a scopi di test. L'elenco predefinito potrebbe non essere adatto ai tuoi casi d'uso.

Per saperne di più su come utilizzare i rilevatori di infoType per analizzare i tuoi contenuti, consulta uno degli argomenti su come fare relativi a ispezione, oscuramento o anonimizzazione.

Certezza e test

I risultati vengono segnalati con un punteggio di certezza chiamato probabilità. Il punteggio di probabilità indica la probabilità che un risultato corrisponda al tipo corrispondente. Ad esempio, un tipo può restituire una probabilità inferiore se corrisponde solo al pattern e una probabilità superiore se corrisponde al pattern e ha un contesto positivo. Per questo motivo, potresti notare che un singolo risultato potrebbe corrispondere a diversi tipi con una probabilità inferiore. Inoltre, un risultato potrebbe non essere visualizzato o avere una certezza inferiore se non corrisponde correttamente o se è associato a un contesto negativo. Ad esempio, un risultato potrebbe non essere segnalato se corrisponde alla struttura dell'infoType specificato, ma non supera il checksum dell'infoType. In alternativa, un risultato potrebbe corrispondere a più di un infoType, ma avere un contesto che ne mette in evidenza uno, pertanto viene segnalato solo per quel tipo.

Se stai testando vari rilevatori, potresti notare che i dati falsi o di esempio non vengono segnalati perché non superano un numero sufficiente di controlli per essere segnalati.

Tipi di rilevatori di infoType

Sensitive Data Protection include diversi tipi di rilevatori di infoType, tutti riassunti qui:

• I rilevatori di infoType integrati sono integrati in Sensitive Data Protection. Sono inclusi rilevatori per tipi di dati sensibili specifici per paese o regione, nonché tipi di dati applicabili a livello globale. Sono disponibili anche infoType generali per semplificare le configurazioni.
• I rivelatori di infoType personalizzati sono rilevatori che crei personalmente. Esistono tre tipi di rilevatori di infoType personalizzati:
  • I rilevatori di dizionari personalizzati piccoli sono semplici elenchi di parole che la protezione dei dati sensibili mette in corrispondenza. Utilizza rilevatori di dizionari personalizzati piccoli quando hai un elenco di parole o frasi fino a diverse decine di migliaia. I rilevatori di dizionari personalizzati piccoli sono preferibili se non prevedi che l'elenco di parole cambi in modo significativo.
  • I rilevatori di dizionari personalizzati di grandi dimensioni vengono generati da Sensitive Data Protection utilizzando grandi elenchi di parole o frasi archiviati in Cloud Storage o BigQuery. Utilizza i rilevatori di dizionari personalizzati di grandi dimensioni quando hai un elenco di parole o frasi di grandi dimensioni, fino a decine di milioni.
  • I rilevatori di espressioni regolari (regex) consentono a Sensitive Data Protection di rilevare le corrispondenze in base a un pattern di espressione regolare.

Inoltre, Sensitive Data Protection include il concetto di regole di ispezione, che ti consentono di perfezionare i risultati della scansione utilizzando quanto segue:

• Le regole di esclusione ti consentono di ridurre il numero di risultati restituiti aggiungendo regole a un rilevatore infoType integrato o personalizzato.
• Le regole per hotword ti consentono di aumentare la quantità o modificare il valore di probabilità dei risultati restituiti aggiungendo regole a un rilevatore infoType integrato o personalizzato.

Rilevatori di infoType integrati

I rilevatori di infoType integrati sono integrati in Sensitive Data Protection e includono rilevatori per tipi di dati sensibili specifici per paese o regione, come il Numéro d'Inscription au Répertoire (NIR) francese (FRANCE_NIR), il numero di patente di guida del Regno Unito (UK_DRIVERS_LICENSE_NUMBER) e il numero di previdenza sociale degli Stati Uniti (US_SOCIAL_SECURITY_NUMBER). Includono anche tipi di dati applicabili a livello globale, come il nome di una persona (PERSON_NAME), i numeri di telefono (PHONE_NUMBER), gli indirizzi email (EMAIL_ADDRESS) e i numeri di carte di credito (CREDIT_CARD_NUMBER). Per rilevare i contenuti che corrispondono agli infoType, Sensitive Data Protection utilizza varie tecniche, tra cui la corrispondenza dei pattern, i checksum, il machine learning, l'analisi del contesto e altre.

L'elenco dei rilevatori di infoType integrati viene aggiornato continuamente. Per un elenco completo dei rilevatori di infoType integrati attualmente supportati, consulta Guida di riferimento per i rilevatori di infoType.

Puoi anche visualizzare un elenco completo di tutti i rilevatori di infoType integrati chiamando il metodo infoTypes.list di Sensitive Data Protection.

Supporto dei linguaggi

I tipi di informazioni specifici per paese supportano la lingua inglese e le lingue del paese in questione. La maggior parte degli infoType globali funziona con più lingue. Testa Sensitive Data Protection con i tuoi dati per verificare che soddisfi i tuoi requisiti.

Rilevatori di infoType generali e specifici

Un rilevatore di infoType generico è un rilevatore definito in modo più ampio rispetto ai tipici rilevatori di infoType e può corrispondere a un'ampia gamma di tipi di informazioni potenzialmente sensibili. I rilevatori di infoType generici sono superset di rilevatori di infoType specifici che condividono un attributo o uno scopo comune. Ad esempio, il rilevatore di infoType DRIVERS_LICENSE_NUMBER può rilevare contenuti che corrispondono agli infoType GERMANY_DRIVERS_LICENSE_NUMBER e CANADA_DRIVERS_LICENSE_NUMBER.

In molti casi, i rilevatori di infoType generali possono trovare corrispondenze che i rilevatori di infoType specifici non riescono a trovare. Ad esempio, il rilevatore PASSPORT è più efficace nel trovare i numeri di passaporto rispetto ai rilevatori di passaporti specifici per paese, che a volte richiedono la presenza di indizi contestuali o contenuti con una formattazione specifica.

Nella configurazione dell'ispezione, puoi utilizzare un rilevatore di infoType generico al posto di un rilevatore di infoType specifico. Sensitive Data Protection presenta i risultati in base al rilevatore specificato nella richiesta. Ad esempio, se una stringa che esamini corrisponde al infoType GERMANY_DRIVERS_LICENSE_NUMBER e hai eseguito la scansione sia di DRIVERS_LICENSE_NUMBER sia di GERMANY_DRIVERS_LICENSE_NUMBER nella richiesta, otterrai due risultati per la stessa stringa: uno per DRIVERS_LICENSE_NUMBER e uno per GERMANY_DRIVERS_LICENSE_NUMBER. Tuttavia, se nella richiesta hai eseguito la scansione solo per DRIVERS_LICENSE_NUMBER, il risultato dell'ispezione mostra solo il problema relativo a DRIVERS_LICENSE_NUMBER.

L'utilizzo di un rilevatore di infoType generico presenta i seguenti vantaggi:

• In molti casi, i rilevatori di infoType generici hanno un tasso di richiamo superiore rispetto a quelli specifici. Il richiamo è il numero di istanze di veri positivi rispetto al numero totale di istanze pertinenti.

• Puoi semplificare le richieste di Protezione dei dati sensibili perché non devi specificare ogni tipo di infoType specifico da cercare. Ad esempio, il solo rilevatore di infoType GOVERNMENT_ID include più di 100 rilevatori di infoType diversi.

• È meno probabile che tu raggiunga il limite di 150 rilevatori di infoType per richiesta.

• Se Sensitive Data Protection rilascia un nuovo infoType e lo aggiunge a un infoType generale già specificato nelle configurazioni esistenti, Sensitive Data Protection include automaticamente il nuovo infoType nelle scansioni. Non devi aggiungere manualmente i tipi di informazioni appena rilasciati alle configurazioni esistenti.

Gli infoType generali e specifici hanno una relazione many-to-many. ovvero un infoType generico può includere molti infoType specifici e un infoType specifico può appartenere a molti infoType generici. Per un elenco completo degli infoType generici e degli infoType specifici che includono, vedi infoType generici.

Rilevatori di infoType personalizzati

Esistono tre tipi di rilevatori di infoType personalizzati:

• Rilevatori di dizionari personalizzati piccoli
• Rilevatori di dizionari personalizzati di grandi dimensioni
• Espressioni regolari (regex)

Inoltre, Sensitive Data Protection include regole di ispezione che ti consentono di perfezionare i risultati della scansione aggiungendo quanto segue ai rilevatori esistenti:

• Regole di esclusione
• Regole hotword

Rilevatori di dizionari personalizzati piccoli

Utilizza i rilevatori di dizionari personalizzati piccoli (chiamati anche "rilevatori di dizionari personalizzati regolari") per trovare corrispondenze con un elenco breve (fino a diverse decine di migliaia) di parole o frasi. Un piccolo dizionario personalizzato può fungere da rilevatore univoco.

I rilevatori di dizionari personalizzati sono utili quando vuoi eseguire la scansione di un elenco di parole o frasi che non corrispondono facilmente a un'espressione regolare o a un rilevatore integrato. Ad esempio, supponiamo che tu voglia cercare sale conferenze che vengono comunemente chiamate con i nomi assegnati anziché con i numeri, come nomi di stati o regioni, punti di riferimento, personaggi di fantasia e così via. Puoi creare un piccolo rilevatore di dizionari personalizzato che contenga un elenco di questi nomi di stanze. Sensitive Data Protection può eseguire la scansione dei tuoi contenuti per ogni nome della stanza e restituire una corrispondenza quando ne rileva uno nel contesto. Scopri di più su come Sensitive Data Protection abbina parole e frasi del dizionario nella sezione "Specifiche della corrispondenza del dizionario" di Creazione di un rilevatore di dizionario personalizzato regolare.

Per maggiori dettagli sul funzionamento dei rilevatori di infoType personalizzati con dizionario di piccole dimensioni, nonché esempi pratici, vedi Creazione di un rilevatore di dizionari personalizzato normale.

Rilevatori di dizionari personalizzati di grandi dimensioni

Utilizza rilevatori di dizionari personalizzati di grandi dimensioni (chiamati anche "rilevatori di dizionari personalizzati archiviati") quando hai più di poche parole o frasi da scansionare o se il tuo elenco di parole o frasi cambia spesso. I rilevatori di dizionari personalizzati di grandi dimensioni possono trovare corrispondenze con decine di milioni di parole o frasi.

I rilevatori di dizionari personalizzati grandi vengono creati in modo diverso rispetto ai rilevatori personalizzati di espressioni regolari e ai rilevatori di dizionari personalizzati piccoli. Ogni dizionario personalizzato di grandi dimensioni ha due componenti:

• Un elenco di frasi che crei e definisci. L'elenco viene archiviato come file di testo in Cloud Storage o come colonna in una tabella BigQuery.
• I file dizionario generati, creati da Sensitive Data Protection in base all'elenco di frasi. I file del dizionario sono archiviati in Cloud Storage e sono costituiti da una copia dei dati delle frasi di origine più filtri Bloom, che aiutano nella ricerca e nella corrispondenza. Non puoi modificare direttamente questi file.

Dopo aver creato un elenco di parole e utilizzato Sensitive Data Protection per generare un dizionario personalizzato, avvii o pianifichi una scansione utilizzando un rilevatore di dizionari personalizzati di grandi dimensioni in modo simile ad altri rilevatori di infoType.

Per maggiori dettagli su come funzionano i rilevatori di dizionari personalizzati di grandi dimensioni, nonché esempi pratici, vedi Creazione di un rilevatore di dizionari personalizzato archiviato.

Espressioni regolari

Un rilevatore di infoType personalizzato con espressioni regolari (regex) ti consente di creare i tuoi rilevatori di infoType che consentono a Sensitive Data Protection di rilevare corrispondenze in base a un pattern regex. Ad esempio, supponiamo che tu abbia numeri di cartelle cliniche nel formato ###-#-#####. Puoi definire un pattern regex come il seguente:

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

Sensitive Data Protection troverebbe corrispondenze con elementi come questo:

123-4-56789

Puoi anche specificare una probabilità da assegnare a ogni corrispondenza di infoType personalizzato. ovvero, quando Sensitive Data Protection trova corrispondenza con la sequenza che specifichi, assegnerà la probabilità che hai indicato. Ciò è utile perché se la tua espressione regolare personalizzata definisce una sequenza abbastanza comune, potrebbe corrispondere facilmente a un'altra sequenza casuale. In questo caso, non vorresti che Sensitive Data Protection etichetti ogni corrispondenza come VERY_LIKELY. In questo modo si minerebbe la fiducia nei risultati della scansione e si potrebbe causare la corrispondenza o la deidentificazione di informazioni errate.

Per saperne di più sui rilevatori di infoType personalizzati con espressioni regolari e per vederli in azione, consulta Creazione di un rilevatore di espressioni regolari personalizzato.

Regole di ispezioni

Utilizzi le regole di ispezione per perfezionare i risultati restituiti dai rilevatori di infoType esistenti, integrati o personalizzati. Le regole di ispezione possono essere utili quando i risultati restituiti dalla protezione dei dati sensibili devono essere integrati in qualche modo, aggiungendo ed escludendo dal rilevatore di infoType esistente.

I due tipi di regole di ispezione sono:

• Regole di esclusione
• Regole hotword

Per saperne di più sulle regole di ispezione, vedi Modifica dei rilevatori infoType per perfezionare i risultati della scansione.

Regole di esclusione

Le regole di esclusione ti consentono di diminuire la quantità o la precisione dei risultati restituiti aggiungendo regole a un rilevatore infoType integrato o personalizzato. Le regole di esclusione possono aiutarti a ridurre il rumore o altri risultati indesiderati restituiti da un rilevatore infoType.

Ad esempio, se esegui la scansione di un database alla ricerca di indirizzi email, puoi aggiungere una regola di esclusione sotto forma di espressione regolare personalizzata che indica a Sensitive Data Protection di escludere tutti i risultati che terminano con "@example.com".

Le regole di esclusione non possono essere applicate agli infoType oggetto.

Per ulteriori informazioni sulle regole di esclusione, vedi Modifica dei rilevatori infoType per perfezionare i risultati della scansione.

Regole hotword

Le regole per hotword ti consentono di aumentare la quantità o l'accuratezza dei risultati restituiti aggiungendo regole a un rilevatore infoType integrato o personalizzato. Le regole per le hotword possono aiutarti a rendere meno rigide le regole di un rilevatore infoType esistente.

Ad esempio, supponiamo che tu voglia scansionare un database medico alla ricerca dei nomi dei pazienti. Puoi utilizzare il rilevatore di infoType PERSON_NAME integrato di Sensitive Data Protection, ma in questo modo Sensitive Data Protection troverà corrispondenze per tutti i nomi di persone, non solo per i nomi dei pazienti. Per risolvere il problema, puoi includere una regola hotwordd sotto forma di infoType personalizzato regex che cerca la parola "paziente" entro una certa prossimità di caratteri dal primo carattere delle potenziali corrispondenze. Puoi quindi assegnare ai risultati che corrispondono a questo pattern una probabilità "molto probabile", poiché corrispondono ai tuoi criteri speciali.

Per ulteriori informazioni sulle regole per le hotword, vedi Modifica dei rilevatori infoType per perfezionare i risultati della scansione.

Esempi

Per farti un'idea migliore di come corrispondono gli infoType nei risultati, esamina i seguenti esempi di corrispondenza di una serie di cifre per determinare se costituiscono un numero di previdenza sociale statunitense o un numero di identificazione fiscale individuale statunitense. Tieni presente che questi esempi si riferiscono ai rilevatori di infoType integrati. Quando crei un rilevatore di infoType personalizzato, specifichi i criteri che determinano la probabilità di una corrispondenza della scansione.

Esempio 1

"SSN 222-22-2222"

Riporta un punteggio di probabilità elevata di VERY_LIKELY per un US_SOCIAL_SECURITY_NUMBER perché:

• È nel formato standard del codice fiscale, il che aumenta la certezza.
• Ha un contesto nelle vicinanze ("Codice fiscale") che aumenta la probabilità di US_SOCIAL_SECURITY_NUMBER.

Esempio 2

"999-99-9999"

Segnala un punteggio di probabilità basso pari a VERY_UNLIKELY per un US_SOCIAL_SECURITY_NUMBER perché:

• È nel formato standard, il che aumenta la certezza.
• Inizia con un 9, che non è consentito nei codici fiscali, quindi riduce la certezza.
• Manca il contesto, il che riduce la certezza.

Esempio 3

"999-98-9999"

Riporta un punteggio di probabilità di POSSIBLE per un US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER e VERY_UNLIKELY per US_SOCIAL_SECURITY_NUMBER perché:

• Ha il formato standard sia per US_SOCIAL_SECURITY_NUMBER sia per US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Inizia con un 9 e ha un altro controllo delle cifre, il che aumenta la certezza per US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Manca qualsiasi contesto, il che riduce la certezza per entrambi.

Passaggi successivi

Il team di Sensitive Data Protection rilascia periodicamente nuovi rilevatori e gruppi di infoType. Per scoprire come ottenere l'elenco più recente degli infoType integrati, consulta Elenco dei rilevatori di infoType integrati.