Creare un tipo di informazioni riservate personalizzato

La prevenzione della perdita dei dati in Office 365 include diversi tipi di informazioni riservate pronti da usare nei criteri di prevenzione della perdita dei dati. Questi tipi predefiniti consentono di identificare e proteggere i numeri di carta di credito, i numeri di conto corrente bancario, i numeri di passaporto e così via.

Tuttavia, se è necessario identificare e proteggere tipi diversi di informazioni riservate, ad esempio un ID dipendente che usa un formato specifico dell'organizzazione, è possibile creare un tipo di informazioni riservate personalizzato. Un tipo di informazioni riservate viene definito in un file XML denominato pacchetto di regole.

Questo argomento mostra come creare un file XML che definisce un tipo di informazioni riservate personalizzato. È necessario sapere come creare un'espressione regolare. Ad esempio, in questo argomento viene creato un tipo di informazioni riservate personalizzato che identifica un ID dipendente. È possibile usare questo file XML di esempio come punto di partenza per il proprio file XML.

Dopo aver creato un file XML ben formato, è possibile caricarlo in Office 365 con PowerShell. Ora è possibile usare il tipo di informazioni riservate personalizzato nei criteri di prevenzione della perdita dei dati e verificare che stia rilevando le informazioni riservate come previsto.

Sommario

Esempio di file XML di un pacchetto di regole

Ecco il file XML di esempio del pacchetto di regole che verrà creato in questo argomento. Gli elementi e gli attributi sono descritti nelle sezioni seguenti.

<?xml version="1.0" encoding="UTF-16"?>
<RulePackage xmlns="http://schemas.microsoft.com/office/2011/mce">

<RulePack id="DAD86A92-AB18-43BB-AB35-96F7C594ADAA">
	<Version build="0" major="1" minor="0" revision="0"/>
	<Publisher id="619DD8C3-7B80-4998-A312-4DF0402BAC04"/>
	<Details defaultLangCode="en-us">
		<LocalizedDetails langcode="en-us">
			<PublisherName>Contoso</PublisherName>
			<Name>Employee ID Custom Rule Pack</Name>
			<Description>
			This rule package contains the custom Employee ID entity.
			</Description>
		</LocalizedDetails>
	</Details>
</RulePack>

<Rules>
<!-- Employee ID -->
	<Entity id="E1CC861E-3FE9-4A58-82DF-4BD259EAB378" patternsProximity="300" recommendedConfidence="70">
		<Pattern confidenceLevel="60">
			<IdMatch idRef="Regex_employee_id"/>
		</Pattern>
		<Pattern confidenceLevel="70">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
		</Pattern>
		<Pattern confidenceLevel="80">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
			<Any minMatches="1">
				<Match idRef="Keyword_badge" minCount=”2”/>
				<Match idRef="Keyword_employee"/>
			</Any>
			<Any maxMatches="0">
				<Match idRef="Keyword_false_positives_local"/>
				<Match idRef="Keyword_false_positives_intl"/>
			</Any>
		</Pattern>
	</Entity>

	<Regex id="Regex_employee_id">(\s)(\d{9})(\s)</Regex>
	<Keyword id="Keyword_employee">
		<Group matchStyle="word">
			<Term>Identification</Term>
			<Term>Contoso Employee</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_badge">
		<Group matchStyle="string">
			<Term>card</Term>
			<Term>badge</Term>
			<Term caseSensitive="true">ID</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_false_positives_local">
		<Group matchStyle="word">
			<Term>credit card</Term>
			<Term>national ID</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_false_positives_intl">
		<Group matchStyle="word">
			<Term>identity card</Term>
			<Term>national ID</Term>
			<Term>EU debit card</Term>
		</Group>
	</Keyword>
	<LocalizedStrings>
		<Resource idRef="E1CC861E-3FE9-4A58-82DF-4BD259EAB378">
			<Name default="true" langcode="en-us">Employee ID</Name>
			<Description default="true" langcode="en-us">
			A custom classification for detecting Employee IDs.
			</Description>
			<Name default="true" langcode="de-de">Name for German locale</Name>
			<Description default="true" langcode="de-de">
			Description for German locale.
			</Description>
		</Resource>
	</LocalizedStrings>
</Rules>
</RulePackage>

Quali sono i requisiti principali? [Elementi Rule, Entity, Pattern]

Prima di iniziare, è utile comprendere la struttura di base di XML Schema per una regola e come usare questa struttura per definire il tipo di informazioni riservate personalizzato in modo che identifichi il contenuto corretto.

Una regola definisce una o più entità, ovvero tipi di informazioni riservate, mentre ogni entità definisce uno o più criteri. Un modello è l'oggetto della ricerca della prevenzione della perdita dei dati quando valuta contenuti come i messaggi di posta elettronica e i documenti.

Una nota rapida sulla terminologia: se si ha familiarità con i criteri di prevenzione della perdita dei dati, si sa che i criteri contengono una o più regole formate da condizioni e azioni. In questo argomento, tuttavia, il markup XML usa il termine regola per indicare i criteri che definiscono un'entità, nota anche come tipo di informazioni riservate. Quindi, in questo argomento il termine regola viene usato per indicare un'entità o un tipo di informazioni riservate, non condizioni e azioni.

