InfoType e rilevatori di infoType

Sensitive Data Protection utilizza tipi di informazioni, o infoType, per definire l'analisi. Un infoType è un tipo di dati sensibili, come un nome, un indirizzo email, un numero di telefono, un numero di identificazione, un 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.

Nota: se cerchi un elenco aggiornato di tutti i rilevatori infoType integrati, consulta la documentazione di riferimento per i rilevatori infoType.

Come utilizzare gli infoType

Sensitive Data Protection utilizza rilevatori di infoType nella configurazione per le proprie scansioni al fine di determinare cosa ispezionare e come trasformare i risultati. I nomi dei tipi di infoType vengono utilizzati anche quando vengono visualizzati o segnalati i risultati della scansione.

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

Inoltre, puoi utilizzare una combinazione di rilevatori infoType integrati e personalizzati per escludere un sottoinsieme di indirizzi email dai risultati dell'analisi. Innanzitutto, crea un infoType personalizzato denominato INTERNAL_EMAIL_ADDRESS e configuralo in modo da escludere gli indirizzi email di test interni. Dopodiché puoi configurare l'analisi in modo da includere i risultati relativi a EMAIL_ADDRESS, ma includere una regola di esclusione che escluda tutti i risultati che corrispondono a INTERNAL_EMAIL_ADDRESS. Per ulteriori informazioni sulle regole di esclusione e su altre funzionalità dei rilevatori infoType personalizzati, consulta Creazione di rilevatori infoType personalizzati.

Sensitive Data Protection fornisce un insieme di rilevatori infoType integrati che specifichi per nome, ciascuno dei quali è elencato nel riferimento per i rilevatori di InfoType. Questi rilevatori utilizzano varie tecniche per scoprire e classificare ogni tipo. Ad esempio, alcuni tipi richiedono una corrispondenza di schema, alcuni possono avere checksum matematici, alcuni hanno limitazioni speciali per le cifre e altri possono avere prefissi o contesto specifici per i risultati.

Esempi

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

Ad esempio, i seguenti esempi di codice 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 scansionare la stringa specificata per trovare un numero di telefono.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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

Input 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 invii la richiesta precedente all'endpoint specificato, Sensitive Data Protection restituisce quanto segue:

Output 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"
      }
    ]
  }
}

Se hai bisogno di un controllo preciso e di una prevedibilità in merito ai rilevatori da eseguire, devi specificare infoType specifici nel riferimento. In caso contrario, Sensitive Data Protection utilizza un elenco predefinito, che potrebbe cambiare nel tempo. A seconda della quantità di contenuti da scansionare, l'analisi degli infoType predefiniti può richiedere molto tempo o denaro in modo proibitivo.

Per ulteriori informazioni su come utilizzare i rilevatori infoType per analizzare i contenuti, consulta uno degli argomenti didattici su 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à più bassa se corrisponde solo al pattern e restituire una probabilità più alta se corrisponde al pattern e ha un contesto positivo. Per questo motivo, potresti notare che un singolo risultato può corrispondere a più tipi con una probabilità inferiore. Inoltre, un risultato potrebbe non essere visualizzato o avere una certezza minore 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. Oppure un risultato potrebbe corrispondere a più di un infoType, ma avere un contesto che ne migliora uno e quindi viene segnalato solo per quel tipo.

Nota: per contesto positivo si intende quando l'inclusione di determinati caratteri, parole o frasi in prossimità di un pattern potenzialmente corrispondente indica a Sensitive Data Protection che una corrispondenza con il pattern è più probabile. Analogamente, per contesto negativo si intende quando l'inclusione di determinati caratteri, parole o frasi in prossimità di un pattern indica che una corrispondenza è meno probabile.

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

Tipi di rilevatori infoType

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

