Créer un type d’informations sensibles personnalisé

Dans Office 365, la protection contre la perte de données (DLP) intègre de nombreux types d’informations sensibles que pouvez utiliser directement dans vos stratégies DLP. Ces types intégrés permettent d’identifier et de protéger les numéros de carte de crédit, les numéros de compte bancaire, les numéros de passeport et bien plus encore.

Mais si vous devez identifier et protéger un autre type d’informations sensibles, par exemple un ID d’employé qui utilise un format spécifique à votre organisation, vous avez la possibilité de créer un type d’informations sensibles personnalisé. Un type d’informations sensibles se définit dans un fichier XML appelé package de règles.

Cette rubrique vous montre comment créer un fichier XML qui définit votre type d’informations sensibles personnalisé. Vous devez savoir comment créer une expression régulière. À titre d’exemple, cette rubrique permet de créer un type d’informations sensibles personnalisé qui identifie un ID d’employé. Vous pouvez utiliser cet exemple de code XML comme point de départ de votre propre fichier XML.

Une fois que vous avez créé un fichier XML correct, vous pouvez le télécharger dans Office 365 à l’aide de PowerShell. Vous êtes alors prêt à utiliser votre type d’informations sensibles personnalisé dans vos stratégies DLP et à vérifier qu’il détecte bien les informations sensibles comme prévu.

Contenu

Exemple de code XML d’un package de règles

Voici le code XML du package de règles que nous allons créer dans cette rubrique. Les différents éléments et attributs sont expliqués dans les sections suivantes.

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

Quelles sont vos principales exigences ? [éléments Rule, Entity, Pattern]

Avant de commencer, vous devez comprendre la structure de base du schéma XML d’une règle et comment vous pouvez l’utiliser pour définir votre type d’informations sensibles personnalisé afin qu’il identifie le contenu correct.

Une règle définit une ou plusieurs entités (types d’informations sensibles), et chaque entité définit un ou plusieurs modèles. Un modèle est ce que recherche la DLP lorsqu’elle évalue des contenus tels que les messages électroniques et les documents.

(Note rapide sur la terminologie : si vous connaissez les stratégies DLP, vous savez qu’une stratégie contient une ou plusieurs règles composées de conditions et actions. Toutefois, dans cette rubrique, le balisage XML utilise le terme règle pour désigner les modèles qui définissent une entité, également appelée type d’informations sensibles. Par conséquent, lorsque vous rencontrez le terme règle dans cette rubrique, vous devez le comprendre comme signifiant entité ou type d’informations sensibles, et pas conditions et actions.)

Scénario le plus simple : entité avec un modèle

Voici le scénario le plus simple. Vous souhaitez que votre stratégie DLP identifie le contenu qui comprend l’ID d’employé de votre organisation, celle-ci se présentant sous la forme d’un nombre à neuf chiffres. Par conséquent, le modèle référence une expression régulière contenue dans la règle qui identifie le nombre à neuf chiffres. Tout contenu comprenant un nombre à neuf chiffres correspond au modèle.

Diagramme d’entité avec un modèle

Néanmoins et malgré sa simplicité, ce modèle peut identifier de nombreux faux positifs en considérant comme contenu correspondant un contenu comprenant un nombre à neuf chiffres, qui n’est pas nécessairement un ID d’employé.

Scénario plus courant : entité avec plusieurs modèles

Pour cette raison, il est plus courant de définir une entité à l’aide de plusieurs modèles. Dans ce cas, les modèles identifient la preuve à l’appui (telle qu’un mot clé ou une date) en plus de l’entité (telle qu’un nombre à neuf chiffres).

Par exemple, pour augmenter la probabilité d’identifier un contenu comprenant un ID d’employé, vous pouvez définir un autre modèle qui identifie également une date d’embauche, et définir encore un autre modèle qui identifie une date d’embauche et un mot clé (par exemple « ID d’employé »), en plus du nombre à neuf chiffres.

Diagramme d’entité avec plusieurs modèles