Scenario più semplice: entità con un criterio

Ecco lo scenario più semplice. Si vuole che i criteri di prevenzione della perdita dei dati identifichino il contenuto che include l'ID dipendente dell'organizzazione, formattato come un numero di nove cifre. I criteri si riferiscono quindi a un'espressione regolare contenuta nella regola che identifica i numeri di nove cifre. Qualsiasi contenuto che include un numero di nove cifre soddisfa i criteri.

Diagramma dell'entità con un criterio

Tuttavia, anche se semplici, questi criteri possono rilevare molti falsi positivi, trovando contenuti corrispondenti che includono un qualsiasi numero di nove cifre che non è necessariamente un ID dipendente.

Scenario più comune: entità con più criteri

Per questo motivo, è più frequente che un'entità venga definita usando più criteri, che identificano prove corroborative (ad esempio una parola chiave o una data) in aggiunta all'entità (ad esempio un numero di nove cifre).

Ad esempio, per aumentare le probabilità di identificazione di un contenuto che include un ID dipendente, è possibile definire altri criteri che rilevano anche la data di assunzione oppure sia la data di assunzione che una parola chiave, ad esempio "ID dipendente", oltre al numero di nove cifre.

Diagramma dell'entità con più criteri

Ecco alcuni aspetti importanti di questa struttura:

  • I criteri che richiedono altre prove hanno un livello di probabilità più alto. Questo è utile perché quando si usa questo tipo di informazioni riservate in criteri di prevenzione della perdita dei dati in un secondo momento, sarà possibile usare azioni più restrittive, ad esempio il blocco del contenuto, solo per le corrispondenze con probabilità più alta, mentre per quelle con probabilità più bassa si potranno usare azioni meno restrittive, come l'invio di una notifica.

  • Gli elementi di supporto IdMatch e Match fanno riferimento a regex e parole chiave che sono in effetti figli dell'elemento Rule, non di Pattern. Questi elementi di supporto sono indicati da Pattern, ma inclusi in Rule. Ciò significa che più entità e criteri possono fare riferimento a una singola definizione di un elemento di supporto, ad esempio un'espressione regolare o un elenco di parole chiave.

Quale entità deve essere identificata? [Elemento Entity, attributo ID]

Un'entità è un tipo di informazioni riservate, ad esempio il numero di carta di credito, associato a un criterio ben definito. L'ID di ogni entità è un GUID.

Assegnare un nome all'entità e creare il GUID

Aggiungere gli elementi Rules ed Entity. Quindi aggiungere un commento contenente il nome dell'entità personalizzata, in questo esempio l'ID dipendente. In un secondo momento verrà aggiunto il nome dell'entità alla sezione delle stringhe localizzate, che verrà visualizzato nell'interfaccia utente quando si creano i criteri di prevenzione della perdita dei dati.

Quindi, generare un GUID per l'entità. Esistono diversi modi per generare i GUID, ma la soluzione più semplice consiste nell'usare PowerShell digitando [guid]::NewGuid(). In un secondo momento, il GUID dell'entità verrà aggiunto anche alla sezione delle stringhe localizzate.

Markup XML che mostra gli elementi Rules e Entity

Quali criteri si vogliono associare? [Elemento Pattern, elemento IdMatch, elemento Regex]

I criteri contengono l'elenco di elementi cercati dal tipo di informazioni riservate, che può comprendere regex, parole chiave e funzioni incorporate (che eseguono attività quali l'esecuzione di regex per trovare date o indirizzi). I tipi di informazioni riservate possono avere più criteri con probabilità univoche.

L'elemento comune di tutti i criteri seguenti è che fanno tutti riferimento alla stessa espressione regolare, che consente di cercare un numero di nove cifre (\d{9}) racchiuso da spazi (\s)... (\s). Questa espressione regolare viene indicata dall'elemento IdMatch ed è il requisito comune per tutti i criteri che cercano l'entità ID dipendente. IdMatch è l'identificatore per cui i criteri cercano corrispondenze, ad esempio l'ID dipendente, il numero di carta di credito o il codice fiscale. Un elemento Pattern deve avere esattamente un elemento IdMatch.

Markup XML che mostra più elementi Pattern che fanno riferimento a un singolo elemento Regex

Quando vengono soddisfatti, i criteri restituiscono un numero e un livello di probabilità che possono essere usati nelle condizioni dei criteri di prevenzione della perdita dei dati. Quando si aggiunge una condizione per il rilevamento di un tipo di informazioni riservate ai criteri di prevenzione della perdita dei dati, è possibile modificare il numero e il livello di probabilità come illustrato di seguito. Il livello di probabilità, anche noto come accuratezza della corrispondenza, viene spiegato più avanti in questo argomento.

Opzioni Numero di istanze e Accuratezza corrispondenza

Quando si crea l'espressione regolare, tenere presente che possono verificarsi dei problemi. Ad esempio, se si scrive e si carica un regex che identifica una quantità eccessiva di contenuto, le prestazioni possono risentirne. Per altre informazioni su questi problemi potenziali, vedere la sezione successiva Possibili problemi di convalida da tenere presenti.

Sono necessarie altre prove? [Elemento Match, attributo minCount]

Oltre a IdMatch, i criteri possono usare l'elemento Match per richiedere altre prove corroborative, ad esempio una parola chiave, un regex, una data o un indirizzo.