• I rilevatori di infoType integrati sono integrati in Sensitive Data Protection. Includono rilevatori di tipi di dati sensibili specifici per paese o regione, nonché tipi di dati applicabili a livello globale.
• I rilevatori di infoType personalizzati sono rilevatori creati da te. Esistono tre tipi di rilevatori infoType personalizzati:
  • Piccoli rilevatori di dizionari personalizzati sono semplici elenchi di parole in cui vengono trovate corrispondenze con la protezione dei dati sensibili. Utilizza piccoli rilevatori di dizionari personalizzati quando hai un elenco di diverse decine di migliaia di parole o frasi. Sono preferibili rilevatori di dizionari personalizzati 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 archiviate in Cloud Storage o BigQuery. Usa rilevatori di dizionari personalizzati di grandi dimensioni quando hai un lungo elenco di parole o frasi, 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, Sensitive Data Protection include il concetto di regole di ispezione, che consentono di ottimizzare i risultati dell'analisi utilizzando quanto segue:

• Le regole di esclusione 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 infoType integrati

I rilevatori di infoType integrati sono integrati in Sensitive Data Protection e includono rilevatori di tipi di dati sensibili specifici per paese o regione, come il Numéro d'Inscription au Répertoire (NIR) (FRANCE_NIR), il numero di patente di guida del Regno Unito (UK_DRIVERS_LICENSE_NUMBER) e i tipi di previdenza sociale degli Stati Uniti (US_SOCIAL_SECURITY_NUMBER). Includono anche tipi di dati applicabili a livello globale (ad esempio, numeri di numeri di carte di credito e di riconoscimento),PERSON_NAMEPHONE_NUMBEREMAIL_ADDRESSCREDIT_CARD_NUMBER

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

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

I rilevatori infoType integrati non rappresentano un metodo di rilevamento preciso al 100%. Ad esempio, non possono garantire la conformità ai requisiti normativi. Devi decidere quali sono i dati sensibili e come proteggerli al meglio. Google consiglia di testare le impostazioni per assicurarti che la configurazione soddisfi i requisiti.

Supporto dei linguaggi

Gli infoType specifici per paese supportano la lingua inglese e la lingua del rispettivo paese. La maggior parte degli infoType globali funziona con più lingue. Testa la protezione dei dati sensibili con i tuoi dati per verificare che soddisfino i tuoi requisiti.

Rilevatori infoType personalizzati

Esistono tre tipi di rilevatori infoType personalizzati:

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

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

• Regole di esclusione
• Regole hotword

Piccoli rilevatori di dizionari personalizzati

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

I rilevatori di dizionari personalizzati sono utili quando vuoi cercare un elenco di parole o frasi che non sono facilmente individuabili da un'espressione regolare o da un rilevatore integrato. Ad esempio, supponi di voler cercare sale conferenze a cui si fa riferimento con i nomi delle sale a cui sono state assegnate, anziché con i numeri delle sale, come nomi di stati o regioni, punti di riferimento, personaggi fittizi e così via. Puoi creare un piccolo rilevatore di dizionari personalizzato che contenga un elenco di nomi di stanze. Sensitive Data Protection può analizzare i tuoi contenuti per ciascun nome di stanza e restituire una corrispondenza quando ne rileva uno nel contesto. Scopri di più su come Sensitive Data Protection associa le parole e le frasi del dizionario nella sezione "Specifiche corrispondenti del dizionario" in Creazione di un normale rilevatore di dizionari personalizzato.

Per ulteriori dettagli sul funzionamento dei rilevatori infoType personalizzati di piccole dimensioni e per visualizzare esempi pratici, consulta la sezione Creazione di un rilevatore di dizionari personalizzato normale.

Rilevatori di dizionari personalizzati di grandi dimensioni

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

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

• Un elenco di frasi create e definite da te. L'elenco viene archiviato come file di testo all'interno di Cloud Storage o come colonna in una tabella BigQuery.
• I file di dizionario generati, creati da Sensitive Data Protection in base all'elenco di frasi. I file di dizionario sono archiviati in Cloud Storage e sono costituiti da una copia dei dati della frase 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 aver utilizzato Sensitive Data Protection per generare un dizionario personalizzato, puoi avviare o pianificare una scansione utilizzando un rilevatore di dizionari personalizzato di grandi dimensioni, in modo simile agli altri rilevatori infoType.