Il convient de noter deux aspects importants de cette structure :

  • Les modèles qui nécessitent plus de preuves ont un niveau de confiance plus élevé. Ceci est utile car lorsque vous utilisez ce type d’informations sensibles par la suite dans une stratégie DLP, vous pouvez utiliser des actions plus restrictives (par exemple le blocage de contenu) uniquement avec les correspondances d’un niveau de confiance plus élevé, et utiliser des actions moins restrictives (par exemple l’envoi d’une notification) avec les correspondances d’un niveau de confiance inférieur.

  • Les éléments IdMatch et Match de support référencent les expressions régulières et les mots clés enfants de l’élément Rule et non de l’élément Pattern. Ces éléments de support sont référencés dans l’élément Pattern, mais inclus dans l’élément Rule. Cela signifie qu’une seule définition d’un élément de support, par exemple une expression régulière ou une liste de mots clés, peut être référencée par plusieurs entités et modèles.

Quelle entité devez-vous identifier ? [élément Entity, attribut id]

Une entité est un type d’informations sensibles, tel qu’un numéro de carte de crédit, associé à un modèle bien défini. L’ID de chaque entité est un GUID unique.

Nommer l’entité et générer son GUID

Ajoutez les éléments Rules et Entity. Ensuite, ajoutez un commentaire qui contient le nom de votre entité personnalisée (dans cet exemple, l’ID d’employé). Vous ajouterez ultérieurement le nom de l’entité à la section de chaînes localisées. Ce nom est celui qui apparaît dans l’interface utilisateur lorsque vous créez une stratégie DLP.

Ensuite, générez un GUID pour votre entité. Vous disposez de plusieurs méthodes pour générer des GUID, mais cette opération peut être effectuée facilement dans PowerShell en saisissant [guid]::NewGuid(). Plus tard, vous ajouterez également le GUID de l’entité à la section de chaînes localisées.

Balisage XML montrant les éléments Rules et Entity

Quel modèle doit être utilisé pour la correspondance ? [élément Pattern, élément IdMatch, élément Regex]

Le modèle contient la liste de ce que le type d’informations sensibles recherche. Elle peut inclure des expressions régulières, des mots clés et des fonctions intégrées (qui effectuent des tâches telles que l’exécution des expressions régulières pour rechercher des dates ou des adresses). Les types d’informations sensibles peuvent avoir plusieurs modèles avec un niveau de confiance qui leur est propre.

Tous les modèles suivants ont une chose en commun : ils référencent tous la même expression régulière, qui se présente sous la forme d’un nombre à neuf chiffres (\d{9}) entre espaces (\s) … (\s). Cette expression régulière est référencée par l’élément IdMatch et est l’exigence commune à tous les modèles qui recherchent l’entité d’ID d’employé. IdMatch est l’identificateur dont le modèle cherche des correspondances, par exemple un ID d’employé ou un numéro de carte de crédit, ou encore un numéro de sécurité sociale. Un élément Pattern doit avoir exactement un élément IdMatch.

Balisage XML montrant plusieurs éléments Pattern référençant l’élément Regex

Lorsqu’il est satisfait, un modèle renvoie un nombre et un niveau de confiance, que vous pouvez utiliser dans les conditions de votre stratégie DLP. Lorsque vous ajoutez à une stratégie DLP une condition de détection d’un type d’informations sensibles, vous pouvez modifier le nombre et le niveau de confiance comme indiqué ici. La notion de niveau de confiance (également appelée précision de correspondance) est expliquée plus loin dans cette rubrique.

Nombre d’instances et options de précision de correspondance

Lorsque vous créez l’expression régulière, n’oubliez pas que vous devez tenir compte d’un certain nombre de problèmes potentiels. Par exemple, si vous écrivez et téléchargez une expression régulière qui identifie trop de contenu, cela peut affecter les performances. Pour en savoir plus sur ces problèmes potentiels, consultez la section Problèmes de validation éventuels plus loin dans cette rubrique.