Pattern può contenere più elementi Match, che possono essere inclusi direttamente nell'elemento Pattern o combinati usando l'elemento Any. Gli elementi Match vengono uniti da un operatore implicito AND. Tutti gli elementi Match devono essere soddisfatti per trovare le corrispondenze per i criteri. È possibile usare l'elemento Any per introdurre gli operatori AND o OR. Per altre informazioni, vedere più avanti.

È possibile usare l'attributo facoltativo minCount per specificare quante istanze di una corrispondenza devono essere trovate per ognuno degli elementi Match. Ad esempio, è possibile specificare che i criteri sono soddisfatti solo quando vengono trovate almeno due parole chiave in un elenco delle parole chiave.

Markup XML che mostra l'elemento Match con l'attributo minOccurs

Parole chiave [elementi Keyword, Group e Term, attributi matchStyle e caseSensitive]

Quando si identificano informazioni riservate, ad esempio un ID dipendente, spesso è opportuno richiedere parole chiave come prove corroborative. Ad esempio, oltre a trovare una corrispondenza con un numero di nove cifre, è consigliabile aggiungere anche la ricerca di parole come "carta", "badge" o "ID". A questo scopo, usare l'opzione Keyword. L'elemento Keyword ha un attributo ID che può essere indicato da più elementi Match in più criteri o entità.

Gli elementi Keyword sono inclusi in un elenco di elementi Term in un elemento Group. L'elemento Group ha un attributo matchStyle con due valori possibili:

  • matchStyle="word" La corrispondenza con l'opzione word identifica parole intere racchiuse da spazi o altri delimitatori. È consigliabile usare sempre l'opzione word, a meno che non si debbano trovare corrispondenze con parti di parole o con parole in lingue asiatiche.

  • matchStyle="string" La corrispondenza con l'opzione string identifica le stringhe, a prescindere dagli elementi che le circondano. Ad esempio, le corrispondenze di "id" saranno "bid" e "idea". Usare l'opzione string solo quando è necessario trovare una corrispondenza con parole in lingue asiatiche o se la parola chiave potrebbe essere inclusa in altre stringhe.

Infine, è possibile usare l'attributo caseSensitive di un elemento Term per specificare che il contenuto deve corrispondere esattamente alla parola chiave, incluse le lettere minuscole e maiuscole.

Markup XML che mostra gli elementi Match che fanno riferimento a parole chiave

Espressioni regolari [elemento Regex]

In questo esempio l'entità ID dipendente usa già l'elemento IdMatch per fare riferimento a un regex per i criteri, ovvero un numero di nove cifre racchiuso da spazi. Inoltre, i criteri possono usare un elemento Match per fare riferimento a un altro elemento Regex per identificare una prova corroborativa, ad esempio un numero di cinque o nove cifre nel formato di un codice postale ZIP (Stati Uniti).

Altri criteri, ad esempio date o indirizzi [funzioni predefinite]

Oltre ai tipi di informazioni riservate predefinite, la prevenzione della perdita dei dati include anche funzioni predefinite che consentono di identificare le prove corroborative, ad esempio una data degli Stati Uniti, una data dell'Unione europea, una data di scadenza o un indirizzo degli Stati Uniti. La prevenzione della perdita dei dati non supporta il caricamento di funzioni personalizzate, ma quando si crea un tipo di informazioni riservate personalizzato, l'entità può fare riferimento alle funzioni predefinite.

Ad esempio, un badge dell'ID dipendente contiene una data di assunzione, quindi questa l'entità personalizzata può usare la funzione predefinita Func_us_date per identificare una data nel formato comunemente usato negli Stati Uniti.

Per altre informazioni, vedere Che cosa cercano le funzioni dei criteri di prevenzione della perdita dei dati.

Markup XML che mostra l'elemento Match che fa riferimento alla funzione predefinita

Diverse combinazioni di prove [elemento Any, attributi minMatches e maxMatches]

In un elemento Pattern tutti gli elementi IdMatch e Match vengono uniti da un operatore implicito AND. Per soddisfare i criteri, tutte le corrispondenze devono essere soddisfatte. Tuttavia, è possibile creare una logica di corrispondenza più flessibile usando l'elemento Any per raggruppare gli elementi Match. Ad esempio, è possibile usare qualsiasi elemento Any per trovare le corrispondenze di tutti gli elementi, di nessuno o di uno specifico sottoinsieme di elementi Match figlio.

L'elemento Any ha attributi facoltativi minMatches e maxMatches che consentono di definire quanti elementi Match figlio devono essere soddisfatti per trovare una corrispondenza per i criteri. Questi attributi definiscono il numero di elementi Match che deve essere soddisfatto, non il numero di istanze di prova trovate per le corrispondenze. Per definire un numero di istanze minimo per una corrispondenza specifica, ad esempio due parole chiave da un elenco, usare l'attributo minCount per un elemento Match (vedere sopra).

Trovare una corrispondenza per almeno un elemento Match figlio

Per impostare solo un numero minimo di elementi Match da soddisfare, è possibile usare l'attributo minMatches. In effetti, questi elementi Match sono uniti da un operatore OR implicito. Questo elemento Any viene soddisfatto se in un elenco viene trovata una parola chiave o una data in un formato per gli Stati Uniti.

