Een aangepast type voor vertrouwelijke gegevens maken met PowerShell

  • Artikel
  • 24 minuten om te lezen

In dit artikel wordt beschreven hoe u een XML-regelpakketbestand maakt waarmee aangepaste typen gevoelige informatie worden gedefinieerd. In dit artikel wordt een aangepast type gevoelige informatie beschreven waarmee een werknemers-id wordt geïdentificeerd. U kunt de voorbeeld-XML in dit artikel gebruiken als uitgangspunt voor uw eigen XML-bestand.

Zie Meer informatie over typen gevoelige informatie voor meer informatie over typen gevoelige informatie.

Nadat u een goed opgemaakt XML-bestand hebt gemaakt, kunt u dit uploaden naar Microsoft 365 met behulp van PowerShell. Vervolgens kunt u uw aangepaste type gevoelige informatie gebruiken in beleidsregels. U kunt de effectiviteit ervan testen bij het detecteren van gevoelige informatie zoals u dat wilt.

Opmerking

Als u het gedetailleerde besturingselement dat PowerShell biedt niet nodig hebt, kunt u aangepaste typen gevoelige informatie maken in de Microsoft Purview-nalevingsportal. Zie Een aangepast type voor vertrouwelijke gegevens maken voor meer informatie.

Tip

Als u geen E5-klant bent, gebruikt u de 90-daagse proefversie van Microsoft Purview-oplossingen om te verkennen hoe aanvullende Purview-mogelijkheden uw organisatie kunnen helpen bij het beheren van gegevensbeveiliging en nalevingsbehoeften. Begin nu bij de hub Microsoft Purview-nalevingsportal proefversies. Meer informatie over registratie- en proefvoorwaarden.

Belangrijke vrijwaring

Microsoft Ondersteuning kunt u niet helpen bij het maken van definities die overeenkomen met inhoud.

Voor het ontwikkelen, testen en opsporen van aangepaste inhoud moet u uw eigen interne IT-resources gebruiken of adviesservices gebruiken, zoals Microsoft Consulting Services (MCS). Microsoft Ondersteuning technici kunnen beperkte ondersteuning bieden voor deze functie, maar ze kunnen niet garanderen dat aangepaste suggesties voor inhoudskoppeling volledig aan uw behoeften voldoen.

MCS kan reguliere expressies bieden voor testdoeleinden. Ze kunnen ook hulp bieden bij het oplossen van problemen met een bestaand RegEx-patroon dat niet werkt zoals verwacht met één specifiek inhoudsvoorbeeld.

Zie Mogelijke validatieproblemen waar u rekening mee moet houden in dit artikel.

Zie Boost.Regex 5.1.3 voor meer informatie over de engine Boost.RegEx (voorheen bekend als RegEx++) die wordt gebruikt voor het verwerken van tekst.

Opmerking

Als u een en-teken (&) gebruikt als onderdeel van een trefwoord in uw aangepaste type gevoelige informatie, moet u een extra term met spaties rond het teken toevoegen. Gebruik L & P bijvoorbeeld nietL&P.

Voorbeeld-XML van een regelpakket

Dit is de voorbeeld-XML van het regelpakket dat we in dit artikel gaan maken. In onderstaande gedeelten worden elementen en kenmerken uitgelegd.

<?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="75">
    <Pattern confidenceLevel="65">
      <IdMatch idRef="Regex_employee_id"/>
    </Pattern>
    <Pattern confidenceLevel="75">
      <IdMatch idRef="Regex_employee_id"/>
      <Match idRef="Func_us_date"/>
    </Pattern>
    <Pattern confidenceLevel="85">
      <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 minMatches="0" 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>
      <Description default="false" langcode="de-de">
      Description for German locale.
      </Description>
    </Resource>
  </LocalizedStrings>
</Rules>
</RulePackage>

Wat zijn uw belangrijkste vereisten? [Regel, Entiteit, Patroonelementen]

Het is belangrijk dat u de basisstructuur van het XML-schema voor een regel begrijpt. Uw kennis van de structuur helpt uw aangepaste type gevoelige informatie om de juiste inhoud te identificeren.

Een regel definieert een of meer entiteiten (ook wel gevoelige informatietypen genoemd). Elke entiteit definieert een of meer patronen. Een patroon is waar een beleid naar op zoek is bij het evalueren van inhoud (bijvoorbeeld e-mail en documenten).

In XML-opmaak betekent 'regels' de patronen die het type gevoelige informatie definiëren. Koppel verwijzingen naar regels in dit artikel niet aan 'voorwaarden' of 'acties' die gebruikelijk zijn in andere Microsoft-functies.

Eenvoudigste scenario: entiteit met één patroon

