InfoType e rilevatori di infoType

Sensitive Data Protection utilizza i tipi di informazioni, o infoType, per definire gli elementi da cercare. 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 passaggi fondamentali per proteggerli. Come best practice, devi raccogliere, archiviare ed elaborare solo le informazioni di cui hai bisogno per la tua attività. Identificando i dati che gestisci, puoi prendere decisioni consapevoli per la tua attività, gli utenti, la sicurezza dei dati e la tua posizione in materia di privacy.

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

Linee guida generali

Tieni in considerazione le seguenti linee guida generali quando selezioni gli infoType.

Informazioni sensibili che non devi raccogliere

Ogni servizio della tua attività deve raccogliere solo i dati di cui necessita. Ad esempio, alcuni servizi della tua attività non devono raccogliere informazioni finanziarie. Per questi servizi, ti consigliamo 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 con il tuo team

Potrebbero esserci casi d'uso validi per la raccolta di informazioni personali, ma non dovresti condividerle con il tuo team. Ad esempio, un cliente che invia un ticket di assistenza 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 soggetti a normative di settore, sulla privacy dei dati o giurisdizionali

Alcuni tipi di informazioni sono considerati sensibili a causa del modo in cui vengono emesse o per le finalità per cui possono essere utilizzate. In altri casi, le informazioni contestuali e demografiche sono considerate una categoria protetta. Per questi tipi di informazioni potrebbero essere previste limitazioni aggiuntive relative alla 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

Tieni presente quanto segue quando scegli tra rilevatori di infoType simili.

Passaporti

Se non devi cercare gli identificatori dei passaporti di un paese specifico, scegli il rilevatore generalizzato: PASSPORT.

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

Nomi di persona

Quando esegui la ricerca dei nomi delle persone, utilizza PERSON_NAME per la maggior parte degli scenari di utilizzo anziché FIRST_NAME o LAST_NAME.

PERSON_NAME è un rilevatore per i nomi delle persone. Sono inclusi 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, inclusa la comprensione del linguaggio naturale. FIRST_NAME e LAST_NAME sono sottoinsiemi di questo rilevatore che tentano di identificare parti di un nome. I risultati di questi rilevatori sono sempre sottoinsiemi dei risultati di PERSON_NAME.

Date e ore

Se non devi cercare tutte le date, ti consigliamo di utilizzare un rilevatore di date mirate come DATE_OF_BIRTH. Questo rilevatore tenta di identificare il contesto che indica che la data è correlata alla data di nascita di una persona.

Il rilevatore DATE tenta di trovare tutte le date indipendentemente dal contesto. Inoltre, segnala le date relative, ad esempio oggi o ieri. Analogamente, TIME tenta di trovare tutti i timestamp.

Località

Se non devi eseguire la ricerca in tutte le località, valuta la possibilità di utilizzare STREET_ADDRESS invece del rilevatore LOCATION. Il rilevatore STREET_ADDRESS tenta di trovare indirizzi completamente qualificati, che in genere sono più precisi delle località 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 di segnalare, perché non si verificano indizi contestuali nelle immediate vicinanze di questi elementi, ti consigliamo di utilizzare GENERIC_ID o un rilevatore di infoType personalizzato.

Tipi di informazioni privi di una definizione comune del settore

Per alcuni tipi di informazioni non esiste una definizione comune del settore. Alcuni esempi sono numeri di documenti medici, 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 delle entità e contesto per trovare elementi potenzialmente sensibili.

Rilevatori di infoType con latenza più elevata

• Evita di attivare i rilevatori di infoType che non ti servono. Sebbene i seguenti siano utili in determinati scenari, questi tipi di informazioni possono far eseguire le richieste molto più lentamente 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 i rilevatori di infoType in modo esplicito. Non utilizzare un elenco infoTypes vuoto.

Come utilizzare gli infoType

Sensitive Data Protection utilizza i rilevatori di infoType nella configurazione delle sue scansioni per determinare cosa cercare e come trasformare i risultati. I nomi di InfoType vengono utilizzati anche per visualizzare o generare report sui risultati della scansione.

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

Inoltre, puoi 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 denominato INTERNAL_EMAIL_ADDRESS e configuralo in modo da escludere gli indirizzi email di test interni. Poi, puoi configurare la scansione in modo da includere i risultati relativi a EMAIL_ADDRESS, ma includere una regola di esclusione che escluda tutti i risultati corrispondenti a EMAIL_ADDRESS.INTERNAL_EMAIL_ADDRESS Per ulteriori informazioni sulle regole di esclusione e su altre funzionalità dei rilevatori di infoType personalizzati, vedi Creare rilevatori di infoType personalizzati.