Markup XML che mostra l'elemento Any con l'attributo minMatches

Trovare una corrispondenza per un sottoinsieme esatto di elementi Match figlio

Per impostare un numero esatto di elementi Match da soddisfare, è possibile impostare minMatches e maxMatches sullo stesso valore. Questo elemento Any viene soddisfatto solo se viene trovata esattamente una data o una parola chiave. Se ne vengono trovate di più, non viene trovata alcuna corrispondenza per i criteri.

Markup XML che mostra l'elemento Any con gli attributi minMatches e maxMatches

Non trovare corrispondenze per gli elementi Match figlio

Se si vuole impostare l'assenza di prove specifiche perché i criteri siano soddisfatti, è possibile impostare maxMatches su 0. Questa opzione può essere utile se si ha un elenco di parole chiave o altre prove che probabilmente indicano un falso positivo.

Ad esempio, l'entità ID dipendente cerca la parola chiave "carta" perché potrebbe fare riferimento a "ID carta". Tuttavia, se viene visualizzato solo nella frase "carta di credito", è improbabile che il termine "carta" in questo contenuto sia riferito all'D scheda (ID card). Quindi è possibile aggiungere "carta di credito" come parola chiave a un elenco di termini da escludere per le corrispondenze dei criteri.

Markup XML che mostra il valore zero dell'attributo maxMatches

Quanto devono essere vicine l'entità e le altre prove? [Attributo patternsProximity]

Il tipo di informazioni riservate cerca i criteri che rappresentano un ID dipendente e, nell'ambito di questi criteri, cerca anche una prova corroborativa, ad esempio una parola chiave come "ID". Quanto più vicina è la prova, tanto più alta è la probabilità che i criteri debbano corrispondere a un effettivo ID dipendente. È possibile determinare quanto debbano essere vicine all'entità le altre prove nei criteri usando l'attributo obbligatorio patternsProximity dell'elemento Entity.

Markup XML che mostra l'attributo patternsProximity

Per ogni criterio nell'entità, il valore dell'attributo patternsProximity definisce la distanza dalla posizione IdMatch in caratteri Unicode per tutte le altre corrispondenze specificate per il criterio. La finestra di prossimità viene ancorata dalla posizione IdMatch, con la finestra che si estende a sinistra e a destra di IdMatch.

Diagramma della finestra di prossimità

L'esempio seguente mostra in che modo la finestra di prossimità influisce sulla corrispondenza dei criteri, dove l'elemento IdMatch per l'entità personalizzata dell'ID dipendente richiede almeno una corrispondenza corroborativa della parola chiave o della data. Solo ID1 corrisponde perché per ID2 e ID3 non sono state trovate prove corroborative o sono state trovate solo prove parziali all'interno della finestra di prossimità.

Diagramma delle prove corroborative e della finestra di prossimità

Per la posta elettronica, il corpo del messaggio e tutti gli allegati vengono trattati come elementi separati. Questo significa che la finestra di prossimità non si estende oltre la fine di ciascuno di questi elementi. Per ogni elemento (allegato o corpo), è necessario che sia idMatch che la prova corroborativa si trovino nell'elemento.

Quali sono i livelli di probabilità corretti per i diversi criteri? [Attributo confidenceLevel, attributo recommendedConfidence]

Più prove sono richieste dai criteri, maggiore è la probabilità che un'entità effettiva, ad esempio un ID dipendente, sia stata identificata quando i criteri trovano una corrispondenza. Ad esempio, la probabilità è maggiore in criteri che richiedono un numero di ID di nove cifre, una data di assunzione e una parola chiave in posizioni molto vicine rispetto ai criteri che richiedono solo un numero di ID di nove cifre.

L'elemento Pattern ha un attributo confidenceLevel obbligatorio. Il valore di confidenceLevel, ovvero un numero intero compreso tra 1 e 100, può essere considerato come un ID univoco per ogni criterio in un'entità. Ai criteri in un'entità devono essere assegnati livelli di probabilità diversi. Il valore esatto del numero intero non ha importanza, basta selezionare numeri significativi per il proprio team di conformità. Dopo aver caricato il tipo di informazioni riservate personalizzato e aver creato i criteri di prevenzione della perdita dei dati, è possibile fare riferimento a questi livelli di probabilità nelle condizioni delle regole create dall'utente.

Markup XML che mostra gli elementi Pattern con valori diversi per l'attributo confidenceLevel

Oltre all'attributo confidenceLevel per ogni elemento Pattern, l'elemento Entity ha un attributo recommendedConfidence. L'attributo recommendedConfidence può essere considerato come il livello di probabilità predefinito per la regola. Quando si crea una regola nei criteri di prevenzione della perdita dei dati, se non si specifica un livello di probabilità per la regola, la corrispondenza per questa regola verrà basata sul livello di probabilità consigliato per l'entità.

SI vogliono supportare altre lingue nell'interfaccia utente del Centro sicurezza e conformità? [Elemento LocalizedStrings]

Se il team di conformità usa il Centro sicurezza e conformità di Office 365 per creare i criteri di prevenzione della perdita dei dati in diverse aree geografiche e in diverse lingue, è possibile fornire versioni localizzate del nome e della descrizione del tipo di informazioni riservate personalizzato. Quando il team di conformità usa Office 365 in un'altra lingua supportata, il nome nell'interfaccia utente verrà visualizzato localizzato.