Voulez-vous demander des preuves supplémentaires ? [élément Match, attribut minCount]

Outre l’élément IdMatch, un modèle peut utiliser l’élément Match pour demander des preuves supplémentaires à l’appui, notamment un mot clé, une expression régulière, une date ou une adresse.

Un modèle peut comporter plusieurs éléments Match, qui peuvent être inclus directement dans l’élément Pattern ou combinés à l’aide de l’élément Any. Les éléments Match sont joints par un opérateur AND implicite. Tous les éléments Match doivent être satisfaits pour qu’une correspondance au modèle soit trouvée. Vous pouvez utiliser l’élément Any pour introduire des opérateurs AND ou OR (voir plus loin pour de plus amples informations).

Vous pouvez utiliser l’attribut facultatif minCount pour spécifier combien d’instances d’une correspondance doivent être trouvées pour chaque élément Match. Par exemple, vous pouvez spécifier qu’un modèle est satisfait uniquement lorsqu’au moins deux mots clés d’une liste de mots clés sont trouvés.

Balisage XML montrant l’élément Match avec l’attribut minOccurs

Mots clés [éléments Keyword, Group et Term, attributs matchStyle et caseSensitive]

Lorsque vous identifiez des informations sensibles, telles qu’un ID d’employé, vous êtes souvent tenté de demander des mots clés comme preuve à l’appui. Par exemple, outre une correspondance à un nombre à neuf chiffres, il se peut que vous vouliez rechercher des mots tels que « carte », « badge » ou « ID ». Pour cela, vous devez utiliser l’élément Keyword. L’élément Keyword possède un attribut id qui peut être référencé par plusieurs éléments Match dans plusieurs modèles ou entités.

Les mots clés sont inclus sous forme d’une liste d’éléments Term dans un élément Group. L’élément Group possède un attribut matchStyle avec deux valeurs possibles :

  • matchStyle=”word” La correspondance de mot identifie des mots entiers entre espaces ou autres séparateurs. Vous devez toujours utiliser word, sauf si vous recherchez des correspondances à des parties de mot ou des correspondances dans une langue asiatique.

  • matchStyle=”string” La correspondance de chaîne identifie les chaînes, peu importe ce qui les entoure. Par exemple, « id » renvoie « ride » et « idée ». Utilisez string uniquement lorsque vous recherchez des mots asiatiques ou s’il est possible que votre mot clé soit inclus dans d’autres chaînes.

Enfin, vous pouvez utiliser l’attribut caseSensitive de l’élément Term pour spécifier que le contenu doit correspondre exactement au mot clé, en respectant la casse.

Balisage XML montrant les éléments Match référençant des mots clés

Expressions régulières [élément Regex]

Dans cet exemple, l’entité d’ID d’employé utilise déjà l’élément IdMatch pour référencer une expression régulière pour le modèle : un nombre à chiffres neuf entre espaces. Par ailleurs, un modèle peut utiliser un élément Match pour référencer un élément Regex supplémentaire afin d’identifier une preuve à l’appui, par exemple un nombre à cinq ou neuf chiffres au format de code postal américain.

Autres modèles tels que les dates ou les adresses [fonctions intégrées]

Outre les types d’informations sensibles intégrés, la DLP inclut également des fonctions intégrées qui peuvent identifier des preuves à l’appui telles qu’une date américaine, une date européenne, une date d’expiration ou une adresse américaine. La DLP ne prend pas en charge le téléchargement de fonctions personnalisées, mais lorsque vous créez un type d’informations sensibles personnalisé, votre entité peut référencer les fonctions intégrées.

Par exemple, un badge d’ID d’employé porte une date d’embauche. Par conséquent, cette entité personnalisée peut pas utiliser la fonction intégrée Func_us_date pour identifier une date au format utilisé aux États-Unis.

Pour plus d’informations, voir What the DLP functions look for.

Balisage XML montrant l’élément Match référençant une fonction intégrée

