InfoType dan pendeteksi infoType

Sensitive Data Protection menggunakan jenis informasi—atau infoType—untuk menentukan apa yang dipindai. InfoType adalah jenis data sensitif, seperti nama, alamat email, nomor telepon, nomor identifikasi, nomor kartu kredit, dan sebagainya. Pendeteksi infoType adalah mekanisme deteksi yang sesuai dan cocok dengan kriteria pencocokan infoType.

Praktik terbaik untuk memilih infoType

Memahami data Anda adalah salah satu langkah penting pertama dalam melindunginya. Sebagai praktik terbaik, Anda hanya boleh mengumpulkan, menyimpan, dan memproses informasi yang Anda perlukan untuk bisnis. Dengan mengidentifikasi data yang Anda tangani, Anda dapat membuat keputusan yang tepat untuk bisnis, pengguna, serta postur keamanan dan privasi data Anda.

Beberapa kasus penggunaan bisnis Anda mungkin memerlukan informasi sensitif tertentu, dan yang lainnya mungkin tidak. Tidak ada satu solusi yang mendukung semua kasus penggunaan. Oleh karena itu, Sensitive Data Protection menawarkan kontrol yang fleksibel atas jenis data yang akan dipindai. Jika Anda menggunakan infoType untuk de-identifikasi atau penyamaran, Anda juga dapat mengontrol kapan dan bagaimana data ditransformasi.

Panduan umum

Pertimbangkan panduan umum berikut saat memilih infoType.

Menggunakan infoType umum sebagai pengganti infoType spesifik

Jika Anda tidak ingin hasil pemindaian menampilkan infoType spesifik yang terdeteksi, pertimbangkan untuk menggunakan infoType umum, bukan infoType spesifik dalam konfigurasi pemeriksaan Anda. Untuk mengetahui informasi tentang keuntungan menggunakan detektor infoType umum dalam permintaan Anda, lihat Detektor infoType umum dan spesifik di halaman ini.

Untuk mengetahui daftar lengkap infoType umum dan infoType spesifik yang disertakan, lihat infoType Umum.

Informasi sensitif yang tidak perlu Anda kumpulkan

Setiap layanan di bisnis Anda hanya boleh mengumpulkan data yang dibutuhkan oleh layanan tersebut. Misalnya, layanan tertentu di bisnis Anda tidak perlu mengumpulkan informasi keuangan. Untuk layanan tersebut, pertimbangkan untuk mengaktifkan detektor infoType seperti CREDIT_CARD_NUMBER, FINANCIAL_ACCOUNT_NUMBER, dan infoType lainnya dalam kategori industri FINANCE.

Informasi yang perlu Anda kumpulkan, tetapi tidak ingin dibagikan secara luas kepada tim Anda

Mungkin ada kasus penggunaan yang valid untuk mengumpulkan informasi pribadi, tetapi Anda tidak boleh membagikannya secara luas kepada tim Anda. Misalnya, pelanggan yang mengajukan tiket dukungan dapat memberikan informasi kontak kepada Anda, sehingga Anda dapat menghubungi mereka untuk menyelesaikan masalah. Anda tidak ingin semua orang di tim yang melihat tiket melihat informasi identitas pribadi (PII). Pertimbangkan untuk mengaktifkan detektor infoType seperti PHONE_NUMBER, EMAIL_ADDRESS, dan infoType lainnya dalam kategori jenis PII.

Kategori data sensitif yang tunduk pada peraturan industri, privasi data, atau yurisdiksi

Jenis informasi tertentu dianggap sensitif karena cara penerbitannya atau tujuan penggunaannya. Dalam kasus lain, informasi kontekstual dan demografi dianggap sebagai kategori yang dilindungi. Jenis informasi ini mungkin memiliki batasan tambahan terkait cara pengumpulan, penggunaan, dan pengelolaannya. Pertimbangkan untuk mengaktifkan pendeteksi infoType dalam kategori berikut:

• Kategori jenis SPII, GOVERNMENT_ID, dan DEMOGRAPHIC
• Kategori industri HEALTH

Memilih di antara infoType yang serupa

Pertimbangkan hal berikut saat memilih antara pendeteksi infoType yang serupa.

Paspor