Opzioni Numero di istanze e Accuratezza corrispondenza

L'elemento Rules deve contenere un elemento LocalizedStrings, che incluse a sua volta un elemento Resource che fa riferimento al GUID dell'entità personalizzata. Ogni elemento Resource a sua volta contiene uno o più elementi Name e Description, ciascuno dei quali usa l'attributo langcode per fornire una stringa localizzata per una lingua specifica.

Markup XML che mostra i contenuti di un elemento LocalizedStrings

Le stringhe localizzate vengono usate solo per determinare in che modo viene visualizzato il tipo di informazioni riservate personalizzato nell'interfaccia utente del Centro sicurezza e conformità. Non è possibile usare stringhe localizzate per fornire diverse versioni localizzate di un elenco di parole chiave o di espressioni regolari.

Altri markup del pacchetto di regole [GUID di RulePack]

Infine, all'inizio di ogni RulePackage sono riportate alcune informazioni generali che è necessario compilare. È possibile usare il markup seguente come modello e sostituire i segnaposto "..." con le proprie informazioni.

E, soprattutto, è necessario generare un GUID per RulePack. In precedenza è stato generato un GUID per l'entità. Questo è un secondo GUID per RulePack. Esistono diversi modi per generare i GUID, ma la soluzione più semplice consiste nell'usare PowerShell digitando [guid]::NewGuid().

Anche l'elemento Version è importante. Quando si carica il pacchetto di regole per la prima volta, Office 365 annota il numero di versione. In un secondo momento, se si aggiorna il pacchetto di regole e si carica una nuova versione, assicurarsi di aggiornare il numero di versione, altrimenti Office 365 non riuscirà a distribuire il pacchetto di regole.

<?xml version="1.0" encoding="utf-16"?>
<RulePackage xmlns="http://schemas.microsoft.com/office/2011/mce">
  <RulePack id=". . .">
    <Version major="1" minor="0" build="0" revision="0" />
    <Publisher id=". . ." /> 
    <Details defaultLangCode=". . .">
      <LocalizedDetails langcode=" . . . ">
         <PublisherName>. . .</PublisherName>
         <Name>. . .</Name>
         <Description>. . .</Description>
      </LocalizedDetails>
    </Details>
  </RulePack>
  
 <Rules>

	. . .

 </Rules>
</RulePackage>

Al termine, l'elemento RulePack dovrà essere simile al seguente.

Markup XML che mostra l'elemento RulePack

Modifiche per Exchange Online

In passato, per importare tipi di informazioni riservate personalizzati per la prevenzione della perdita dei dati, è probabile che fosse usato PowerShell di Exchange Online. Ora i tipi di informazioni riservate personalizzati possono essere usati sia nell'interfaccia di amministrazione di Exchange che nel Centro sicurezza e conformità. Nell'ambito di questo miglioramento, è necessario usare PowerShell nel Centro sicurezza e conformità per importare i tipi di informazioni riservate personalizzati: non è più possibile importarli da Exchange PowerShell. I tipi di informazioni riservate personalizzati continueranno a funzionare come prima, tuttavia per visualizzare nell'interfaccia di amministrazione di Exchange le modifiche apportate ai tipi di informazioni riservate personalizzati nel Centro sicurezza e conformità potrebbe volerci fino a un'ora.

Nel Centro sicurezza e conformità viene usato il cmdlet DlpSensitiveInformationTypeRulePackage per caricare un pacchetto di regole. In precedenza, nell'interfaccia di amministrazione di Exchange, veniva usato il cmdlet ClassificationRuleCollection.

Caricare il pacchetto di regole

Per caricare il pacchetto di regole, eseguire questa procedura.

  1. Salvarlo come file XML con codifica Unicode.

  2. Connettersi al Centro sicurezza e conformità di Office 365 usando una sessione remota di PowerShell

  3. In PowerShell nel Centro sicurezza e conformità digitare New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\percorsopersonalizzato\MyNewRulePack.xml" -Encoding Byte).

    Assicurarsi di usare il percorso del file in cui è effettivamente archiviato il pacchetto di regole. C:\percorsopersonalizzato\ è un segnaposto.

  4. Per confermare, digitare S e quindi premere INVIO.

  5. Verificare che il nuovo tipo di informazioni riservate sia stato caricato digitando Get-DlpSensitiveInformationType per visualizzare un elenco di tutti i tipi di informazioni riservate. È possibile separare rapidamente i tipi di informazioni riservate personalizzati e quelli predefiniti osservando la colonna Publisher. È possibile filtrare l'elenco per un tipo specifico di informazioni riservate eseguendo Get-DlpSensitiveInformationType -Identity "nome del tipo di informazioni riservate".

Possibili problemi di convalida da tenere presenti