Différentes combinaisons de preuves [élément Any, attributs minMatches et maxMatches]

Dans un élément Pattern, tous les éléments IdMatch et Match sont joints par un opérateur AND implicite : toutes les correspondances doivent être satisfaites pour que le modèle soit satisfait. Toutefois, vous pouvez créer une logique de correspondance plus souple en utilisant l’élément Any pour regrouper des éléments Match. Par exemple, vous pouvez utiliser l’élément Any pour rechercher les correspondances à tous ses éléments Match enfants ou à un sous-ensemble exact de ces éléments ou ne pas rechercher de correspondance à ces éléments.

L’élément Any est associé à des attributs minMatches et maxMatches facultatifs, que vous pouvez utiliser pour définir le nombre d’éléments Match enfants qui doivent être satisfaits pour qu’une correspondance au modèle soit trouvée. Il convient de noter que ces attributs définissent le nombre d’éléments Match qui doivent être satisfaits, pas le nombre d’instances de preuves trouvées pour les correspondances. Pour définir un nombre minimal d’instances pour une correspondance spécifique, par exemple deux mots clés d’une liste, vous devez utiliser l’attribut minCount d’un élément Match (voir ci-dessus).

Correspondance à au moins un élément Match enfant

Pour exiger la satisfaction d’un nombre minimal d’éléments Match seulement, vous pouvez utiliser l’attribut minMatches. En effet, ces éléments Match sont joints par un opérateur OR implicite. Cet élément Any est satisfait si une date au format américain ou un mot clé d’une liste est trouvé.

Balisage XML montrant l’élément Any avec l’attribut minMatches

Correspondance à un sous-ensemble exact d’éléments Match enfants

Pour exiger la satisfaction d’un nombre exact d’éléments Match, vous pouvez définir les attributs minMatches et maxMatches sur la même valeur. Cet élément Any est satisfait uniquement si une seule date ou un seul mot clé est trouvé. Si plus d’une date ou d’un mot clé est trouvé, aucune correspondance au modèle n’est renvoyée.

Balisage XML montrant l’élément Any avec les attributs minMatches et maxMatches

Aucune correspondance aux éléments Match enfants

Pour exiger l’absence de preuve spécifique pour la satisfaction d’un modèle, vous pouvez définir maxMatches sur 0. Cela peut s’avérer utile si vous avez une liste de mots clés ou d’autres preuves susceptibles d’indiquer des faux positifs.

Par exemple, l’entité d’ID d’employé recherche le mot clé « carte », car il peut désigner une « carte d’identité ». Toutefois, si le mot « carte » apparaît uniquement dans l’expression « carte de crédit », il est peu probable qu’il signifie « carte d’identité » dans ce contenu. Par conséquent, vous pouvez ajouter « carte de crédit » comme mot clé à une liste de termes que vous voulez exclure de la satisfaction du modèle.

Balisage XML montrant une valeur d’attribut maxMatches égale à zéro

Quelle doit être la proximité entre l’entité et l’autre preuve ? [attribut patternsProximity]

Votre type d’informations sensibles recherche un modèle qui représente un ID d’employé, et dans ce modèle, il recherche également une preuve à l’appui, par exemple un mot clé tel que « ID ». Il est logique que plus cette preuve est proche, plus le modèle est susceptible d’être un ID d’employé. Vous pouvez déterminer la proximité exigée entre la preuve et l’entité dans le modèle à l’aide de l’attribut obligatoire patternsProximity de l’élément Entity.

Balisage XML montrant l’attribut patternsProximity

Pour chaque modèle de l’entité, la valeur de l’attribut patternsProximity définit la distance (en caractères Unicode) à partir de l’emplacement IdMatch pour toutes les autres correspondances spécifiées pour ce modèle. La fenêtre de proximité est ancrée par l’emplacement IdMatch et s’étend à gauche et à droite de l’emplacement IdMatch.

Diagramme de la fenêtre de proximité