Jika Anda tidak perlu memindai ID paspor dari negara tertentu, pilih detektor umum: PASSPORT.

Detektor paspor khusus negara tertentu, seperti UK_PASSPORT, tersedia. Namun, beberapa detektor paspor khusus negara hanya dapat mengidentifikasi paspor dengan format tertentu atau dengan adanya petunjuk kontekstual.

Nama orang

Saat memindai nama orang, gunakan PERSON_NAME untuk sebagian besar kasus penggunaan, bukan FIRST_NAME atau LAST_NAME.

PERSON_NAME adalah pendeteksi untuk nama orang. Nama ini mencakup nama satu kata dan nama lengkap. Detektor ini mencoba mendeteksi, misalnya, nama seperti Jane, Jane Smith, dan Jane Marie Smith menggunakan berbagai teknologi, termasuk pemahaman bahasa alami. FIRST_NAME dan LAST_NAME adalah subset dari detektor ini yang berupaya mengidentifikasi bagian nama. Temuan dari pendeteksi ini selalu merupakan subset temuan dari PERSON_NAME.

Tanggal dan waktu

Jika Anda tidak perlu memindai semua tanggal, pertimbangkan untuk menggunakan detektor tanggal yang ditargetkan seperti DATE_OF_BIRTH. Detektor ini mencoba mengidentifikasi konteks yang menunjukkan bahwa tanggal tersebut terkait dengan tanggal lahir seseorang.

Detektor DATE mencoba menemukan semua tanggal terlepas dari konteksnya. Fitur ini juga menandai tanggal relatif, seperti hari ini atau kemarin. Demikian pula, TIME mencoba menemukan semua stempel waktu.

Lokasi

Jika Anda tidak perlu memindai semua lokasi, pertimbangkan untuk menggunakan STREET_ADDRESS, bukan detektor LOCATION. Detektor STREET_ADDRESS mencoba menemukan alamat yang memenuhi syarat sepenuhnya, yang biasanya lebih akurat daripada lokasi umum dan dapat dianggap lebih sensitif.

Detektor infoType LOCATION mencoba menemukan lokasi apa pun, terlepas dari konteksnya—misalnya, Paris atau Kanada.

Pendeteksi InfoType yang memerlukan konteks

Banyak detektor infoType memerlukan petunjuk kontekstual agar dapat mengidentifikasi kecocokan. Jika detektor infoType bawaan tidak menandai item yang Anda harapkan untuk ditandai, karena tidak ada petunjuk kontekstual yang terjadi di dekat item tersebut, pertimbangkan untuk menggunakan GENERIC_ID atau detektor infoType kustom.

Jenis informasi yang tidak memiliki definisi industri umum

Beberapa jenis informasi tidak memiliki definisi industri yang umum. Contohnya adalah nomor catatan medis, nomor akun, PIN, dan kode keamanan. Untuk jenis ini, pertimbangkan untuk menggunakan infoType seperti GENERIC_ID, FINANCIAL_ACCOUNT_NUMBER, dan MEDICAL_RECORD_NUMBER. Detektor ini menggunakan kombinasi deteksi entity dan konteks untuk menemukan elemen yang berpotensi sensitif.

Pendeteksi infoType dengan latensi lebih tinggi

• Hindari mengaktifkan detektor infoType yang tidak Anda perlukan. Meskipun berikut ini berguna dalam skenario tertentu, infoType ini dapat membuat permintaan berjalan jauh lebih lambat daripada permintaan yang tidak menyertakannya:

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

• Selalu tentukan pendeteksi infoType secara eksplisit. Jangan gunakan daftar infoTypes kosong.

Cara menggunakan infoType

Sensitive Data Protection menggunakan pendeteksi infoType dalam konfigurasi untuk pemindaiannya guna menentukan apa yang harus diperiksa dan cara mengubah temuan. Nama InfoType juga digunakan saat menampilkan atau melaporkan hasil pemindaian.

Misalnya, jika Anda ingin mencari alamat email dalam blok teks, Anda dapat menentukan detektor infoType EMAIL_ADDRESS dalam konfigurasi pemeriksaan. Jika Anda ingin menyamarkan alamat email dari blok teks, Anda akan menentukan EMAIL_ADDRESS dalam konfigurasi pemeriksaan dan konfigurasi penyamaran untuk menunjukkan cara menyamarkan atau mengubah jenis tersebut.