Dit is een eenvoudig scenario: u wilt dat uw beleid inhoud identificeert die negencijferige werknemer-id's bevat die in uw organisatie worden gebruikt. Een patroon verwijst naar de reguliere expressie in de regel die negencijferige getallen identificeert. Elke inhoud die een getal van negen cijfers bevat, voldoet aan het patroon.

Diagram van entiteit met één patroon.

Maar dit patroon kan elk negencijferig getal identificeren, inclusief langere getallen of andere typen negencijferige nummers die geen werknemer-id's zijn. Dit type ongewenste overeenkomst staat bekend als een fout-positief.

Vaker voorkomend scenario: entiteit met meerdere patronen

Vanwege de kans op fout-positieven gebruikt u doorgaans meer dan één patroon om een entiteit te definiëren. Meerdere patronen bieden ondersteunend bewijs voor de doelentiteit. Aanvullende trefwoorden, datums of andere tekst kunnen bijvoorbeeld helpen bij het identificeren van de oorspronkelijke entiteit (bijvoorbeeld het negencijferige werknemersnummer).

Als u bijvoorbeeld de kans wilt vergroten dat inhoud met een werknemers-id wordt geïdentificeerd, kunt u andere patronen definiëren waarnaar moet worden gezocht:

  • Een patroon dat een aanhuurdatum identificeert.
  • Een patroon dat zowel een indiensttredingsdatum als het trefwoord 'werknemer-id' identificeert.

Diagram van entiteit met meerdere patronen.

Er zijn belangrijke punten om rekening mee te houden voor meerdere patroonovereenkomsten:

  • Patronen die meer bewijs nodig hebben, hebben een hoger betrouwbaarheidsniveau. Op basis van het betrouwbaarheidsniveau kunt u de volgende acties uitvoeren:

    • Gebruik meer beperkende acties (zoals blokinhoud) met overeenkomsten met een hogere betrouwbaarheid.
    • Gebruik minder beperkende acties (zoals het verzenden van meldingen) met overeenkomsten met een lagere betrouwbaarheid.

  • De ondersteunende IdMatch elementen en Match elementen verwijzen naar RegExes en trefwoorden die eigenlijk onderliggende elementen van het Rule element zijn, niet de Pattern. Naar deze ondersteunende elementen wordt verwezen door de Pattern, maar zijn opgenomen in de Rule. Dit gedrag betekent dat naar één definitie van een ondersteunend element, zoals een reguliere expressie of een lijst met trefwoorden, kan worden verwezen door meerdere entiteiten en patronen.

Welke entiteit moet u identificeren? [Entiteitselement, id-kenmerk]

Een entiteit is een type voor vertrouwelijke gegevens, zoals een creditcardnummer, met een goed gedefinieerd patroon. Elke entiteit heeft een unieke GUID als ID.

De entiteit een naam geven en de bijbehorende GUID genereren

  1. Voeg in de XML-editor van uw keuze de Rules elementen en Entity toe.
  2. Voeg een opmerking toe die de naam van uw aangepaste entiteit bevat, zoals Werknemer-id. Later voegt u de naam van de entiteit toe aan de sectie Gelokaliseerde tekenreeksen en die naam wordt weergegeven in het beheercentrum wanneer u een beleid maakt.
  3. Genereer een unieke GUID voor uw entiteit. In Windows PowerShell kunt u bijvoorbeeld de opdracht [guid]::NewGuid()uitvoeren. Later voegt u ook de GUID toe aan de sectie gelokaliseerde tekenreeksen van de entiteit.

XML-opmaak met regels en entiteitselementen.

Welk patroon wilt u vergelijken? [Patroonelement, IdMatch-element. Regex-element]

Het patroon bevat de lijst met waar het type voor vertrouwelijke gegevens naar zoekt. Het patroon kan RegExes, trefwoorden en ingebouwde functies bevatten. Functies voeren taken uit zoals regexes uitvoeren om datums of adressen te vinden. Typen voor gevoelige gegevens kunnen meerdere patronen met unieke betrouwbaarheden.

In het volgende diagram verwijzen alle patronen naar dezelfde reguliere expressie. Deze RegEx zoekt naar een getal (\d{9}) van negen cijfers omgeven door witruimte (\s) ... (\s). Naar deze reguliere expressie wordt verwezen door het IdMatch element en is de algemene vereiste voor alle patronen die zoeken naar de entiteit Werknemer-id. IdMatch is de id die het patroon probeert te vinden. Een Pattern element moet precies één IdMatch element hebben.

XML-opmaak met meerdere patroonelementen die verwijzen naar één Regex-element.