L’exemple suivant illustre la façon dont la fenêtre de proximité affecte la correspondance au modèle, avec l’élément IdMatch de l’entité personnalisée d’ID d’employé nécessitant au moins une correspondance de mot clé ou de date à l’appui. Seul l’ID1 correspond car pour l’ID2 et l’ID3, soit aucune preuve à l’appui n’est présente dans la fenêtre de proximité, soit seulement une preuve partielle est présente.

Diagramme de preuves à l’appui et de la fenêtre de proximité

Il convient de noter que pour le courrier électronique, le corps du message et chaque pièce jointe sont traités comme des éléments distincts. Cela signifie que la fenêtre de proximité ne s’étend pas au-delà de ces éléments. L’emplacement idMatch et la preuve à l’appui doivent résider dans chaque élément (pièce jointe ou corps).

Quels sont les niveaux de confiance appropriés pour différents modèles ? [attribut confidenceLevel, attribut recommendedConfidence]

Plus un modèle nécessite de preuves, plus vous pouvez être sûr qu’une entité (telle qu’un ID d’employé) a effectivement été identifiée lorsqu’une correspondance à un modèle est trouvé. Par exemple, vous avez plus confiance dans un modèle qui nécessite un numéro d’identification à neuf chiffres, la date d’embauche et un mot clé à proximité directe, que dans un modèle qui requiert uniquement un numéro d’identification à neuf chiffres.

L’élément Pattern est associé à un attribut confidenceLevel obligatoire. Vous pouvez considérer la valeur confidenceLevel (un nombre entier compris entre 1 et 100) comme un ID unique pour chaque modèle d’une entité : les modèles d’une entité doivent avoir des niveaux de confiance distincts que vous attribuez. Peu importe la valeur précise de l’entier, sélectionnez simplement un nombre approuvé par votre équipe de conformité. Une fois que vous avez téléchargé votre type d’informations sensibles personnalisé et que vous avez créé une stratégie DLP, vous pouvez référencer ces niveaux de confiance dans les conditions des règles que vous créez.

Balisage XML montrant les éléments Pattern avec des valeurs différentes pour l’attribut confidenceLevel

En plus de l’attribut confidenceLevel de chaque modèle, l’entité possède un attribut recommendedConfidence. L’attribut de niveau de confiance recommandé est assimilable au niveau de confiance par défaut de la règle. Lorsque vous créez une règle dans une stratégie DLP, si vous n’indiquez pas le niveau de confiance que la règle doit utiliser, cette règle recherche les correspondances en fonction du niveau de confiance recommandé pour l’entité.

Voulez-vous prendre en charge d’autres langues dans l’interface utilisateur du Centre de sécurité et conformité ? [élément LocalizedStrings]

Si votre équipe de conformité utilise le Centre de sécurité et conformité Office 365 pour créer les stratégies DLP à l’aide de paramètres régionaux différents et dans différentes langues, vous avez la possibilité de fournir des versions localisées du nom et de la description de votre type d’informations sensibles personnalisé. Lorsque votre équipe de conformité utilise Office 365 dans une langue que vous prenez en charge, elle peut voir le nom localisé dans l’interface utilisateur.

Nombre d’instances et options de précision de correspondance

L’élément Rules doit contenir un élément LocalizedStrings, qui comprend un élément Resource référençant le GUID de votre entité personnalisée. Chaque élément Resource contient quant à lui un ou plusieurs éléments Name et Description qui utilisent l’attribut langcode afin de fournir une chaîne localisée pour une langue spécifique.

Balisage XML montrant le contenu de l’élément LocalizedStrings

Il convient de noter que les chaînes localisées vous permettent uniquement de définir comment le type d’information sensibles personnalisé apparaît dans l’interface utilisateur et le Centre de sécurité et conformité. Vous ne pouvez pas les utiliser pour fournir différentes versions localisées d’une liste de mots clés ou d’une expression régulière.

Autre balisage de package de règles [GUID RulePack]