Selain itu, Anda dapat menggunakan kombinasi detektor infoType bawaan dan kustom untuk mengecualikan subset alamat email dari temuan pemindaian. Pertama, buat infoType kustom yang disebut INTERNAL_EMAIL_ADDRESS dan konfigurasikan untuk mengecualikan alamat email pengujian internal. Kemudian, Anda dapat menyiapkan pemindaian untuk menyertakan temuan untuk EMAIL_ADDRESS, tetapi menyertakan aturan pengecualian yang mengecualikan temuan yang cocok dengan INTERNAL_EMAIL_ADDRESS. Untuk mengetahui informasi selengkapnya tentang aturan pengecualian dan fitur lain dari detektor infoType kustom, lihat Membuat detektor infoType kustom.

Sensitive Data Protection menyediakan serangkaian detektor infoType bawaan yang Anda tentukan berdasarkan nama, yang masing-masing tercantum dalam Referensi detektor infoType. Detektor ini menggunakan berbagai teknik untuk menemukan dan mengklasifikasikan setiap jenis. Misalnya, beberapa jenis akan memerlukan pencocokan pola, beberapa mungkin memiliki checksum matematika, beberapa memiliki batasan digit khusus, dan yang lain mungkin memiliki awalan atau konteks khusus di sekitar temuan.

Contoh

Saat menyiapkan Perlindungan Data Sensitif untuk memindai konten, Anda menyertakan pendeteksi infoType yang akan digunakan dalam konfigurasi pemindaian.

Misalnya, contoh JSON dan kode berikut menunjukkan permintaan pemindaian sederhana ke DLP API. Perhatikan bahwa detektor PHONE_NUMBER ditentukan dalam inspectConfig, yang menginstruksikan Perlindungan Data Sensitif untuk memindai string yang diberikan untuk nomor telepon.

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

Anda harus menentukan infoType tertentu yang tercantum dalam referensi di konfigurasi inspeksi Anda. Jika Anda tidak menentukan infoType apa pun, Sensitive Data Protection menggunakan daftar infoType default yang ditujukan hanya untuk tujuan pengujian. Daftar default mungkin tidak sesuai untuk kasus penggunaan Anda.

Untuk mengetahui informasi selengkapnya tentang cara menggunakan detektor infoType untuk memindai konten Anda, lihat salah satu topik cara penggunaan tentang memeriksa, menyamarkan, atau menghilangkan identitas.

Kepastian dan pengujian

Temuan dilaporkan dengan skor kepastian yang disebut kemungkinan. Skor kemungkinan menunjukkan seberapa besar kemungkinan temuan cocok dengan jenis yang sesuai. Misalnya, jenis dapat menampilkan kemungkinan yang lebih rendah jika hanya cocok dengan pola dan menampilkan kemungkinan yang lebih tinggi jika cocok dengan pola dan memiliki konteks positif di sekitarnya. Oleh karena itu, Anda mungkin melihat bahwa satu temuan dapat cocok dengan beberapa jenis pada kemungkinan yang lebih rendah. Selain itu, temuan mungkin tidak muncul atau memiliki kepastian yang lebih rendah jika tidak cocok dengan benar, atau jika memiliki konteks negatif di sekitarnya. Misalnya, temuan mungkin tidak dilaporkan jika cocok dengan struktur untuk infoType yang ditentukan, tetapi gagal dalam checksum infoType. Atau, temuan dapat cocok dengan lebih dari satu infoType, tetapi memiliki konteks yang meningkatkan salah satunya, sehingga hanya dilaporkan untuk jenis tersebut.

Jika Anda menguji berbagai detektor, Anda mungkin melihat bahwa data palsu atau sampel tidak dilaporkan karena data palsu atau sampel tersebut tidak lulus pemeriksaan yang cukup untuk dilaporkan.

Jenis pendeteksi infoType

Sensitive Data Protection mencakup beberapa jenis detektor infoType, yang semuanya diringkas di sini:

• Detektor infoType bawaan sudah terintegrasi dalam Sensitive Data Protection. Detektor ini mencakup jenis data sensitif khusus negara atau wilayah, serta jenis data yang berlaku secara global. infoType Umum juga tersedia untuk membantu menyederhanakan konfigurasi Anda.
• Detektor infoType kustom adalah detektor yang Anda buat sendiri. Ada tiga jenis pendeteksi infoType kustom:
  • Pendeteksi kamus kustom kecil adalah daftar kata sederhana yang dicocokkan oleh Sensitive Data Protection. Gunakan detektor kamus kustom kecil jika Anda memiliki daftar hingga beberapa puluh ribu kata atau frasa. Detektor kamus kustom kecil lebih disukai jika Anda tidak memperkirakan daftar kata Anda akan berubah secara signifikan.
  • Detektor kamus kustom besar dibuat oleh Sensitive Data Protection menggunakan daftar besar kata atau frasa yang disimpan di Cloud Storage atau BigQuery. Gunakan detektor kamus kustom besar jika Anda memiliki daftar kata atau frasa yang besar—hingga puluhan juta.
  • Pendeteksi ekspresi reguler (regex) memungkinkan Perlindungan Data Sensitif mendeteksi kecocokan berdasarkan pola ekspresi reguler.

Selain itu, Sensitive Data Protection mencakup konsep aturan pemeriksaan, yang memungkinkan Anda menyesuaikan hasil pemindaian menggunakan hal berikut:

• Aturan pengecualian memungkinkan Anda mengurangi jumlah temuan yang ditampilkan dengan menambahkan aturan ke detektor infoType bawaan atau kustom.
• Aturan frasa pengaktif memungkinkan Anda meningkatkan kuantitas atau mengubah nilai kemungkinan temuan yang ditampilkan dengan menambahkan aturan ke detektor infoType bawaan atau kustom.

Pendeteksi infoType bawaan

Detektor infoType bawaan dibuat ke dalam Perlindungan Data Sensitif, dan mencakup detektor untuk jenis data sensitif khusus negara atau wilayah seperti Numéro d'Inscription au Répertoire (NIR) (FRANCE_NIR) Prancis, nomor surat izin mengemudi (UK_DRIVERS_LICENSE_NUMBER) Inggris Raya, dan nomor Jaminan Sosial (US_SOCIAL_SECURITY_NUMBER) Amerika Serikat. Detektor ini juga mencakup jenis data yang berlaku secara global seperti nama orang (PERSON_NAME), nomor telepon (PHONE_NUMBER), alamat email (EMAIL_ADDRESS), dan nomor kartu kredit (CREDIT_CARD_NUMBER). Untuk mendeteksi konten yang sesuai dengan infoType, Perlindungan Data Sensitif memanfaatkan berbagai teknik, termasuk pencocokan pola, checksum, machine learning, analisis konteks, dan lainnya.

Daftar pendeteksi infoType bawaan selalu diperbarui. Untuk mengetahui daftar lengkap detektor infoType bawaan yang saat ini didukung, lihat Referensi detektor infoType.

Anda juga dapat melihat daftar lengkap semua detektor infoType bawaan dengan memanggil metode infoTypes.list Sensitive Data Protection.

Dukungan bahasa

infoType khusus negara mendukung bahasa Inggris dan bahasa negara masing-masing. Sebagian besar infoType global berfungsi dengan beberapa bahasa. Uji Perlindungan Data Sensitif dengan data Anda untuk memverifikasi bahwa data tersebut memenuhi persyaratan Anda.

Detektor infoType umum dan spesifik

Detektor infoType umum adalah detektor yang ditentukan lebih luas daripada detektor infoType biasa dan dapat mencocokkan berbagai jenis informasi yang berpotensi sensitif. Detektor infoType umum adalah superset dari detektor infoType spesifik yang memiliki atribut atau tujuan yang sama. Misalnya, pendeteksi infoType DRIVERS_LICENSE_NUMBER dapat mendeteksi konten yang cocok dengan infoType GERMANY_DRIVERS_LICENSE_NUMBER dan CANADA_DRIVERS_LICENSE_NUMBER.