Sensitive Data Protection fornisce un insieme di rilevatori di infoType integrati che puoi specificare per nome, ognuno dei quali è elencato nella documentazione di riferimento dei rilevatori di infoType. Questi rilevatori utilizzano una serie di tecniche per rilevare e classificare ogni tipo. Ad esempio, alcuni tipi richiedono una corrispondenza con un pattern, altri potrebbero avere checksum matematici, altri ancora hanno limitazioni speciali per le cifre e altri ancora potrebbero avere prefissi o contesti specifici per i risultati.

Esempi

Quando configuri la Protezione dei dati sensibili per eseguire la scansione dei contenuti, includi i rilevatori di infoType da utilizzare nella configurazione della scansione.

Ad esempio, i seguenti esempi di JSON e codice 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 cercare un numero di telefono nella stringa specificata.

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 determinati infoType elencati nella documentazione di riferimento nella configurazione dell'ispezione. Se non specifichi alcun infoType, Sensitive Data Protection utilizza un elenco di infoType predefiniti destinato esclusivamente ai 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 eseguire la scansione dei contenuti, consulta uno degli argomenti di istruzioni sull'ispezione, l'oscuramento o la rimozione dell'identità.

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 intorno. Per questo motivo, potresti notare che un singolo risultato potrebbe corrispondere a più tipi con una probabilità inferiore. Inoltre, un risultato potrebbe non essere visualizzato o avere una certezza inferiore se non corrisponde correttamente o se il contesto circostante è negativo. Ad esempio, un risultato potrebbe non essere segnalato se corrisponde alla struttura dell'infoType specificato, ma non supera il controllo di checksum dell'infoType. In alternativa, un risultato potrebbe corrispondere a più di un infoType, ma avere un contesto che ne favorisce uno e, di conseguenza, essere segnalato solo per quel tipo.

Se stai testando vari rilevatori, potresti notare che i dati falsi o di esempio non vengono registrati perché non superano i controlli necessari per la registrazione.

Tipi di rilevatori di infoType

Sensitive Data Protection include diversi tipi di rilevatori di infoType, tutti brevemente descritti di seguito:

• I rivelatori 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.
• I rivelatori di infoType personalizzati sono quelli che crei personalmente. Esistono tre tipi di rilevatori di infoType personalizzati:
  • I piccoli rilevatori di dizionari personalizzati sono semplici elenchi di parole su cui si basano le corrispondenze della funzionalità Protezione dei dati sensibili. Utilizza piccoli rilevatori di dizionario personalizzato quando hai un elenco di massimo diverse decine di migliaia di parole o frasi. I piccoli rilevatori di dizionari personalizzati sono preferibili se non prevedi che l'elenco di parole cambierà in modo significativo.
  • I rivelatori di grandi dizionari personalizzati vengono generati da Sensitive Data Protection utilizzando grandi elenchi di parole o frasi archiviati in Cloud Storage o BigQuery. Utilizza i rilevatori di dizionario personalizzato grande 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 espressioni regolari.

Inoltre, la funzionalità Protezione dei dati sensibili include il concetto di regole di ispezione, che ti consente 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 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 Protezione dei dati sensibili 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 statunitense (US_SOCIAL_SECURITY_NUMBER). Sono inclusi 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 corrispondenti agli infoType, Protezione dei dati sensibili sfrutta varie tecniche, tra cui la corrispondenza di pattern, i checksum, l'apprendimento automatico, 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 la 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

Gli infoType specifici per paese supportano la lingua inglese e le lingue del rispettivo paese. 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 personalizzati

Esistono tre tipi di rilevatori di infoType personalizzati:

• Rilevatori di piccoli dizionari personalizzati
• 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

Piccoli rilevatori di dizionari personalizzati

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

I rilevatori di dizionario personalizzati sono utili quando vuoi eseguire la ricerca 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 a cui si fa comunemente riferimento con i nomi assegnati anziché con i relativi numeri, come nomi di stati o regioni, punti di riferimento, personaggi di fantasia e così via. Puoi creare un piccolo rilevatore di dizionari personalizzati contenente un elenco di questi nomi di camere. La funzionalità Sensitive Data Protection può analizzare i tuoi contenuti per individuare ciascuno dei nomi delle stanze e restituire una corrispondenza quando ne trova uno nel contesto. Scopri di più su come Sensitive Data Protection associa le parole e le frasi del dizionario nella sezione "Specifiche della corrispondenza del dizionario" di Creare un rilevatore di dizionario personalizzato normale.

Per ulteriori dettagli sul funzionamento dei rilevatori di infoType personalizzati di piccoli dizionari, nonché esempi in azione, consulta Creare un rilevatore di dizionari personalizzato normale.

Rilevatori di dizionari personalizzati di grandi dimensioni