Enfin, le début de chaque RulePackage contient des informations générales que vous devez indiquer. Vous pouvez utiliser le balisage suivant comme modèle et remplacez les espaces réservés “. . .” par vos données.

Mais surtout, vous devez générer un GUID pour le RulePack. Ci-dessus, vous avez généré un GUID pour l’entité. Il s’agit ici de créer un second GUID pour le RulePack. Vous disposez de plusieurs méthodes pour générer des GUID, mais cette opération peut être effectuée facilement dans PowerShell en saisissant [guid]::NewGuid().

L’élément Version est également important. Lorsque vous téléchargez votre package de règles la première fois, Office 365 prend note du numéro de version. Si vous mettez à jour le package de règles ultérieurement et téléchargez une nouvelle version, veillez à mettre à jour le numéro de version pour qu’Office 365 puisse déployer le package de règles.

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

Une fois que vous avez terminé, votre élément RulePack doit se présenter comme suit.

Balisage XML montrant l’élément RulePack

Modifications pour Exchange Online

Auparavant, vous utilisiez peut-être Exchange Online PowerShell pour importer vos types d’informations sensibles personnalisés pour DLP. Désormais, vos types d’informations sensibles personnalisés peuvent être utilisés dans le Centre d’administration Exchange et dans le Centre de sécurité et conformité. Dans le cadre de cette amélioration, nous vous conseillons d’utiliser PowerShell dans le Centre de sécurité et conformité pour les importer, car vous ne pouvez plus les importer à partir d’Exchange PowerShell. Vos types d’informations sensibles personnalisés continueront à fonctionner comme ils l’ont fait jusqu’à présent. Toutefois, une heure peut être nécessaire pour que les modifications apportées aux types d’informations sensibles personnalisés dans le Centre de sécurité et conformité soient reflétées dans le Centre d’administration Exchange.

Notez que dans le Centre de sécurité et conformité, vous devez utiliser l’applet de commande DlpSensitiveInformationTypeRulePackage pour charger un package de règles. Auparavant, dans le Centre d’administration Exchange, vous utilisiez l’applet de commande ClassificationRuleCollection.

Télécharger le package de règles

Pour télécharger votre package de règles, procédez comme suit.

  1. Enregistrez-le en tant que fichier .xml avec le codage Unicode.

  2. Se connecter au Centre de sécurité et conformité Office 365 à l’aide de PowerShell à distance

  3. Dans PowerShell dans le Centre de sécurité et conformité, saisissez New- DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\custompath\MyNewRulePack.xml" -Encoding Byte).

    Veillez à utiliser l’emplacement de fichier dans lequel votre package de règles est effectivement stocké. C:\custompath\ est un espace réservé.

  4. Pour confirmer, saisissez Y, puis appuyez sur ENTRÉE.

  5. Vérifiez que votre nouveau type d’informations sensibles a bien été téléchargé en saisissant Get-DlpSensitiveInformationType afin d’afficher la liste de tous les types sensibles. Vous pouvez rapidement distinguer les types d’informations sensibles personnalisés des types intégrés en consultant la colonne Éditeur. Vous pouvez filtrer la liste pour obtenir un type d’informations sensibles particulier en exécutant la commande Get-DlpSensitiveInformationType -Identity “nom du type d’informations sensibles”.

Problèmes de validation éventuels