Een tevreden patroonovereenkomst retourneert een aantal en betrouwbaarheidsniveau, dat u kunt gebruiken in de voorwaarden in uw beleid. Wanneer u een voorwaarde voor het detecteren van een type gevoelige informatie toevoegt aan een beleid, kunt u het aantal en het betrouwbaarheidsniveau bewerken, zoals wordt weergegeven in het volgende diagram. Betrouwbaarheidsniveau (ook wel overeenkomstnauwkeurigheid genoemd) wordt verderop in dit artikel uitgelegd.

Opties voor aantal exemplaren en nauwkeurigheid van overeenkomsten.

Reguliere expressies zijn krachtig, dus er zijn problemen die u moet weten. Een RegEx die bijvoorbeeld te veel inhoud identificeert, kan de prestaties beïnvloeden. Zie de sectie Mogelijke validatieproblemen waar u rekening mee moet houden verderop in dit artikel voor meer informatie over deze problemen.

Wilt u aanvullend bewijs eisen? [Trefferelement, minCount-kenmerk]

Daarnaast IdMatchkan een patroon het Match element gebruiken om aanvullend ondersteunend bewijs te vereisen, zoals een trefwoord, RegEx, datum of adres.

Een Pattern kan meerdere Match elementen bevatten:

  • Rechtstreeks in het Pattern element.
  • Gecombineerd met behulp van het Any element.

Match elementen worden gekoppeld door een impliciete AND-operator. Met andere woorden, alle Match elementen moeten worden voldaan om het patroon te laten overeenkomen.

U kunt het Any element gebruiken om AND- of OR-operators te introduceren. Het Any element wordt verderop in dit artikel beschreven.

U kunt het optionele minCount kenmerk gebruiken om op te geven hoeveel exemplaren van een overeenkomst moeten worden gevonden voor elke Match elementen. U kunt bijvoorbeeld specificeren dat pas aan een patroon wordt voldaan wanneer ten minste twee trefwoorden van een lijst met trefwoorden kunnen worden gevonden.

XML-opmaak met het element Overeenkomst met het kenmerk minOccurs.

Trefwoorden [trefwoord, groep en termelementen, matchStyle en caseSensitive-attributen]

Zoals eerder beschreven, vereist het identificeren van gevoelige informatie vaak aanvullende trefwoorden als bewijsmateriaal. U kunt bijvoorbeeld niet alleen overeenkomen met een getal van negen cijfers, maar ook zoeken naar woorden zoals 'kaart', 'badge' of 'ID' met behulp van het element Trefwoord. Het Keyword element heeft een ID kenmerk waarnaar kan worden verwezen door meerdere Match elementen in meerdere patronen of entiteiten.

Trefwoorden worden opgenomen als een lijst met Term elementen in een Group element. Het Group element heeft een matchStyle kenmerk met twee mogelijke waarden:

  • matchStyle="word": een woordovereenkomst identificeert hele woorden omgeven door witruimte of andere scheidingstekens. U moet altijd woord gebruiken, tenzij u delen van woorden of woorden in Aziatische talen moet overeenkomen.

  • matchStyle="string": een tekenreeksovereenkomst identificeert tekenreeksen, ongeacht waar ze door worden omgeven. 'ID' komt bijvoorbeeld overeen met 'bod' en 'idee'. Gebruik string alleen wanneer u Aziatische woorden wilt vinden of als uw trefwoord mogelijk is opgenomen in andere tekenreeksen.

Ten slotte kunt u het caseSensitive kenmerk van het Term element gebruiken om op te geven dat de inhoud exact moet overeenkomen met het trefwoord, inclusief kleine letters en hoofdletters.

XML-opmaak met overeenkomende elementen die verwijzen naar trefwoorden.

Normale expressies [Regex-element]

In dit voorbeeld gebruikt de entiteit werknemer ID het IdMatch element al om te verwijzen naar een reguliere expressie voor het patroon: een getal van negen cijfers omgeven door witruimte. Bovendien kan een patroon een Match element gebruiken om te verwijzen naar een extra Regex element om bevestigend bewijs te identificeren, zoals een vijfcijferig of negencijferig getal in de indeling van een Amerikaanse postcode.

Aanvullende patronen, zoals datums of adressen [ingebouwde functies]

Typen gevoelige informatie kunnen ook ingebouwde functies gebruiken om bewijsmateriaal te identificeren. Bijvoorbeeld een Amerikaanse datum, EU-datum, vervaldatum of Amerikaans adres. Microsoft 365 biedt geen ondersteuning voor het uploaden van uw eigen aangepaste functies. Wanneer u echter een aangepast type gevoelige informatie maakt, kan uw entiteit verwijzen naar ingebouwde functies.

