Een aangepast type voor vertrouwelijke gegevens maken met PowerShell

In dit artikel leest u hoe u een XML-regelpakketbestand maakt dat aangepaste typen gevoelige informatie definieert. In dit artikel wordt een aangepast type gevoelige informatie beschreven waarmee een werknemer-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 gevormd XML-bestand hebt gemaakt, kunt u het 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 de gevoelige informatie zoals u bedoeld.

Opmerking

Als u het fijnmazige 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, kunt u alle premium-functies in Microsoft Purview gratis proberen. Gebruik de proefversie van Purview-oplossingen van 90 dagen om te ontdekken hoe robuuste Purview-mogelijkheden uw organisatie kunnen helpen bij het beheren van de behoeften op het gebied van gegevensbeveiliging en naleving. Begin nu bij de hub met Microsoft Purview-nalevingsportal proefversies. Meer informatie over registratie en proefabonnementen.

Belangrijke vrijwaring

Microsoft Ondersteuning kan u niet helpen bij het maken van definities voor inhoudskoppeling.

Voor aangepaste inhoudskoppelingen voor ontwikkeling, testen en foutopsporing moet u uw eigen interne IT-resources gebruiken of adviesservices gebruiken, zoals Microsoft Consulting Services (MCS). Microsoft Ondersteuning engineers 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 ampersandteken (&) gebruikt als onderdeel van een trefwoord in uw aangepaste type gevoelige informatie, moet u een extra term toevoegen met spaties rond het teken. Gebruik L & P bijvoorbeeld nietL&P.

Voorbeeld-XML van een regelpakket

Hier 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 begrip 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 zoekt wanneer inhoud wordt geëvalueerd (bijvoorbeeld e-mail en documenten).

In XML-markeringen betekent 'regels' de patronen waarmee het type gevoelige informatie wordt gedefinieerd. Koppel geen verwijzingen naar regels in dit artikel aan 'voorwaarden' of 'acties' die gebruikelijk zijn in andere Microsoft-functies.

Eenvoudigste scenario: entiteit met één patroon

Hier 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. Inhoud die een negencijferig nummer bevat, voldoet aan het patroon.

Diagram van entiteit met één patroon.

Maar dit patroon kan elk nummer van negen cijfers identificeren, inclusief langere getallen of andere typen negencijferige getallen die geen werknemer-id's zijn. Dit type ongewenste overeenkomst wordt een fout-positief genoemd.

Vaker voorkomend scenario: entiteit met meerdere patronen

Vanwege het potentieel voor fout-positieven gebruikt u meestal meer dan één patroon om een entiteit te definiëren. Meerdere patronen bieden ondersteunend bewijs voor de doelentiteit. Extra 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 werknemer-id wordt geïdentificeerd, kunt u andere patronen definiëren om te zoeken naar:

  • Een patroon waarmee een aanstellingsdatum wordt geïdentificeerd.
  • Een patroon dat zowel een aanstellingsdatum als het trefwoord 'werknemer-id' aangeeft.

Diagram van entiteit met meerdere patronen.

Er zijn belangrijke punten waarmee u rekening moet houden bij 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 meldingen verzenden) met overeenkomsten met een lagere betrouwbaarheid.
  • De ondersteunende IdMatch 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 de en Entity de elementen toe in de Rules XML-editor van uw keuze.
  2. Voeg een opmerking toe die de naam van uw aangepaste entiteit bevat, zoals werknemer-id. Later voegt u de entiteitsnaam 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-markeringen 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 bijvoorbeeld RegExes uit 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 negencijferig nummer (\d{9}) 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-markeringen met meerdere patroonelementen die verwijzen naar één Regex-element.

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

Opties voor aantal exemplaren en overeenkomstnauwkeurigheid.

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 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 extra ondersteunend bewijs te vereisen, zoals een trefwoord, RegEx, datum of adres.

A Pattern kan meerdere Match elementen bevatten:

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

Match elementen worden samengevoegd door een impliciete AND-operator. Met andere woorden, aan alle Match elementen moet worden voldaan om te voldoen aan het patroon.

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 voor elke Match elementen moeten worden gevonden. 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-markeringen met het kenmerk Match met minOccurs.

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