Lorsque vous téléchargez votre fichier XML de package de règles, le système valide le fichier XML et recherche les modèles incorrects connus et les problèmes de performance évidents. La liste suivante répertorie certains des problèmes recherchés lors de la validation. Une expression régulière :

  • Ne peut pas commencer ou se terminer par un alternateur « | » car celui-ci correspond à tous les éléments puisqu’il est considéré comme correspondance vide.

    Avec « |a » ou « b| » par exemple, la validation échoue.

  • Ne peut pas commencer ou se terminer par un modèle « {0,m} » car celui-ci ne remplit aucune fonction et réduit les performances.

    Avec « .{0,50}ASDF » ou « ASDF.{0,50} » par exemple, la validation échoue.

  • Ne peut pas contenir « .{0,m} » ou « .{1,m} » dans les groupes, ni « .* » ou « .+ ».

    Avec « (.{0,50000}) » par exemple, la validation échoue.

  • Ne peut pas contenir de caractère avec le répéteur « {0,m} » ou « {1,m} » dans les groupes.

    Avec « (a*) » par exemple, la validation échoue.

  • Ne peut pas commencer ou se terminer par « {1,m} ». Utilisez simplement « . ».

    Avec « .{1,m}asdf » par exemple, la validation échoue. Utilisez simplement « .asdf ».

  • Ne peut pas contenir de répéteur illimité (tel que « * » ou « + ») dans un groupe.

    Avec « (xx)* » et « (xx)+ » par exemple, la validation échoue.

Si un type d’informations sensibles personnalisé contient un problème qui peut affecter les performances, il n’est pas téléchargé et il est possible qu’un des types de message d’erreur suivants s’affiche :

  • Quantificateurs génériques correspondant à plus de contenu que prévu (par exemple, « + », « * »)

  • Assertions d’inspection

  • Regroupement complexe conjointement avec des quantificateurs généraux

Analyser de nouveau le contenu pour identifier les informations sensibles

La DLP utilise le robot de recherche pour identifier et classer les informations sensibles du contenu d’un site. Le contenu des sites SharePoint Online et OneDrive Entreprise est à nouveau analysé automatiquement chaque fois qu’il est mis à jour. Mais pour que votre nouveau type d’informations sensibles personnalisé puisse être identifié dans l’ensemble du contenu existant, il doit être de nouveau analysé.

Dans Office 365, vous ne pouvez pas demander manuellement une nouvelle analyse de l’ensemble d’un client, mais cela est possible pour une collection de sites, une liste ou une bibliothèque (voir Manually request crawling and re-indexing of a site, a library or a list).

Supprimer un type d’informations sensibles personnalisé

  1. Se connecter au Centre de sécurité et conformité Office 365 à l’aide de PowerShell à distance

  2. Dans le Centre de sécurité et conformité PowerShell, effectuez l’une des opérations suivantes :

    • Pour supprimer un package de règles entier et toutes les entités qu’il contient

      Saisissez Remove-DlpSensitiveInformationTypeRulePackage "NomDeVotrePackageDeRègles". Pour l’exemple de code XML ci-dessus, vous saisiriez Remove-DlpSensitiveInformationTypeRulePackage "Package de règles personnalisé d’ID d’employé".

      Notez que pour identifier votre package de règles, vous pouvez utiliser l’élément <Name> (pour n’importe quelle langue) dans l’élément <Rule Pack> ou le GUID de l’attribut id de l’élément RulePack.

    • Pour supprimer une seule entité d’un package de règles

      Vous devez télécharger une nouvelle version de votre package de règles avec l’entité en question supprimée à l’aide de la commande Set-DlpSensitiveInformationTypeRulePackage. Vous devrez vous assurer qu’aucune stratégie DLP ou règle de transport Exchange ne référence le type d’informations sensibles avant de le supprimer.

  3. Pour confirmer, saisissez Y, puis appuyez sur ENTRÉE.

  4. Vérifiez que votre nouvelle règle a bien été supprimée en saisissant Get- DlpSensitiveInformationType. Le nom de votre type d’informations sensibles ne devrait pas s’afficher.

Référence : définition de schéma XML du package de règles

Vous pouvez copier ce balisage, l’enregistrer sous la forme d’un fichier XSD et l’utiliser pour valider votre fichier XML de package de règles.

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

Informations complémentaires

Développez vos compétences
Découvrez des formations
Accédez aux nouvelles fonctionnalités en avant-première
Rejoignez le programme Office Insider

Ces informations vous ont-elles été utiles ?

Nous vous remercions pour vos commentaires.

Merci pour vos commentaires. Il serait vraisemblablement utile pour vous de contacter l’un de nos agents du support Office.

×