Een badge voor een werknemers-id Func_us_date heeft bijvoorbeeld een indiensttredingsdatum, zodat deze aangepaste entiteit de ingebouwde functie kan gebruiken om een datum te identificeren in de indeling die vaak wordt gebruikt in de VS.

Zie Functies van het type gevoelige informatie voor meer informatie.

XML-opmaak met het element Match dat verwijst naar de ingebouwde functie.

Verschillende combinaties van bewijs [Any-element, minMatches- en maxMatches-kenmerken]

In een Pattern element worden alle IdMatch elementen en Match gekoppeld door een impliciete AND-operator. Met andere woorden, alle overeenkomsten moeten worden voldaan voordat aan het patroon kan worden voldaan.

U kunt flexibelere vergelijkingslogica maken door het Any element te gebruiken om elementen te groeperen Match . U kunt het Any element bijvoorbeeld gebruiken om alle, geen of een exacte subset van de onderliggende Match elementen te vinden.

Het Any element heeft optionele minMatches en maxMatches kenmerken die u kunt gebruiken om te definiëren hoeveel van de onderliggende Match elementen moeten worden voldaan voordat het patroon wordt vergeleken. Deze kenmerken definiëren het aantalMatch elementen, niet het aantal exemplaren van bewijs dat is gevonden voor de overeenkomsten. Als u een minimum aantal exemplaren voor een specifieke overeenkomst wilt definiëren, zoals twee trefwoorden uit een lijst, gebruikt u het minCount kenmerk voor een Match element (zie hierboven).

Ten minste één overeenkomend onderliggend trefferlement

Als u slechts een minimaal aantal Match elementen wilt vereisen, kunt u het minMatches kenmerk gebruiken. In feite worden deze Match elementen gekoppeld door een impliciete OF-operator. Aan dit Any element wordt voldaan als een datum of trefwoord uit een van beide lijsten wordt gevonden.

<Any minMatches="1" >
     <Match idRef="Func_us_date" />
     <Match idRef="Keyword_employee" />
     <Match idRef="Keyword_badge" />
</Any>

Een exact overeekomende subset van onderliggende trefferelementen

Als u een exact aantal Match elementen wilt vereisen, stelt u en maxMatches in minMatches op dezelfde waarde. Aan dit Any element wordt alleen voldaan als er precies één datum of trefwoord wordt gevonden. Als er meer overeenkomsten zijn, komt het patroon niet overeen.

<Any minMatches="1" maxMatches="1" >
     <Match idRef="Func_us_date" />
     <Match idRef="Keyword_employee" />
     <Match idRef="Keyword_badge" />
</Any>

Geen overeenkomende onderliggende trefferelementen

Wanneer u wilt eisen dat er geen bepaald bewijs wordt gevonden om aan een patroon te voldoen, kunt u minMatches en maxMatches beide op 0 instellen. Dit kan handig zijn wanneer u een lijst met trefwoorden hebt of ander bewijs dat waarschijnlijk duidt op een fout-positief.

De entiteit medewerkers-ID zoekt bijvoorbeeld naar het trefwoord 'kaart', omdat dat mogelijk naar 'ID-kaart' verwijst. Als kaart echter alleen voorkomt in 'bankkaart', betekent 'kaart' in deze inhoud waarschijnlijk niet 'ID-kaart'. U kunt dus 'bankkaart' toevoegen als trefwoord in een lijst met termen die u wilt uitsluiten om aan het patroon te voldoen.

<Any minMatches="0" maxMatches="0" >
    <Match idRef="Keyword_false_positives_local" />
    <Match idRef="Keyword_false_positives_intl" />
</Any>

Een aantal unieke overeenkomende termen

Wanneer u een aantal unieke termen wilt vergelijken, gebruikt u de parameter uniqueResults, ingesteld op waar, zoals weergegeven in het volgende voorbeeld:

<Pattern confidenceLevel="75">
    <IdMatch idRef="Salary_Revision_terms" />
    <Match idRef=" Salary_Revision_ID " minCount="3" uniqueResults="true" />
</Pattern>

In dit voorbeeld is een patroon gedefinieerd voor een salariswijziging die gebruikmaakt van ten minste drie unieke overeenkomsten.

Hoe dicht bij de entiteit moet het andere bewijs zijn? [patternsProximity-attribuut]

Uw type voor vertrouwelijke gegevens zoekt naar een patroon dat een medewerkers-ID vertegenwoordigt en als onderdeel van dat patroon zoekt het ook naar ondersteunende gegevens, zoals een trefwoord als 'ID'. Het is logisch dat des te meer het bewijs overeenkomt, des te groter de kans is dat het patroon een medewerkers-ID is. U kunt bepalen hoe dicht bij de entiteit het andere bewijs in het patroon moet zijn, door het vereiste attribuut patternsProximity van het entiteitselement te gebruiken.