Per ulteriori dettagli sul funzionamento dei rilevatori di dizionari personalizzati di grandi dimensioni, e per visualizzare esempi pratici, consulta Creazione di un rilevatore di dizionari personalizzato archiviato.

Espressioni regolari

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

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

La protezione dei dati sensibili corrisponderà quindi a elementi come i seguenti:

123-4-56789

Puoi anche specificare una probabilità da assegnare a ogni corrispondenza infoType personalizzata. In altre parole, quando Sensitive Data Protection corrisponde alla sequenza specificata, assegnerà la probabilità che hai indicato. Questo è utile perché se la tua regex personalizzata definisce una sequenza sufficientemente comune che potrebbe facilmente corrispondere ad altre sequenze casuali, non vuoi che Sensitive Data Protection etichetti ogni corrispondenza come VERY_LIKELY. Così facendo, si corrode l'affidabilità dei risultati dell'analisi e si potrebbe far sì che le informazioni errate vengano abbinate o anonimizzate.

Per ulteriori informazioni sui rilevatori infoType personalizzati di espressioni regolari e per vederli in azione, consulta Creazione di un rilevatore di espressioni regolari personalizzate.

Regole di ispezioni

Puoi utilizzare le regole di ispezione per perfezionare i risultati restituiti dai rilevatori infoType esistenti, integrati o personalizzati. Le regole di ispezione possono essere utili nei momenti in cui i risultati restituiti da Sensitive Data Protection devono essere in qualche modo aumentati, aggiungendo ed escludendo dal rilevatore di infoType esistente.

I due tipi di regole di ispezione sono:

• Regole di esclusione
• Regole hotword

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

Regole di esclusione

Le regole di esclusione consentono di ridurre 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 scansioni un database alla ricerca di indirizzi email, puoi aggiungere una regola di esclusione sotto forma di regex personalizzata che indica alla protezione dei dati sensibili di escludere eventuali 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 consentono di aumentare la quantità o l'accuratezza dei risultati restituiti aggiungendo regole a un rilevatore infoType integrato o personalizzato. Le regole hotword possono aiutarti in modo efficace ad allentare le regole di un rilevatore infoType esistente.

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

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

Esempi

Per avere un'idea migliore di come gli infoType corrispondono ai risultati, guarda i seguenti esempi di corrispondenza su una serie di cifre per determinare se costituiscono un numero di previdenza sociale degli Stati Uniti o un numero di identificazione del contribuente individuale statunitense. Tieni presente che questi esempi riguardano i rilevatori infoType integrati. Quando crei un rilevatore infoType personalizzato, devi specificare i criteri che determinano la probabilità di una corrispondenza di scansione.

Esempio 1

"SSN 222-22-2222"

Segnala un punteggio di probabilità elevato di VERY_LIKELY per una US_SOCIAL_SECURITY_NUMBER perché:

• Si tratta del formato standard del numero di previdenza sociale, il che aumenta la certezza.
• Include un contesto nelle vicinanze ("SSN") che fa aumentare verso US_SOCIAL_SECURITY_NUMBER.

Esempio 2

"999-99-9999"

Segnala un punteggio di probabilità basso di VERY_UNLIKELY per una 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 abbassa la certezza.

Esempio 3

"999-98-9999"

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

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

Passaggi successivi

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

Importante: i rilevatori infoType integrati non rappresentano un metodo di rilevamento preciso al 100%. Ad esempio, non possono garantire la conformità ai requisiti normativi. Devi decidere quali sono i dati sensibili e come proteggerli al meglio. Google consiglia di verificare le impostazioni per assicurarti che la configurazione soddisfi i requisiti.