Zoals eerder beschreven, vereist het identificeren van gevoelige informatie vaak extra trefwoorden als bevestigend bewijs. U kunt bijvoorbeeld niet alleen zoeken naar een negencijferig nummer, maar ook woorden zoeken zoals 'kaart', 'badge' of 'ID' met behulp van het sleutelwoordelement. 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 tussen spaties of andere scheidingstekens. U moet altijd woord gebruiken, tenzij u delen van woorden of woorden in Aziatische talen moet vinden.

  • matchStyle="string": Een tekenreeksovereenkomst identificeert tekenreeksen, ongeacht waar ze tussen staan. 'Id' komt bijvoorbeeld overeen met 'bieden' en 'idee'. Gebruik string dit alleen als u Aziatische woorden wilt vergelijken 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-markeringen met overeenkomende elementen die verwijzen naar trefwoorden.

Normale expressies [Regex-element]

In dit voorbeeld gebruikt de entiteit Employee ID al het IdMatch element om te verwijzen naar een reguliere expressie voor het patroon: een negencijferig nummer 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 vijf- of negencijferig nummer in de notatie van een Amerikaanse postcode.

Aanvullende patronen, zoals datums of adressen [ingebouwde functies]

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

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

Zie de functies van het type Gevoelige informatie voor meer informatie.

XML-markeringen 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 IdMatchMatch elementen samengevoegd door een impliciete AND-operator. Met andere woorden, alle overeenkomsten moeten worden voldaan voordat het patroon kan worden voldaan.

U kunt flexibelere overeenkomende logica 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 maxMatchesminMatches en kenmerken die u kunt gebruiken om te definiëren aan hoeveel van de onderliggende Match elementen moet worden voldaan voordat het patroon wordt vergeleken. Met deze kenmerken wordt het aantalMatch elementen gedefinieerd, niet het aantal exemplaren van het bewijs dat voor de overeenkomsten is gevonden. 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 minimum aantal Match elementen wilt vereisen, kunt u het minMatches kenmerk gebruiken. In feite worden deze Match elementen samengevoegd door een impliciete OR-operator. Aan dit Any element wordt voldaan als er een datum in amerikaanse notatie of een trefwoord uit een van de 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 minMatches deze in op maxMatches dezelfde waarde. Aan dit Any element wordt alleen voldaan als er precies één datum of trefwoord wordt gevonden. Als er nog overeenkomsten zijn, wordt het patroon niet vergeleken.

<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-markeringen 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) zien 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-markeringen 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 beleid te maken in verschillende landinstellingen en in verschillende talen, kunt u gelokaliseerde versies opgeven van de naam en beschrijving van uw aangepaste type gevoelige informatie. Wanneer uw complianceteam Microsoft 365 gebruikt in een taal die u ondersteunt, zien ze de gelokaliseerde naam in de gebruikersinterface.

Configuratie van aantal exemplaren en overeenkomstnauwkeurigheid.

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-markeringen met de 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 maakt functieprocessors voor veelgebruikte SID's beschikbaar als validatiefuncties. Hier is een lijst met hen.

Lijst met momenteel beschikbare validaties

  • 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 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. Zodra deze is 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 controlesomfunctie 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 validaties

Controlesom validator

In dit voorbeeld wordt een controlesom 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>

Datum validator

In dit voorbeeld wordt een datum validator gedefinieerd voor een RegEx-deel waarvan de 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 ze niet meer importeren vanuit 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. (Eerder 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 naamwaarde 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 van vaste lengte zijn. Asserties met variabele lengte resulteren in fouten.

    De validatie wordt bijvoorbeeld "(?<=^|\s|_)" niet voltooid. 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 deze wordt beschouwd als een lege overeenkomst.

    Bijvoorbeeld, |a of b| zal niet worden gevalideerd.

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

    Bijvoorbeeld, .{0,50}ASDF of ASDF.{0,50} zal niet worden gevalideerd.

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

    De validatie wordt bijvoorbeeld (.{0,50000}) niet voltooid.

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

    De validatie wordt bijvoorbeeld (a\*) niet voltooid.

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

    De validatie wordt bijvoorbeeld .{1,m}asdf niet voltooid. Gebruik in .asdfplaats daarvan .

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

    Bijvoorbeeld, (xx)\* en (xx)+ zal niet worden gevalideerd.

  • 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 ad-schemalimieten. 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, tabs of regelterugloop-/regelinvoervermeldingen. 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 recrawl van een hele organisatie aanvragen, maar u kunt handmatig een recrawl aanvragen voor een siteverzameling, lijst of bibliotheek. Zie Handmatig verkennen en opnieuw indexeren van een site, bibliotheek of lijst 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