XML-opmaak met het kenmerk patternsProximity.

Voor elk patroon in de entiteit definieert de waarde van het attribuut patternsProximity de afstand (in Unicode-tekens) van de IdMatch-locatie voor alle andere overeenkomsten opgegeven voor dat patroon. De nabijheidsmarge is verankerd aan de IdMatch-locatie, waarbij de marge links en rechts van IdMatch kan worden uitgebreid.

Diagram van nabijheidsvenster.

Onderstaande voorbeeld toont hoe de nabijheidsmargevan invloed is op de manier waarop IdMatch-element voor de aangepaste entiteit medewerkers-ID ten minste één overeenkomst van trefwoord of datum vereist. Alleen ID1 komt overeen, omdat voor ID2 en ID3 geen of alleen gedeeltelijk ondersteunende gegevens kunnen worden gevonden binnen de nabijheidsmarge.

Diagram van bevestigend bewijs en nabijheidsvenster.

Houd er rekening mee dat voor e-mailberichten, het bericht zelf en elke bijlage als afzonderlijke items worden behandeld. Dit betekent dat het nabijheidsvenster niet verder gaat dan het einde van elk van deze items. Voor elk item (bijlage of bericht) moeten zowel de IdMatch en ondersteunende gegevens zich in dat item bevinden.

Wat zijn de juiste betrouwbaarheidsniveaus voor verschillende patronen? [confidenceLevel-attribuut, recommendedConfidence-attribuut]

Des te meer bewijs is vereist voor een patroon, des te betrouwbaarder het is dat een werkelijke entiteit (zoals medewerkers-ID) is geïdentificeerd wanneer het patroon overeenkomt. U hebt bijvoorbeeld meer vertrouwen in een patroon dat een negencijferig ID-nummer, datum in dienst en trefwoord dicht bij elkaar vereist, dan in een patroon dat alleen een negencijferig ID-nummer vereist.

Het patroonelement heeft een vereist kenmerk confidenceLevel. U kunt de waarde van confidenceLevel (een waarde tussen 65/75/85 die lage/gemiddelde/hoge betrouwbaarheidsniveaus aangeeft) beschouwen als een unieke id voor elk patroon in een entiteit. Nadat u uw aangepaste type vertrouwelijke gegevens hebt geüpload en daarna beleid hebt gemaakt, kunt u naar deze betrouwbaarheidsniveaus verwijzen in de voorwaarden van de regels die u maakt.

XML-opmaak met patroonelementen met verschillende waarden voor het kenmerk confidenceLevel.

Naast confidenceLevel voor elk patroon heeft de entiteit ook een kenmerk recommendedConfidence. Het kenmerk recommendedConfidence kan worden beschouwd als het standaardbetrouwbaarheidsniveau voor de regel. Wanneer u een beleidsregel maakt, vergelijkt de regel op basis van het aanbevolen betrouwbaarheidsniveau voor de entiteit, tenzij u een betrouwbaarheidsniveau voor de regel opgeeft. Houd er rekening mee dat het kenmerk recommendedConfidence verplicht is voor elke entiteits-ID in het regelpakket. Als het kenmerk ontbreekt, kunt u geen beleid opslaan dat gebruikmaakt van het type vertrouwelijke gegevens.

Wilt u andere talen ondersteunen in de gebruikersinterface van het compliancecentrum? [LocalizedStrings-element]

Als uw complianceteam de Microsoft Purview-nalevingsportal gebruikt om beleidsregels te maken in verschillende landinstellingen en in verschillende talen, kunt u gelokaliseerde versies van de naam en beschrijving van uw aangepaste type gevoelige informatie opgeven. Wanneer uw complianceteam Microsoft 365 gebruikt in een taal die u ondersteunt, zien ze de gelokaliseerde naam in de gebruikersinterface.

Configuratie van het aantal exemplaren en de nauwkeurigheid van overeenkomsten.

Het element regels moet een LocalizedStrings-element bevatten, dat een Resource-element bevat dat verwijst naar de GUID van uw aangepaste entiteit. Elk Resource-element bevat een of meer Naam- en Beschrijving-elementen die elk het kenmerk taalcode gebruiken om een gelokaliseerde tekenreeks te geven voor een specifieke taal.

XML-opmaak met inhoud van het element LocalizedStrings.