Dalam banyak kasus, detektor infoType umum juga dapat menemukan kecocokan yang tidak dapat ditemukan oleh detektor infoType spesifik. Misalnya, detektor PASSPORT lebih baik dalam menemukan nomor paspor daripada detektor paspor khusus negara, yang terkadang memerlukan kehadiran petunjuk kontekstual atau konten yang diformat secara khusus.

Dalam konfigurasi pemeriksaan, Anda dapat menggunakan pendeteksi infoType umum, bukan pendeteksi infoType spesifik. Perlindungan Data Sensitif menampilkan hasil berdasarkan detektor yang Anda tentukan dalam permintaan. Misalnya, jika string yang Anda periksa cocok dengan infoType GERMANY_DRIVERS_LICENSE_NUMBER dan Anda memindai DRIVERS_LICENSE_NUMBER dan GERMANY_DRIVERS_LICENSE_NUMBER dalam permintaan Anda, maka Anda akan mendapatkan dua temuan untuk string yang sama—satu untuk DRIVERS_LICENSE_NUMBER dan satu untuk GERMANY_DRIVERS_LICENSE_NUMBER. Namun, jika Anda hanya memindai DRIVERS_LICENSE_NUMBER dalam permintaan Anda, hasil pemeriksaan hanya akan menampilkan temuan untuk DRIVERS_LICENSE_NUMBER.

Penggunaan detektor infoType umum memiliki keunggulan berikut:

• Dalam banyak kasus, detektor infoType umum memiliki perolehan yang lebih tinggi daripada detektor infoType spesifik. Perolehan adalah jumlah instance positif benar dari jumlah total instance yang relevan.

• Anda dapat menyederhanakan permintaan Sensitive Data Protection karena Anda tidak perlu menentukan setiap infoType tertentu yang perlu dipindai. Misalnya, pendeteksi infoType GOVERNMENT_ID saja mencakup lebih dari 100 pendeteksi infoType yang berbeda.

• Anda cenderung tidak mencapai batas 150 pendeteksi infoType per permintaan.

• Jika Sensitive Data Protection merilis infoType baru dan menambahkannya ke infoType umum yang sudah ditentukan dalam konfigurasi yang ada, maka Sensitive Data Protection akan otomatis menyertakan infoType baru tersebut dalam pemindaiannya. Anda tidak perlu menambahkan infoType yang baru dirilis secara manual ke konfigurasi yang ada.

InfoType umum dan spesifik memiliki hubungan many-to-many. Artinya, infoType umum dapat mencakup banyak infoType spesifik, dan infoType spesifik dapat termasuk dalam banyak infoType umum. Untuk mengetahui daftar lengkap infoType umum dan infoType spesifik yang disertakan, lihat infoType umum.

Pendeteksi infoType kustom

Ada tiga jenis pendeteksi infoType kustom:

• Pendeteksi kamus kustom kecil
• Pendeteksi kamus kustom besar
• Ekspresi reguler (regex)

Selain itu, Sensitive Data Protection mencakup aturan pemeriksaan, yang memungkinkan Anda menyempurnakan hasil pemindaian dengan menambahkan hal berikut ke pendeteksi yang ada:

• Aturan pengecualian
• Aturan frasa pengaktif

Pendeteksi kamus kustom kecil

Gunakan pendeteksi kamus kustom kecil (juga disebut sebagai "pendeteksi kamus kustom reguler") untuk mencocokkan daftar kata atau frasa pendek (hingga beberapa puluh ribu). Kamus kustom kecil dapat bertindak sebagai pendeteksi uniknya sendiri.

Pendeteksi kamus kustom berguna saat Anda ingin memindai daftar kata atau frasa yang tidak mudah dicocokkan dengan ekspresi reguler atau pendeteksi bawaan. Misalnya, Anda ingin memindai ruang konferensi yang biasanya disebut dengan nama ruang yang ditetapkan, bukan nomor ruangnya, seperti nama negara bagian atau wilayah, landmark, karakter fiktif, dan sebagainya. Anda dapat membuat detektor kamus khusus kecil yang berisi daftar nama ruangan ini. Sensitive Data Protection dapat memindai konten Anda untuk setiap nama ruangan dan menampilkan kecocokan saat menemukan salah satunya dalam konteks. Pelajari lebih lanjut cara Perlindungan Data Sensitif mencocokkan kata dan frasa kamus di bagian "Kekhususan pencocokan kamus" dalam Membuat detektor kamus kustom reguler.