Quando si carica il file XML del pacchetto di regole, il sistema convalida il file XML e verifica la presenza di criteri non corretti noti e di problemi di prestazioni evidenti. Ecco alcuni problemi noti verificati con la convalida. Un'espressione regolare:

  • Non può iniziare o terminare con l'alternatore "|", che trova corrispondenze con tutti gli elementi perché è considerato una corrispondenza vuota.

    Ad esempio, "|a" o "b|" non supera la convalida.

  • Non può iniziare o terminare con un criterio ".{0,m}", che non ha alcuno scopo funzionale e influisce solo negativamente sulle prestazioni.

    Ad esempio, ".{0,50}ASDF" o "ASDF.{0,50}" non supera la convalida.

  • Non può contenere ".{0,m}" o ".{1,m}" oppure ".*" o ".+" nei gruppi.

    Ad esempio, "(.{0,50000})" non supera la convalida.

  • Non può contenere caratteri con i ripetitori "{0, m}" o "{1, m}" nei gruppi.

    Ad esempio, "(a*)" non supera la convalida.

  • Non può iniziare o terminare con ".{1,m}". Al suo posto, usare semplicemente "."

    Ad esempio, ".{1,m}asdf"non supera la convalida. In alternativa, usare semplicemente ".asdf".

  • Non può contenere un ripetitore unbounded come "*" o "+" in un gruppo.

    Ad esempio, "(xx)*" e "(xx)+" non superano la convalida.

Se un tipo di informazioni riservate personalizzato contiene un errore che può influire sulle prestazioni, non verrà caricato e potrebbe essere visualizzato uno di questi messaggi di errore:

  • Quantificatori generici che trovano corrispondenze per una quantità di contenuto maggiore del previsto, ad esempio, "+", "*"

  • Asserzioni Lookaround

  • Raggruppamento complesso combinato con quantificatori generali

Ripetere la ricerca per indicizzazione per trovare le informazioni riservate

La prevenzione della perdita dei dati usa il crawler di ricerca per identificare e classificare le informazioni riservate nel contenuto del sito. Il contenuto in SharePoint Online e OneDrive for Business viene sottoposto di nuovo a ricerca per indicizzazione automaticamente ogni volta che viene aggiornato. Tuttavia, per identificare il nuovo tipo di informazioni riservate personalizzato in tutto il contenuto esistente, è necessario ripetere la ricerca per indicizzazione del contenuto.

In Office 365 non è possibile richiedere manualmente una nuova ricerca per indicizzazione per un intero tenant, ma è possibile farlo per una raccolta siti, un elenco o una raccolta. Vedere Richiedere manualmente la ricerca per indicizzazione e la reindicizzazione di un sito, di una raccolta o di un elenco.

Rimuovere un tipo di informazioni riservate personalizzato

  1. Connettersi al Centro sicurezza e conformità di Office 365 usando una sessione remota di PowerShell

  2. In PowerShell nel Centro sicurezza e conformità eseguire una di queste operazioni:

    • Per rimuovere un intero pacchetto di regole e tutte le entità contenute

      Digitare Remove-DlpSensitiveInformationTypeRulePackage "NomePacchettoRegole". Per il file XML di esempio riportato sopra si digiterà Remove-DlpSensitiveInformationTypeRulePackage "Pacchetto di regole personalizzato ID dipendente".

      Per identificare il pacchetto di regole, è possibile usare l'elemento <Name> (per qualsiasi lingua) nell'elemento <Rule Pack> o il GUID dell'attributo ID dell'elemento RulePack.

    • Per rimuovere una singola entità da un pacchetto di regole

      È necessario caricare una nuova versione del pacchetto di regole con l'entità specifica rimossa con Set-DlpSensitiveInformationTypeRulePackage. È necessario assicurarsi che nessun criterio di prevenzione della perdita dei dati o regola di trasporto di Exchange faccia ancora riferimento al tipo di informazioni riservate prima di rimuoverlo.

  3. Per confermare, digitare S e quindi premere INVIO.

  4. Verificare che la nuova regola sia stata rimossa digitando Get- DlpSensitiveInformationType, che non dovrebbe più visualizzare il nome del tipo di informazioni riservate.

Riferimento: XML Schema Definition del pacchetto di regole