Houd er rekening mee dat u gelokaliseerde tekenreeksen alleen gebruikt om te bepalen hoe uw aangepaste type vertrouwelijke gegevens wordt weergegeven in de gebruikersinterface van het compliancecentrum. U kunt gelokaliseerde tekenreeksen niet gebruiken om verschillende gelokaliseerde versies van een lijst trefwoorden of normale expressie te bieden.

Ander regelpakket [RulePack GUID]

Ten slotte bevat het begin van elk RulePackage algemene gegevens die u moet invullen. U kunt de volgende tekst gebruiken als sjabloon en de " . tijdelijke aanduidingen met uw eigen gegevens.

Het belangrijkste is dat u een GUID moet genereren voor het RulePack. Hierboven hebt u een GUID gegenereerd voor de entiteit, dit is een tweede GUID voor het RulePack. Er zijn verschillende manieren om GUID's te genereren, maar u kunt het eenvoudig in PowerShell doen door [guid]::NewGuid() te typen.

Het element Versie is ook belangrijk. WAnneer u uw regelpakket de eerste keer upload, wordt in Microsoft 365 het versienummer genoteerd. Later, wanneer u het regelpakket bijwerkt en een nieuwe versie uploadt, zorg er dan voor dat u het versienummer bijwerkt, anders implementeert Microsoft 365 het regelpakket niet.

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

Wanneer het klaar is, zou uw RulePack-element er als volgt uit moeten zien.

XML-opmaak met rulepack-element.

Validators

Microsoft 365 stelt functieprocessors beschikbaar voor veelgebruikte SID's als validators. Hier volgt een lijst met deze.

Lijst met momenteel beschikbare validators

  • Func_credit_card
  • Func_ssn
  • Func_unformatted_ssn
  • Func_randomized_formatted_ssn
  • Func_randomized_unformatted_ssn
  • Func_aba_routing
  • Func_south_africa_identification_number
  • Func_brazil_cpf
  • Func_iban
  • Func_brazil_cnpj
  • Func_swedish_national_identifier
  • Func_india_aadhaar
  • Func_uk_nhs_number
  • Func_Turkish_National_Id
  • Func_australian_tax_file_number
  • Func_usa_uk_passport
  • Func_canadian_sin
  • Func_formatted_itin
  • Func_unformatted_itin
  • Func_dea_number_v2
  • Func_dea_number
  • Func_japanese_my_number_personal
  • Func_japanese_my_number_corporate

Dit biedt u de mogelijkheid om uw eigen RegEx te definiëren en deze te valideren. Als u validators wilt gebruiken, definieert u uw eigen RegEx en gebruikt u de Validator eigenschap om de functieprocessor van uw keuze toe te voegen. Eenmaal gedefinieerd, kunt u deze RegEx gebruiken in een SIT.

In het onderstaande voorbeeld wordt een reguliere expressie Regex_credit_card_AdditionalDelimiters gedefinieerd voor Creditcard, die vervolgens wordt gevalideerd met behulp van de functie controlesom voor creditcard met behulp van Func_credit_card als validator.