Untuk mengetahui detail selengkapnya tentang cara kerja pendeteksi infoType kustom kamus kecil, serta contoh dalam tindakan, lihat Membuat pendeteksi kamus kustom reguler.

Pendeteksi kamus kustom besar

Gunakan pendeteksi kamus kustom besar (juga disebut sebagai "pendeteksi kamus kustom tersimpan") jika Anda memiliki lebih dari beberapa kata atau frasa untuk dipindai, atau jika daftar kata atau frasa Anda sering berubah. Detektor kamus kustom besar dapat mencocokkan hingga puluhan juta kata atau frasa.

Pendeteksi kamus kustom besar dibuat secara berbeda dari pendeteksi kustom ekspresi reguler dan pendeteksi kamus kustom kecil. Setiap kamus kustom besar memiliki dua komponen:

• Daftar frasa yang Anda buat dan tentukan. Daftar disimpan sebagai file teks dalam Cloud Storage atau kolom dalam tabel BigQuery.
• File kamus yang dihasilkan, yang dibuat oleh Sensitive Data Protection berdasarkan daftar frasa Anda. File kamus disimpan di Cloud Storage, dan terdiri dari salinan data frasa sumber ditambah filter bloom, yang membantu dalam penelusuran dan pencocokan. Anda tidak dapat mengedit file ini secara langsung.

Setelah membuat daftar kata, lalu menggunakan Sensitive Data Protection untuk membuat kamus kustom, Anda dapat memulai atau menjadwalkan pemindaian menggunakan detektor kamus kustom besar dengan cara yang sama seperti detektor infoType lainnya.

Untuk mengetahui detail selengkapnya tentang cara kerja detektor kamus kustom besar, serta contoh penggunaannya, lihat Membuat detektor kamus kustom tersimpan.

Ekspresi reguler

Detektor infoType kustom ekspresi reguler (regex) memungkinkan Anda membuat detektor infoType sendiri yang memungkinkan Perlindungan Data Sensitif mendeteksi kecocokan berdasarkan pola regex. Misalnya, Anda memiliki nomor rekam medis dalam bentuk ###-#-#####. Anda dapat menentukan pola regex seperti berikut:

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

Kemudian, Sensitive Data Protection akan mencocokkan item seperti ini:

123-4-56789

Anda juga dapat menentukan kemungkinan yang akan ditetapkan ke setiap kecocokan infoType kustom. Artinya, saat Sensitive Data Protection mencocokkan urutan yang Anda tentukan, Sensitive Data Protection akan menetapkan kemungkinan yang telah Anda tunjukkan. Hal ini berguna karena jika ekspresi reguler kustom Anda menentukan urutan yang cukup umum sehingga dapat dengan mudah cocok dengan urutan acak lainnya, Anda tidak ingin Sensitive Data Protection melabeli setiap kecocokan sebagai VERY_LIKELY. Tindakan ini akan mengurangi keyakinan terhadap hasil pemindaian dan berpotensi menyebabkan informasi yang salah dicocokkan atau dianonimkan.

Untuk mengetahui informasi selengkapnya tentang detektor infoType kustom ekspresi reguler, dan untuk melihat cara kerjanya, lihat Membuat detektor regex kustom.

Aturan inspeksi

Anda menggunakan aturan inspeksi untuk mempertajam hasil yang ditampilkan oleh pendeteksi infoType yang ada—baik bawaan maupun kustom. Aturan inspeksi dapat berguna untuk saat hasil yang ditampilkan Sensitive Data Protection perlu ditambah dengan cara tertentu, baik dengan menambahkan ke dan mengecualikan dari detektor infoType yang ada.

Dua jenis aturan inspeksi adalah:

• Aturan pengecualian
• Aturan frasa pengaktif

Untuk mengetahui informasi selengkapnya tentang aturan pemeriksaan, lihat Mengubah detektor infoType untuk menyempurnakan hasil pemindaian.

Aturan pengecualian