È possibile copiare questo markup, salvarlo come file XSD e usarlo per convalidare il file XML del pacchetto di regole.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:mce="http://schemas.microsoft.com/office/2011/mce"
           targetNamespace="http://schemas.microsoft.com/office/2011/mce" 
           xmlns:xs="http://www.w3.org/2001/XMLSchema"
           elementFormDefault="qualified"
           attributeFormDefault="unqualified"
           id="RulePackageSchema">
  <!-- Use include if this schema has the same target namespace as the schema being referenced, otherwise use import -->
  <xs:element name="RulePackage" type="mce:RulePackageType"/>
  <xs:simpleType name="LangType">
    <xs:union memberTypes="xs:language">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value=""/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:simpleType name="GuidType" final="#all">
    <xs:restriction base="xs:token">
      <xs:pattern value="[0-9a-fA-F]{8}\-([0-9a-fA-F]{4}\-){3}[0-9a-fA-F]{12}"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="RulePackageType">
    <xs:sequence>
      <xs:element name="RulePack" type="mce:RulePackType"/>
      <xs:element name="Rules" type="mce:RulesType">
        <xs:key name="UniqueRuleId">
          <xs:selector xpath="mce:Entity|mce:Affinity|mce:Version/mce:Entity|mce:Version/mce:Affinity"/>
          <xs:field xpath="@id"/>
        </xs:key>
        <xs:key name="UniqueProcessorId">
          <xs:selector xpath="mce:Regex|mce:Keyword|mce:Fingerprint"></xs:selector>
          <xs:field xpath="@id"/>
        </xs:key>
        <xs:key name="UniqueResourceIdRef">
          <xs:selector xpath="mce:LocalizedStrings/mce:Resource"/>
          <xs:field xpath="@idRef"/>
        </xs:key>        
        <xs:keyref name="ReferencedRuleMustExist" refer="mce:UniqueRuleId">
          <xs:selector xpath="mce:LocalizedStrings/mce:Resource"/>
          <xs:field xpath="@idRef"/>
        </xs:keyref>
        <xs:keyref name="RuleMustHaveResource" refer="mce:UniqueResourceIdRef">
          <xs:selector xpath="mce:Entity|mce:Affinity|mce:Version/mce:Entity|mce:Version/mce:Affinity"/>
          <xs:field xpath="@id"/>
        </xs:keyref>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="RulePackType">
    <xs:sequence>
      <xs:element name="Version" type="mce:VersionType"/>
      <xs:element name="Publisher" type="mce:PublisherType"/>
      <xs:element name="Details" type="mce:DetailsType">
        <xs:key name="UniqueLangCodeInLocalizedDetails">
          <xs:selector xpath="mce:LocalizedDetails"/>
          <xs:field xpath="@langcode"/>
        </xs:key>
        <xs:keyref name="DefaultLangCodeMustExist" refer="mce:UniqueLangCodeInLocalizedDetails">
          <xs:selector xpath="."/>
          <xs:field xpath="@defaultLangCode"/>
        </xs:keyref>
      </xs:element>
      <xs:element name="Encryption" type="mce:EncryptionType" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="VersionType">
    <xs:attribute name="major" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="minor" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="build" type="xs:unsignedShort" use="required"/>
    <xs:attribute name="revision" type="xs:unsignedShort" use="required"/>
  </xs:complexType>
  <xs:complexType name="PublisherType">
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="LocalizedDetailsType">
    <xs:sequence>
      <xs:element name="PublisherName" type="mce:NameType"/>
      <xs:element name="Name" type="mce:RulePackNameType"/>
      <xs:element name="Description" type="mce:OptionalNameType"/>
    </xs:sequence>
    <xs:attribute name="langcode" type="mce:LangType" use="required"/>
  </xs:complexType>
  <xs:complexType name="DetailsType">
    <xs:sequence>
      <xs:element name="LocalizedDetails" type="mce:LocalizedDetailsType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="defaultLangCode" type="mce:LangType" use="required"/>
  </xs:complexType>
  <xs:complexType name="EncryptionType">
    <xs:sequence>
      <xs:element name="Key" type="xs:normalizedString"/>
      <xs:element name="IV" type="xs:normalizedString"/>
    </xs:sequence>
  </xs:complexType>
  <xs:simpleType name="RulePackNameType">
    <xs:restriction base="xs:token">
      <xs:minLength value="1"/>
      <xs:maxLength value="64"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NameType">
    <xs:restriction base="xs:normalizedString">
      <xs:minLength value="1"/>
      <xs:maxLength value="256"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="OptionalNameType">
    <xs:restriction base="xs:normalizedString">
      <xs:minLength value="0"/>
      <xs:maxLength value="256"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="RestrictedTermType">
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:maxLength value="100"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="RulesType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Entity" type="mce:EntityType"/>
        <xs:element name="Affinity" type="mce:AffinityType"/>
        <xs:element name="Version" type="mce:VersionedRuleType"/>
      </xs:choice>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="Regex" type="mce:RegexType"/>
        <xs:element name="Keyword" type="mce:KeywordType"/>
        <xs:element name="Fingerprint" type="mce:FingerprintType"/>
        <xs:element name="ExtendedKeyword" type="mce:ExtendedKeywordType"/>
      </xs:choice>
      <xs:element name="LocalizedStrings" type="mce:LocalizedStringsType"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="EntityType">
    <xs:sequence>
      <xs:element name="Pattern" type="mce:PatternType" maxOccurs="unbounded"/>
      <xs:element name="Version" type="mce:VersionedPatternType" minOccurs="0" maxOccurs="unbounded" />
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
    <xs:attribute name="patternsProximity" type="mce:ProximityType" use="required"/>
    <xs:attribute name="recommendedConfidence" type="mce:ProbabilityType"/>
    <xs:attribute name="workload" type="mce:WorkloadType"/>
  </xs:complexType>
  <xs:complexType name="PatternType">
    <xs:sequence>
      <xs:element name="IdMatch" type="mce:IdMatchType"/>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="confidenceLevel" type="mce:ProbabilityType" use="required"/>
  </xs:complexType>
  <xs:complexType name="AffinityType">
    <xs:sequence>
      <xs:element name="Evidence" type="mce:EvidenceType" maxOccurs="unbounded"/>
      <xs:element name="Version" type="mce:VersionedEvidenceType" minOccurs="0" maxOccurs="unbounded" />
    </xs:sequence>
    <xs:attribute name="id" type="mce:GuidType" use="required"/>
    <xs:attribute name="evidencesProximity" type="mce:ProximityType" use="required"/>
    <xs:attribute name="thresholdConfidenceLevel" type="mce:ProbabilityType" use="required"/>
    <xs:attribute name="workload" type="mce:WorkloadType"/>
  </xs:complexType>
  <xs:complexType name="EvidenceType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="confidenceLevel" type="mce:ProbabilityType" use="required"/>
  </xs:complexType>
  <xs:complexType name="IdMatchType">
    <xs:attribute name="idRef" type="xs:string" use="required"/>
  </xs:complexType>
  <xs:complexType name="MatchType">
    <xs:attribute name="idRef" type="xs:string" use="required"/>
    <xs:attribute name="minCount" type="xs:positiveInteger" use="optional"/>
    <xs:attribute name="uniqueResults" type="xs:boolean" use="optional"/>
  </xs:complexType>
  <xs:complexType name="AnyType">
    <xs:sequence>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Match" type="mce:MatchType"/>
        <xs:element name="Any" type="mce:AnyType"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="minMatches" type="xs:nonNegativeInteger" default="1"/>
    <xs:attribute name="maxMatches" type="xs:nonNegativeInteger" use="optional"/>
  </xs:complexType>
  <xs:simpleType name="ProximityType">
    <xs:union>
      <xs:simpleType>
        <xs:restriction base='xs:string'>
          <xs:enumeration value="unlimited"/>
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:positiveInteger">
          <xs:minInclusive value="1"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:simpleType name="ProbabilityType">
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="1"/>
      <xs:maxInclusive value="100"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="WorkloadType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Exchange"/>
      <xs:enumeration value="Outlook"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="EngineVersionType">
    <xs:restriction base="xs:token">
      <xs:pattern value="^\d{2}\.01?\.\d{3,4}\.\d{1,3}$"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="VersionedRuleType">
    <xs:choice maxOccurs="unbounded">
      <xs:element name="Entity" type="mce:EntityType"/>
      <xs:element name="Affinity" type="mce:AffinityType"/>
    </xs:choice>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:complexType name="VersionedPatternType">
    <xs:sequence>
      <xs:element name="Pattern" type="mce:PatternType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:complexType name="VersionedEvidenceType">
    <xs:sequence>
      <xs:element name="Evidence" type="mce:EvidenceType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="minEngineVersion" type="mce:EngineVersionType" use="required" />
  </xs:complexType>
  <xs:simpleType name="FingerprintValueType">
    <xs:restriction base="xs:string">
      <xs:minLength value="2732"/>
      <xs:maxLength value="2732"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="FingerprintType">
    <xs:simpleContent>
      <xs:extension base="mce:FingerprintValueType">
        <xs:attribute name="id" type="xs:token" use="required"/>
        <xs:attribute name="threshold" type="mce:ProbabilityType" use="required"/>
        <xs:attribute name="shingleCount" type="xs:positiveInteger" use="required"/>
        <xs:attribute name="description" type="xs:string" use="optional"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="RegexType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="id" type="xs:token" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="KeywordType">
    <xs:sequence>
      <xs:element name="Group" type="mce:GroupType" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:token" use="required"/>
  </xs:complexType>
  <xs:complexType name="GroupType">
    <xs:sequence>
      <xs:choice>
        <xs:element name="Term" type="mce:TermType" maxOccurs="unbounded"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="matchStyle" default="word">
      <xs:simpleType>
        <xs:restriction base="xs:NMTOKEN">
          <xs:enumeration value="word"/>
          <xs:enumeration value="string"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="TermType">
    <xs:simpleContent>
      <xs:extension base="mce:RestrictedTermType">
        <xs:attribute name="caseSensitive" type="xs:boolean" default="false"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="ExtendedKeywordType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="id" type="xs:token" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="LocalizedStringsType">
    <xs:sequence>
      <xs:element name="Resource" type="mce:ResourceType" maxOccurs="unbounded">
      <xs:key name="UniqueLangCodeUsedInNamePerResource">
        <xs:selector xpath="mce:Name"/>
        <xs:field xpath="@langcode"/>
      </xs:key>
      <xs:key name="UniqueLangCodeUsedInDescriptionPerResource">
        <xs:selector xpath="mce:Description"/>
        <xs:field xpath="@langcode"/>
      </xs:key>
    </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="ResourceType">
    <xs:sequence>
      <xs:element name="Name" type="mce:ResourceNameType" maxOccurs="unbounded"/>
      <xs:element name="Description" type="mce:DescriptionType" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="idRef" type="mce:GuidType" use="required"/>
  </xs:complexType>
  <xs:complexType name="ResourceNameType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="default" type="xs:boolean" default="false"/>
        <xs:attribute name="langcode" type="mce:LangType" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:complexType name="DescriptionType">
    <xs:simpleContent>
      <xs:extension base="xs:string">
        <xs:attribute name="default" type="xs:boolean" default="false"/>
        <xs:attribute name="langcode" type="mce:LangType" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:schema>

Altre informazioni

Amplia le tue competenze
Esplora i corsi di formazione
Ottieni in anticipo le nuove caratteristiche
Partecipa al programma Office Insider

Queste informazioni sono risultate utili?

Grazie per i tuoi commenti e suggerimenti

Grazie per il tuo feedback! Potrebbe essere utile metterti in contatto con uno dei nostri operatori del supporto di Office.

×