<Regex id="Regex_credit_card_AdditionalDelimiters" validators="Func_credit_card"> (?:^|[\s,;\:\(\)\[\]"'])([0-9]{4}[ -_][0-9]{4}[ -_][0-9]{4}[ -_][0-9]{4})(?:$|[\s,;\:\(\)\[\]"'])</Regex>
<Entity id="675634eb7-edc8-4019-85dd-5a5c1f2bb085" patternsProximity="300" recommendedConfidence="85">
<Pattern confidenceLevel="85">
<IdMatch idRef="Regex_credit_card_AdditionalDelimiters" />
<Any minMatches="1">
<Match idRef="Keyword_cc_verification" />
<Match idRef="Keyword_cc_name" />
<Match idRef="Func_expiration_date" />
</Any>
</Pattern>
</Entity>

Microsoft 365 biedt twee algemene validators

Controleomvalidatie

In dit voorbeeld wordt een checksum validator voor werknemer-id gedefinieerd om de RegEx voor EmployeeID te valideren.

<Validators id="EmployeeIDChecksumValidator">
<Validator type="Checksum">
<Param name="Weights">2, 2, 2, 2, 2, 1</Param>
<Param name="Mod">28</Param>
<Param name="CheckDigit">2</Param> <!-- Check 2nd digit -->
<Param name="AllowAlphabets">1</Param> <!— 0 if no Alphabets -->
</Validator>
</Validators>
<Regex id="Regex_EmployeeID" validators="ChecksumValidator">(\d{5}[A-Z])</Regex>
<Entity id="675634eb7-edc8-4019-85dd-5a5c1f2bb085" patternsProximity="300" recommendedConfidence="85">
<Pattern confidenceLevel="85">
<IdMatch idRef="Regex_EmployeeID"/>
</Pattern>
</Entity>

Datumvalidator

In dit voorbeeld wordt een datumvalidator gedefinieerd voor een RegEx-deel waarvan datum is.

<Validators id="date_validator_1"> <Validator type="DateSimple"> <Param name="Pattern">DDMMYYYY</Param> <!—supported patterns DDMMYYYY, MMDDYYYY, YYYYDDMM, YYYYMMDD, DDMMYYYY, DDMMYY, MMDDYY, YYDDMM, YYMMDD --> </Validator> </Validators>
<Regex id="date_regex_1" validators="date_validator_1">\d{8}</Regex>

Wijzigingen voor Exchange Online

Voorheen gebruikte u mogelijk Exchange Online PowerShell om uw aangepaste typen vertrouwelijke gegevens voor DLP te importeren. Nu kunnen uw aangepaste typen gevoelige informatie worden gebruikt in zowel het Exchange-beheercentrum als het compliancecentrum. Als onderdeel van deze verbetering moet u PowerShell voor beveiligingsnaleving & gebruiken om uw aangepaste typen gevoelige informatie te importeren. U kunt deze niet meer importeren uit Exchange Online PowerShell. Uw aangepaste typen vertrouwelijke gegevens blijven gewoon werken als voorheen, het kan echter maximaal een uur duren voordat wijzigingen die zijn aangebracht aan typen vertrouwelijke gegevens in het compliancecentrum verschijnen in het Exchange-beheercentrum.

Houd er rekening mee dat u in het compliancecentrum de cmdlet New-DlpSensitiveInformationTypeRulePackage gebruikt om een regelpakket te uploaden. (Voorheen hebt u in het Exchange-beheercentrum de cmdlet ClassificationRuleCollection gebruikt.)

Uw regelpakket uploaden

Om uw regelpakket te uploaden, moet u de volgende stappen uitvoeren:

  1. Het pakket opslaan als .XML-bestand met Unicode-codering.

  2. Verbinding maken met PowerShell voor beveiligingsnaleving &

  3. Gebruik de volgende syntaxis:

    New-DlpSensitiveInformationTypeRulePackage -FileData ([System.IO.File]::ReadAllBytes('PathToUnicodeXMLFile'))

    In dit voorbeeld wordt het Unicode XML-bestand met de naam MyNewRulePack.xml geüpload vanaf C:\Mijn documenten.

    New-DlpSensitiveInformationTypeRulePackage -FileData ([System.IO.File]::ReadAllBytes('C:\My Documents\MyNewRulePack.xml'))

    Zie New-DlpSensitiveInformationTypeRulePackage voor meer gedetailleerde syntaxis- en parameterinformatie.

    Opmerking

    Er worden maximaal 10 regelpakketten ondersteund, maar ieder pakket kan de definitie van meerdere typen vertrouwelijke gegevens bevatten.

  4. Voer een van de volgende stappen uit om er zeker van te zijn dat u een nieuw type vertrouwelijke gegevens hebt gemaakt:

    • Voer de cmdlet Get-DlpSensitiveInformationTypeRulePackage uit om te verifiëren dat het nieuwe regelpakket op de lijst wordt vermeld:

      Get-DlpSensitiveInformationTypeRulePackage

    • Voer de cmdlet Get-DlpSensitiveInformationType uit om te verifiëren dat het nieuwe regelpakket op de lijst wordt vermeld:

      Get-DlpSensitiveInformationType

      Voor aangepaste typen vertrouwelijke gegevens wordt de waarde van de eigenschap Uitgever iets anders dan Microsoft Corporation.

    • Vervang Naam> door de waarde Naam van het type gevoelige informatie (bijvoorbeeld: Werknemer-id) en voer de cmdlet Get-DlpSensitiveInformationType<uit:

      Get-DlpSensitiveInformationType -Identity "<Name>"

Mogelijke validatieproblemen om rekening mee te houden

Wanneer u uw regelpakket-XML-bestand uploadt, wordt door het systeem de XML gevalideerd en gecontroleerd op bekende onjuiste patronen en voor de hand liggende prestatieproblemen. Hier zijn een aantal bekende problemen waar de validatie op controleert, een normale expressie:

  • Lookbehind-asserties in de reguliere expressie mogen alleen een vaste lengte hebben. Asserties met variabele lengte resulteren in fouten.

    Bijvoorbeeld, "(?<=^|\s|_)" zal niet slagen voor validatie. Het eerste patroon (^) is lengte nul, terwijl de volgende twee patronen (\s en _) een lengte van één hebben. Een alternatieve manier om deze reguliere expressie te schrijven is "(?:^|(?<=\s|_))".

  • Kan niet beginnen of eindigen met de alternator |, die overeenkomt met alles omdat het wordt beschouwd als een lege overeenkomst.

    Bijvoorbeeld, |a of b| komt niet door de validatie.

  • Kan niet beginnen of eindigen met een .{0,m} patroon, dat geen functioneel doel heeft en alleen de prestaties belemmert.

    Bijvoorbeeld, .{0,50}ASDF of ASDF.{0,50} komt niet door de validatie.

  • Kan geen of .{1,m} in groepen hebben .{0,m} en kan geen of .+ in groepen hebben.\*.

    Bijvoorbeeld, (.{0,50000}) zal niet slagen voor validatie.

  • Kan geen tekens met {0,m} of {1,m} herhalingen in groepen hebben.

    Bijvoorbeeld, (a\*) zal niet slagen voor validatie.

  • Kan niet beginnen of eindigen met .{1,m}; gebruik .in plaats daarvan .

    Bijvoorbeeld, .{1,m}asdf zal niet slagen voor validatie. Gebruik .asdfin plaats daarvan .

  • Kan geen niet-afhankelijke repeater (zoals * of +) in een groep hebben.

    En komt bijvoorbeeld (xx)\*(xx)+ niet door de validatie.

  • Trefwoorden mogen maximaal 50 tekens lang zijn. Als u in een groep een trefwoord hebt dat langer is, wordt voorgesteld een groep met termen te maken als een trefwoordenlijst en de GUID van de trefwoordenboek te verwijzen binnen de XML-structuur als onderdeel van de entiteit voor overeenkomst of idMatch in het bestand.

  • Elk aangepaste type vertrouwelijke gegevens mag maximaal 2048 trefwoorden hebben.

  • De maximale grootte van trefwoordenlijsten in één tenant is 480 kB gecomprimeerd om te voldoen aan de limieten van het AD-schema. Verwijs zo vaak als nodig is naar hetzelfde boek bij het maken van typen vertrouwelijke gegevens. Begin met het maken van aangepaste trefwoordenlijsten in het type vertrouwelijke gegevens en gebruik trefwoordenboeken als u meer dan 2048 trefwoord in een trefwoordenlijst hebt of als een trefwoord langer is dan 50 tekens.

  • Er zijn maximaal 50 typen vertrouwelijke gegevens op basis van trefwoordenboeken toegestaan in een tenant.

  • Zorg ervoor dat elke entiteitselement een kenmerk recommendedConfidence bevat.

  • Wanneer u de PowerShell-cmdlet gebruikt, is er een maximale retourgrootte van de gedeserialiseerde gegevens van ongeveer 1 megabyte. Dit is van invloed op de grootte van het XML-bestand van uw regelpakket. Houd het geüploade bestand beperkt tot maximaal 770 kilobyte, als voorgestelde limiet voor consistente resultaten zonder fouten tijdens de uitvoering.

  • Voor de XML-structuur zijn geen opmaaktekens vereist, zoals spaties, tabbladen of vermeldingen voor regelterugloop/regelinvoer. Houd hier rekening mee bij het optimaliseren van ruimte voor uploads. Hulpprogramma's zoals Microsoft Visual Code bieden join-lijnfuncties om het XML-bestand te comprimeren.

Als een aangepast type vertrouwelijke gegevens een probleem bevat dat de prestaties kan beïnvloeden, wordt het niet geüpload en krijgt u mogelijk een van deze foutberichten te zien:

  • Generic quantifiers which match more content than expected (e.g., '+', '*')

  • Lookaround assertions

  • Complex grouping in conjunction with general quantifiers

Uw inhoud opnieuw bekijken om de vertrouwelijke gegevens te identificeren

Microsoft 365 gebruikt de zoekverkenner om vertrouwelijke gegevens te identificeren en te classificeren in site-inhoud. Inhoud in SharePoint Online- en OneDrive Bedrijven-sites wordt automatisch opnieuw verkend bij het bijwerken. Maar om uw nieuwe aangepaste type vertrouwelijke gegevens te identificeren in alle bestaande inhoud, moet die inhoud opnieuw worden verkend.

In Microsoft 365 kunt u niet handmatig een hercrawl van een hele organisatie aanvragen, maar u kunt handmatig een hercrawl aanvragen voor een siteverzameling, lijst of bibliotheek. Zie Verkenning en opnieuw indexeren van een site, bibliotheek of lijst handmatig aanvragen voor meer informatie.

Verwijzing: definitie van het XML-schema van het regelpakket

U kunt deze tekst kopiëren, opslaan als XSD-bestand en gebruiken om het XML-bestand van uw regelpakket te valideren.

<?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="https://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>

Meer informatie