Aturan pengecualian memungkinkan Anda mengurangi kuantitas atau presisi temuan yang ditampilkan dengan menambahkan aturan ke detektor infoType bawaan atau kustom. Aturan pengecualian dapat membantu Anda mengurangi derau atau temuan lain yang tidak diinginkan agar tidak ditampilkan oleh detektor infoType.

Misalnya, jika Anda memindai database untuk menemukan alamat email, Anda dapat menambahkan aturan pengecualian dalam bentuk regex kustom yang menginstruksikan Sensitive Data Protection untuk mengecualikan semua temuan yang berakhiran "@example.com".

Aturan pengecualian tidak dapat diterapkan ke infoType objek.

Untuk mengetahui informasi selengkapnya tentang aturan pengecualian, lihat Mengubah detektor infoType untuk menyempurnakan hasil pemindaian.

Aturan frasa pengaktif

Aturan frasa pengaktif memungkinkan Anda meningkatkan kuantitas atau akurasi temuan yang ditampilkan dengan menambahkan aturan ke detektor infoType bawaan atau kustom. Aturan frasa pengaktif dapat secara efektif membantu Anda melonggarkan aturan detektor infoType yang ada.

Misalnya, Anda ingin memindai database medis untuk mencari nama pasien. Anda dapat menggunakan detektor PERSON_NAMEinfoType bawaan Sensitive Data Protection, tetapi hal itu akan menyebabkan Sensitive Data Protection mencocokkan semua nama orang, bukan hanya nama pasien. Untuk memperbaikinya, Anda dapat menyertakan aturan frasa pengaktif dalam bentuk infoType kustom regex yang mencari kata "pasien" dalam jarak karakter tertentu dari karakter pertama kecocokan potensial. Kemudian, Anda dapat menetapkan temuan yang cocok dengan pola ini sebagai kemungkinan "sangat mungkin", karena sesuai dengan kriteria khusus Anda.

Untuk mengetahui informasi selengkapnya tentang aturan frasa pengaktif, lihat Mengubah detektor infoType untuk meningkatkan kualitas hasil pemindaian.

Contoh

Untuk mendapatkan gambaran yang lebih baik tentang cara infoType cocok dengan temuan, lihat contoh pencocokan pada serangkaian digit berikut untuk menentukan apakah digit tersebut merupakan Nomor Jaminan Sosial AS atau Nomor Pokok Wajib Pajak Orang Pribadi AS. Perlu diingat bahwa contoh ini adalah untuk pendeteksi infoType bawaan. Saat Anda membuat detektor infoType kustom, Anda menentukan kriteria yang menentukan kemungkinan kecocokan hasil pemindaian.

Contoh 1

"SSN 222-22-2222"

Melaporkan skor kemungkinan tinggi VERY_LIKELY untuk US_SOCIAL_SECURITY_NUMBER karena:

• Nomor tersebut dalam format nomor Jaminan Sosial standar, yang meningkatkan kepastiannya.
• Memiliki konteks di sekitarnya ("SSN") yang meningkatkan skor ke arah US_SOCIAL_SECURITY_NUMBER.

Contoh 2

"999-99-9999"

Melaporkan skor kemungkinan rendah VERY_UNLIKELY untuk US_SOCIAL_SECURITY_NUMBER karena:

• Formatnya standar, sehingga meningkatkan kepastian.
• Nomor tersebut dimulai dengan angka 9, yang tidak diizinkan dalam nomor Jaminan Sosial, sehingga menurunkan kepastiannya.
• Tidak ada konteks, sehingga menurunkan kepastiannya.

Contoh 3

"999-98-9999"

Melaporkan skor kemungkinan POSSIBLE untuk US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER dan VERY_UNLIKELY untuk US_SOCIAL_SECURITY_NUMBER karena:

• Memiliki format standar untuk US_SOCIAL_SECURITY_NUMBER dan US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Nomor ini dimulai dengan angka 9 dan memiliki pemeriksaan digit lain, yang meningkatkan kepastian untuk US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER.
• Tidak ada konteks, sehingga menurunkan kepastian untuk keduanya.

Langkah berikutnya

Tim Sensitive Data Protection merilis detektor dan grup infoType baru secara berkala. Untuk mempelajari cara mendapatkan daftar infoType bawaan terbaru, lihat Mencantumkan pendeteksi infoType bawaan.