Utilizza i rivelatori di dizionari personalizzati di grandi dimensioni (chiamati anche "rivelatori di dizionari personalizzati archiviati") quando hai più di alcune parole o frasi da cercare o se l'elenco di parole o frasi varia di frequente. I rilevatori di grandi dizionari personalizzati possono trovare corrispondenze fino a decine di milioni di parole o frasi.

I rilevatori di dizionari personalizzati di grandi dimensioni vengono creati in modo diverso rispetto ai rilevatori di espressioni regolari personalizzate e ai rilevatori di dizionari personalizzati di piccole dimensioni. 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 del dizionario generati, creati da Sensitive Data Protection based on your phrase list. I file del dizionario sono archiviati in Cloud Storage e sono costituiti da una copia dei dati delle frasi di origine più i filtri Bloom, che aiutano nella ricerca e nella corrispondenza. Non puoi modificare direttamente questi file.

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

Per ulteriori dettagli sul funzionamento dei rilevatori di dizionari personalizzati di grandi dimensioni, nonché su esempi pratici, consulta Creare un rilevatore di dizionari personalizzati 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 le corrispondenze in base a un pattern regex. Ad esempio, supponiamo che tu abbia i numeri delle cartelle cliniche nel formato ###-#-#####. Puoi definire un pattern regex come il seguente:

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

Sensitive Data Protection assocerebbe quindi elementi come:

123-4-56789

Puoi anche specificare una probabilità da assegnare a ogni corrispondenza di infoType personalizzato. In altre parole, quando Sensitive Data Protection trova una corrispondenza con la sequenza specificata, assegna la probabilità che hai indicato. Questo è utile perché se la tua regex personalizzata definisce una sequenza abbastanza comune che potrebbe facilmente corrispondere a un'altra sequenza casuale, non vorrai che la Protezione dei dati sensibili etichetti ogni corrispondenza come VERY_LIKELY. In questo modo, la fiducia nei risultati della scansione verrebbe minata e le informazioni sbagliate potrebbero essere associate o anonimizzate.

Per ulteriori informazioni sui rilevatori di infoType personalizzati con espressioni regolari e per visualizzarli in azione, consulta Creare un rilevatore personalizzato con espressioni regolari.

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 aumentati in qualche modo, aggiungendo elementi al rilevatore infoType esistente ed escludendoli.

I due tipi di regole di ispezione sono:

• Regole di esclusione
• Regole hotword

Per ulteriori informazioni sulle regole di ispezione, vedi Modificare i rilevatori infoType per perfezionare i risultati della scansione.

Regole di esclusione

Le regole di esclusione ti consentono di ridurre la quantità o la precisione dei risultati ritornati 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 di infoType.

Ad esempio, se esegui la scansione di un database per trovare indirizzi email, puoi aggiungere una regola di esclusione sotto forma di regex personalizzata che indichi a Protezione dei dati sensibili di escludere tutti i risultati che terminano con "@example.com".

Per ulteriori informazioni sulle regole di esclusione, consulta Modificare i rilevatori infoType per perfezionare i risultati della scansione.

Regole hotword

Le regole hotword ti consentono di aumentare la quantità o l'accuratezza dei risultati riportati aggiungendo regole a un rilevatore infoType integrato o personalizzato. Le regole per le hotword possono aiutarti a allentare in modo efficace le regole di un rilevatore infoType esistente.

Ad esempio, supponiamo che tu voglia cercare i nomi dei pazienti in un database medico. Puoi utilizzare il rilevatore PERSON_NAME infoType incorporato in Protezione dei dati sensibili, ma questo causerà una corrispondenza su tutti i nomi delle persone, non solo sui nomi dei pazienti. Per risolvere il problema, puoi includere una regola hotword sotto forma di infoType personalizzato regex che cerca la parola "paziente" entro una certa distanza dal primo carattere delle potenziali corrispondenze. Puoi quindi assegnare ai risultati corrispondenti a questo pattern una probabilità di "molto probabile", poiché corrispondono ai tuoi criteri speciali.

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

Esempi

Per avere un'idea migliore di come gli infoType corrispondono ai risultati, esamina i seguenti esempi di corrispondenza su una serie di cifre per determinare se costituiscono un numero di previdenza sociale statunitense o un numero di identificazione fiscale personale statunitense. Tieni presente che questi esempi sono per i 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"

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

• È nel formato standard del numero di previdenza sociale, il che aumenta la sicurezza.
• Il contesto nelle vicinanze ("SSN") favorisce il ranking per US_SOCIAL_SECURITY_NUMBER.

Esempio 2

"999-99-9999"

Registra 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, pertanto la certezza è inferiore.
• Manca il contesto, il che riduce la certezza.

Esempio 3

"999-98-9999"

Registra 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 prevede un altro controllo di cifre, 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 gruppi e rilevatori di infoType. Per scoprire come ottenere l'elenco più recente degli infoType integrati, consulta Elenco dei rilevatori di infoType integrati.