Skapa en anpassad typ av känslig information med PowerShellCreate a custom sensitive information type using PowerShell

I det här avsnittet beskrivs hur du använder PowerShell för att skapa en XML-fil för regelpaket som definierar dina egna typer av känslig information.This topic shows you how to use PowerShell to create an XML rule package file that defines your own custom sensitive information types. Du behöver veta hur du skapar ett reguljärt uttryck.You need to know how to create a regular expression. I det här avsnittet skapas exempelvis en anpassad typ av känslig information som identifierar ett medarbetar-ID.As an example, this topic creates a custom sensitive information type that identifies an employee ID. Du kan använda det här XML-exemplet som utgångspunkt för din egen XML-fil.You can use this example XML as a starting point for your own XML file. Se Läs mer om typer av känslig information om du inte har använt typer av känslig information tidigare.If you are new to sensitive information types, see Learn about sensitive information types.

När du har skapat en korrekt formaterad XML-fil kan du ladda upp den till Microsoft 365 med hjälp av Microsoft 365 PowerShell.After you've created a well-formed XML file, you can upload it to Microsoft 365 by using Microsoft 365 PowerShell. Sedan är du redo att använda din anpassade typ av känslig information i dina principer och testa att den identifierar denna känsliga information på det sätt som du tänkt dig.Then you're ready to use your custom sensitive information type in your policies and test that it's detecting the sensitive information as you intended.

Anteckning

Om du inte behöver den detaljerade kontroll som du får med PowerShell kan du skapa anpassade typer av känslig information i efterlevnadscentret.If you don't need the fine grained control that PowerShell provides, you can create custom sensitive information types in the Compliance center. Mer information finns i Skapa en anpassad typ av känslig information.For more information, see Create a custom sensitive information type.

Viktig ansvarsfriskrivningImportant disclaimer

På grund av skillnaderna mellan olika kundmiljöer och innehållsmatchningskrav kan Microsoft Support inte hjälpa till med att ge anpassade definitioner för innehållsmatchning, till exempel definiera anpassade klassificeringar eller mönster för reguljära uttryck (även kallade RegEx).Due to the variances in customer environments and content match requirements, Microsoft Support cannot assist in providing custom content-matching definitions; e.g., defining custom classifications or regular expression (also known as RegEx) patterns. För utveckling, testning och felsökning av anpassad innehållsmatchning måste Microsoft 365-kunder förlita sig på interna IT-resurser, eller använda en extern konsultresurs som Microsoft Consulting Services (MCS).For custom content-matching development, testing, and debugging, Microsoft 365 customers will need to rely upon internal IT resources, or use an external consulting resource such as Microsoft Consulting Services (MCS). Supporttekniker kan ge begränsad support för funktionen, men kan inte garantera att utvecklingen av anpassad innehållsmatchning uppfyller kundens krav eller skyldigheter.Support engineers can provide limited support for the feature, but cannot provide assurances that any custom content-matching development will fulfill the customer's requirements or obligations. En typ av support som kan tillhandahållas är exempelmönster för reguljära uttryck för testningsändamål.As an example of the type of support that can be provided, sample regular expression patterns may be provided for testing purposes. Eller så kan supporten hjälpa till att felsöka ett befintligt RegEx-mönster som inte utlöses som förväntat med ett enskilt specifikt innehållsexempel.Or, support can assist with troubleshooting an existing RegEx pattern which is not triggering as expected with a single specific content example.

Se Möjliga verifieringsproblem som du bör känna till i det här avsnittet.See Potential validation issues to be aware of in this topic.

Mer information om Boost.RegEx-motorn (tidigare kallad RegEx++) som används för att bearbeta texten finns i Boost.Regex 5.1.3.For more information about the Boost.RegEx (formerly known as RegEx++) engine that's used for processing the text, see Boost.Regex 5.1.3.

XML-exempel för regelpaketSample XML of a rule package

Här är XML-exempelkoden för det regelpaketet som vi skapar i det här avsnittet.Here's the sample XML of the rule package that we'll create in this topic. Element och attribut förklaras i avsnitten nedan.Elements and attributes are explained in the sections below.

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

Vilka är dina viktigaste krav?What are your key requirements? [elementen Rule, Entity, Pattern][Rule, Entity, Pattern elements]

Innan du börjar är det bra om du förstår den grundläggande strukturen i XML-schemat för en regel och hur du kan använda den här strukturen för att definiera en anpassad typ av känslig information så att rätt innehåll identifieras.Before you get started, it's helpful to understand the basic structure of the XML schema for a rule, and how you can use this structure to define your custom sensitive information type so that it will identify the right content.

En regel definierar en eller flera entiteter (typer av känslig information) och varje entitet definierar ett eller flera mönster.A rule defines one or more entities (sensitive information types), and each entity defines one or more patterns. En princip söker efter mönster när den utvärderar innehåll som e-post och dokument.A pattern is what a policy looks for when it evaluates content such as email and documents.

I det här avsnittet med XML-kod avser regel de mönster som definierar en entitet, även kallad typ av känslig information.In this topic, the XML markup uses rule to mean the patterns that define an entity, also known as a sensitive information type. När du ser en regel i det här avsnittet motsvarar den alltså entitet eller typ av känslig information, inte villkor och åtgärder.So in this topic, when you see rule, think entity or sensitive information type, not conditions and actions.

Enklaste scenariot: entitet med ett mönsterSimplest scenario: entity with one pattern

Här är det enklaste scenariot.Here's the simplest scenario. Du vill att principen ska identifiera innehåll som innehåller organisationens medarbetar-ID, som är formaterat som ett niosiffrigt nummer.You want your policy to identify content that contains your organization's employee ID, which is formatted as a nine-digit number. Mönstret refererar därför till ett reguljärt uttryck som finns i en regel som identifierar niosiffriga nummer.So the pattern refers to a regular expression contained in the rule that identifies nine-digit numbers. Allt innehåll som innehåller ett niosiffrigt nummer uppfyller mönstret.Any content containing a nine-digit number satisfies the pattern.

Diagram av entitet med ett mönster

Det här är ett enkelt mönster som riskerar att identifiera många falska positiva identifieringar eftersom det matchar alla niosiffriga nummer, inte bara medarbetar-ID:n.However, while simple, this pattern may identify many false positives by matching content that contains any nine-digit number that is not necessarily an employee ID.

Ett vanligare scenario: entitet med flera mönsterMore common scenario: entity with multiple patterns

Därför är det vanligare att definiera en entitet med hjälp av flera mönster, där mönster identifierar bevis (till exempel ett nyckelord eller datum) utöver enheten (till exempel ett niosiffrigt nummer).For this reason, it's more common to define an entity by using more than one pattern, where the patterns identify supporting evidence (such as a keyword or date) in addition to the entity (such as a nine-digit number).

Om du vill öka sannolikheten att exempelvis identifiera ett faktiskt medarbetar-ID i ett visst innehåll kan du definiera ett annat mönster som även identifierar anställningsdatum, och definiera ytterligare ett mönster som identifierar både ett anställningsdatum och ett nyckelord (till exempel ”medarbetar-ID”), utöver det niosiffriga numret.For example, to increase the likelihood of identifying content that contains an employee ID, you can define another pattern that also identifies a hire date, and define yet another pattern that identifies both a hire date and a keyword (such as "employee ID"), in addition to the nine-digit number.

Diagram över en entitet med flera mönster

Observera några viktiga aspekter av den här strukturen:Note a couple of important aspects of this structure:

  • Mönster som kräver fler bevis har högre konfidensnivå.Patterns that require more evidence have a higher confidence level. Du kan ha nytta av detta senare när du använder den här typen av känslig information i en princip då du kan använda mer begränsande åtgärder (till exempel blockera innehåll) med endast matchningar med högre säkerhet och du kan använda mindre begränsande åtgärder (till exempel skicka meddelande) med matchningar med lägre säkerhet.This is useful because when you later use this sensitive information type in a policy, you can use more restrictive actions (such as block content) with only the higher-confidence matches, and you can use less restrictive actions (such as send notification) with the lower-confidence matches.

  • Stödelementen IdMatch och Match refererar till regex och nyckelord som är underordnade Rules-elementet, inte Pattern-elementet.The supporting IdMatch and Match elements reference regexes and keywords that are actually children of the Rule element, not the Pattern. De här stödelementen refereras till av Pattern-elementet men tas med i Rules-elementet.These supporting elements are referenced by the Pattern but included in the Rule. Det innebär att en enda definition av ett stödelement, till exempel ett reguljärt uttryck eller en nyckelordslista, kan refereras till av flera entiteter och mönster.This means that a single definition of a supporting element, like a regular expression or a keyword list, can be referenced by multiple entities and patterns.

Vilken entitet behöver du identifiera?What entity do you need to identify? [elementet Entity, attributet id][Entity element, id attribute]

En entitet är en typ av känslig information, till exempel kreditkortsnummer, som har ett väldefinierat mönster.An entity is a sensitive information type, such as a credit card number, that has a well-defined pattern. Varje entitet har ett unikt GUID som ID.Each entity has a unique GUID as its ID.

Namnge entiteten och generera dess GUIDName the entity and generate its GUID

  1. Lägg till elementen Rules och Entity i valfri XML-redigerare.In your XML editor of choice, add the Rules and Entity elements.
  2. Lägg till en kommentar som innehåller namnet på ditt anpassade entitet – i det här exemplet Employee ID (medarbetar-ID).Add a comment that contains the name of your custom entity — in this example, Employee ID. Senare lägger du till entitetsnamnet i avsnittet för lokaliserade strängar. Det namnet visas i användargränssnittet när du skapar en princip.Later, you'll add the entity name to the localized strings section, and that name is what appears in the UI when you create a policy.
  3. Generera ett GUID för entiteten.Generate a GUID for your entity. Det finns flera sätt att generera GUID. Ett enkelt sätt är att skriva [guid]::NewGuid() i PowerShell.There are several ways to generate GUIDs, but you can do it easily in PowerShell by typing [guid]::NewGuid(). Senare lägger du även till GUID för entiteten i avsnittet för lokaliserade strängar.Later, you'll also add the entity GUID to the localized strings section.

XML-kod som visar elementen Rules och Entity

Vilket mönster vill du matcha?What pattern do you want to match? [elementet Pattern, elementet IdMatch, elementet Regex][Pattern element, IdMatch element, Regex element]

Mönstret innehåller en lista över vad typen av känslig information söker efter.The pattern contains the list of what the sensitive information type is looking for. Det kan vara regex, nyckelord och inbyggda funktioner (som utför uppgifter som att köra regex för att hitta datum eller adresser).This can include regexes, keywords, and built-in functions (which perform tasks like running regexes to find dates or addresses). Typer av känslig information kan ha flera mönster med unika konfidenser.Sensitive information types can have multiple patterns with unique confidences.

Gemensamt för alla mönster nedan är att de refererar till samma reguljära uttryck, som söker efter ett niosiffrigt nummer (\d{9}) omgivet av tomt utrymme (\s) …What all of the below patterns have in common is that they all reference the same regular expression, which looks for a nine-digit number (\d{9}) surrounded by white space (\s) … (\s).(\s). Det här reguljära uttrycket refereras av IdMatch-elementet och är det vanliga kravet för alla mönster som letar efter entiteten Employee ID (medarbetar-ID).This regular expression is referenced by the IdMatch element and is the common requirement for all patterns that look for the Employee ID entity. IdMatch är identifieraren som mönstret försöker matcha, till exempel medarbetar-ID, kreditkortsnummer eller personnummer.IdMatch is the identifier that the pattern is to trying to match, such as Employee ID or credit card number or social security number. Ett Pattern-element måste ha exakt ett IdMatch-element.A Pattern element must have exactly one IdMatch element.

XML-kod med flera Pattern-element som refererar till ett Regex-element

Om mönstret uppfylls returneras ett antal och konfidensnivån, som du kan använda i villkoren i din princip.When satisfied, a pattern returns a count and confidence level, which you can use in the conditions in your policy. När du lägger till ett villkor för att identifiera en typ av känslig information i en princip kan du redigera antalet och konfidensnivån på det sätt som visas här.When you add a condition for detecting a sensitive information type to a policy, you can edit the count and confidence level as shown here. Konfidensnivån (kallas även matchningsnoggrannhet) förklaras senare i det här avsnittet.Confidence level (also called match accuracy) is explained later in this topic.

Alternativ för antal instanser och matchningsnoggrannhet

När du skapar ett reguljärt uttryck finns det möjliga problem som du bör känna till.When you create your regular expression, keep in mind that there are potential issues to be aware of. Om du till exempel skriver och laddar upp en regex som identifierar för mycket innehåll kan det påverka prestanda.For example, if you write and upload a regex that identifies too much content, this can impact performance. Mer information om möjliga problem finns i avsnittet Möjliga verifieringsproblem som du bör känna till.To learn more about these potential issues, see the later section Potential validation issues to be aware of.

Vill du kräva ytterligare bevis?Do you want to require additional evidence? [elementet Match, attributet minCount][Match element, minCount attribute]

Förutom IdMatch kan ett mönster använda elementet Match för att kräva ytterligare bevis, till exempel nyckelord, regex, datum eller adress.In addition to the IdMatch, a pattern can use the Match element to require additional supporting evidence, such as a keyword, regex, date, or address.

Ett mönster kan innehålla flera Match-element. De kan tas med direkt i Pattern-elementet eller kombineras med hjälp av elementet Any.A Pattern can include multiple Match elements; they can be included directly in the Pattern element or combined by using the Any element. Match-element sammanfogas av en implicit OCH-operator. Alla Match-element måste vara uppfyllda för att mönstret ska matchas.Match elements are joined by an implicit AND operator; all Match elements must be satisfied for the pattern to be matched. Du kan använda elementet Any till att introducera OCH- eller ELLER-operatorer (mer om det i ett senare avsnitt).You can use the Any element to introduce AND or OR operators (more on that in a later section).

Du kan använda det valfria attributet minCount till att ange hur många instanser av en matchning som behöver hittas för varje Match-element.You can use the optional minCount attribute to specify how many instances of a match need to be found for each of the Match elements. Du kan till exempel ange att ett mönster bara är uppfyllt när minst två nyckelord från en nyckelordslista hittas.For example, you can specify that a pattern is satisfied only when at least two keywords from a keyword list are found.

XML-kod som visar Match-element med attribut för minOccurs

Nyckelord [elementen Keyword, Group och Term elements, attributen matchStyle och caseSensitive]Keywords [Keyword, Group, and Term elements, matchStyle and caseSensitive attributes]

När du identifierar känslig information, t.ex. medarbetar-ID, är det vanligt att kräva nyckelord som samarbetsbevis.When you identify sensitive information, like an employee ID, you often want to require keywords as corroborative evidence. Förutom att matcha ett niosiffrigt nummer kanske du vill söka efter ord som ”kort”, ”bricka” eller ”ID”.For example, in addition to matching a nine-digit number, you may want to look for words like "card", "badge", or "ID". Det gör du med hjälp av elementet Keyword.To do this, you use the Keyword element. Keyword-elementet har ett ID-attribut som kan refereras av flera Match-element i flera mönster eller entiteter.The Keyword element has an ID attribute that can be referenced by multiple Match elements in multiple patterns or entities.

Keyword-element ingår som en lista över Term-element i ett Group-element.Keywords are included as a list of Term elements in a Group element. Group-elementet har ett matchStyle-attribut med två möjliga värden:The Group element has a matchStyle attribute with two possible values:

  • matchStyle="word" Word-matchningen identifierar hela ord omgivna av tomt utrymme eller andra avgränsare.matchStyle="word" Word match identifies whole words surrounded by white space or other delimiters. Du bör alltid använda ”word” om du inte behöver matcha delar av ord eller matcha ord på asiatiska språk.You should always use word unless you need to match parts of words or match words in Asian languages.

  • matchStyle="string" identifierar strängar oavsett vad de omges av.matchStyle="string" String match identifies strings no matter what they're surrounded by. "id" matchar till exempel "sida" och "idé".For example, "id" will match "bid" and "idea". Använd ”string” endast när du behöver matcha asiatiska ord eller om ditt nyckelord kan ingå som en del av andra strängar.Use string only when you need to match Asian words or if your keyword may be included as part of other strings.

Slutligen kan du använda attributet CaseSensitive för Term-elementet för att ange att innehållet måste matcha nyckelordet exakt, inklusive gemener och versaler.Finally, you can use the caseSensitive attribute of the Term element to specify that the content must match the keyword exactly, including lower- and upper-case letters.

XML-kod som visar Match-element som refererar till nyckelord

Reguljära uttryck [elementet Regex]Regular expressions [Regex element]

I det här exemplet använder employee ID-entiteten redan elementet IdMatch för att referera till ett regex för mönstret, dvs. ett niosiffrigt nummer omgivet av tomt utrymme.In this example, the employee ID entity already uses the IdMatch element to reference a regex for the pattern — a nine-digit number surrounded by whitespace. Ett mönster kan dessutom använda ett Match-element för att referera till ett ytterligare Regex-element för att identifiera samarbetsbevis, till exempel ett fem- eller niosiffrigt nummer i ett amerikanskt postnummerformat.In addition, a pattern can use a Match element to reference an additional Regex element to identify corroborative evidence, such as a five- or nine-digit number in the format of a US zip code.

Ytterligare mönster, till exempel datum eller adresser [inbyggda funktioner]Additional patterns such as dates or addresses [built-in functions]

Utöver de inbyggda typerna av känslig information, kan typer av känslig information även använda inbyggda funktioner som kan identifiera samarbetsbevis, till exempel ett amerikanskt datum, ett utgångsdatum eller en adress i USA.In addition to the built-in sensitive information types, sensitive information types can also use built-in functions that can identify corroborative evidence such as a US date, EU date, expiration date, or US address. Microsoft 365 stöder inte uppladdning av egna anpassade funktioner, men när du skapar en anpassad typ av känslig information kan entiteten referera till de inbyggda funktionerna.Microsoft 365 does not support uploading your own custom functions, but when you create a custom sensitive information type, your entity can reference the built-in functions.

På ett id-kort för personal (”employee ID badge”) finns ett anställningsdatum, så den anpassade entiteten kan använda den inbyggda funktionen Func_us_date för att identifiera ett datum i det format som vanligtvis används i USA.For example, an employee ID badge has a hire date on it, so this custom entity can use the built-in function Func_us_date to identify a date in the format commonly used in the US.

Mer information finns i Vad DLP-funktionerna letar efter.For more information, see What the DLP functions look for.

XML-kod som visar Match-element som refererar till en inbyggd funktion

Olika kombinationer av bevis [elementet Any, attributen minMatches och maxMatches]Different combinations of evidence [Any element, minMatches and maxMatches attributes]

I ett Pattern-element är alla IdMatch- och Match-element sammanfogade av en implicit AND-operator och alla matchningar måste uppfyllas innan mönstret kan uppfyllas.In a Pattern element, all IdMatch and Match elements are joined by an implicit AND operator — all of the matches must be satisfied before the pattern can be satisfied. Men du kan skapa en mer flexibel matchningslogik genom att gruppera Match-element med elementet Any.However, you can create more flexible matching logic by using the Any element to group Match elements. Med elementet Any kan du till exempel matcha alla, inga eller en exakt delmängd av dess underordnade Match-element.For example, you can use the Any element to match all, none, or an exact subset of its children Match elements.

Elementet Any har valfria minMatches- och maxMatches-attribut som du kan använda till att definiera hur många av de underordnade Match-elementen som behöver uppfyllas innan mönstret matchas.The Any element has optional minMatches and maxMatches attributes that you can use to define how many of the children Match elements must be satisfied before the pattern is matched. Observera att dessa attribut definierar antalet Match-element som måste uppfyllas, inte antalet instanser av bevis som hittas för matchningarna.Note that these attributes define the number of Match elements that must be satisfied, not the number of instances of evidence found for the matches. Om du vill definiera ett minsta antal instanser för en viss matchning, till exempel två nyckelord från en lista använder du attributet minCount för ett Match-element (se ovan).To define a minimum number of instances for a specific match, such as two keywords from a list, use the minCount attribute for a Match element (see above).

Matcha minst ett underordnat Match-elementMatch at least one child Match element

Om du vill kräva att ett minsta antal Match-element måste uppfyllas kan du använda attributet minMatches.If you want to require that only a minimum number of Match elements must be met, you can use the minMatches attribute. I praktiken är dessa Match-element sammanfogade av en implicit ELLER-operator.In effect, these Match elements are joined by an implicit OR operator. Ett Any-element uppfylls om ett datum i amerikanskt format eller ett nyckelord i någon av listorna hittas.This Any element is satisfied if a US-formatted date or a keyword from either list is found.

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

Matcha en exakt delmängd av underordnade Match-elementMatch an exact subset of any children Match elements

Om du vill kräva att ett exakt antal Match-element måste uppfyllas kan du ange samma värde för minMatches och maxMatches.If you want to require that an exact number of Match elements must be met, you can set minMatches and maxMatches to the same value. Det här Any-elementet uppfylls bara om exakt ett datum eller nyckelord hittas – om fler hittas matchas inte mönstret.This Any element is satisfied only if exactly one date or keyword is found — any more than that, and the pattern won't be matched.

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

Matcha inget av underordnade Match-elementMatch none of children Match elements

Om du vill kräva att specifika bevis inte får finnas för att ett mönster ska uppfyllas kan du ange värdet 0 för både minMatches och maxMatches.If you want to require the absence of specific evidence for a pattern to be satisfied, you can set both minMatches and maxMatches to 0. Det kan vara användbart om du har en nyckelordslista eller andra bevis som troligen ger en falsk positiv identifiering.This can be useful if you have a keyword list or other evidence that are likely to indicate a false positive.

Entiteten employee ID (medarbetar-ID) letar till exempel efter nyckelordet ”card” (kort) eftersom det kan referera till ett ”ID card” (ID-kort).For example, the employee ID entity looks for the keyword "card" because it might refer to an "ID card". Men om ”card” endast förekommer i frasen ”credit card” (kreditkort) är det inte sannolikt att “card” i det här innehållet betyder “ID card”.However, if card appears only in the phrase "credit card", "card" in this content is unlikely to mean "ID card". Du kan alltså lägga till ”credit card” som ett nyckelord i en lista med termer som inte får finnas för att mönstret ska uppfyllas.So you can add "credit card" as a keyword to a list of terms that you want to exclude from satisfying the pattern.

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

Matcha ett antal unika termerMatch a number of unique terms

Om du vill matcha ett antal unika termer använder du parametern uniqueResults inställd på true, som i följande exempel:If you want to match a number of unique terms, use the uniqueResults parameter, set to true, as shown in the following example:

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

I det här exemplet definieras ett mönster för lönerevision med minst tre unika matchningar.In this example, a pattern is defined for salary revision using at least three unique matches.

Hur nära entiteten måste det andra beviset vara?How close to the entity must the other evidence be? [attributet patternsProximity][patternsProximity attribute]

Din typ av känslig information letar efter ett mönster som representerar ett medarbetar-ID, och som en del i mönstret letar den även efter samarbetsbevis, till exempel ett nyckelord som ”ID”.Your sensitive information type is looking for a pattern that represents an employee ID, and as part of that pattern it's also looking for corroborative evidence like a keyword such as "ID". Det är logiskt att ju närmare detta bevis är, desto troligare är det att mönstret är ett faktiskt medarbetar-ID.It makes sense that the closer together this evidence is, the more likely the pattern is to be an actual employee ID. Du kan ange hur nära andra bevis i mönstret måste vara i förhållande till entiteten med hjälp av det obligatoriska attributet patternsProximity i elementet Entity.You can determine how close other evidence in the pattern must be to the entity by using the required patternsProximity attribute of the Entity element.

XML-kod med attributet patternsProximity

För varje mönster i entiteten definierar värdet för attributet patternsProximity avståndet (i Unicode-tecken) från platsen för IdMatch för alla andra Match-element som angetts för mönstret.For each pattern in the entity, the patternsProximity attribute value defines the distance (in Unicode characters) from the IdMatch location for all other Matches specified for that Pattern. Närhetsfönstret är förankrat vid IdMatch-platsen, och fortsätter till vänster och höger om IdMatch.The proximity window is anchored by the IdMatch location, with the window extending to the left and right of the IdMatch.

Diagram över närhetsfönster

Exemplet nedan visar hur närhetsfönstret påverkar mönstermatchningen där elementet IdMatch för den anpassade entiteten medarbetar-ID kräver minst en samarbetsmatchning av nyckelord eller datum.The example below illustrates how the proximity window affects the pattern matching where IdMatch element for the employee ID custom entity requires at least one corroborating match of keyword or date. Endast ID1 matchar eftersom inget eller bara delvisa samarbetsbevis hittas för ID2 och ID3 inom närhetsfönstret.Only ID1 matches because for ID2 and ID3, either no or only partial corroborating evidence is found within the proximity window.

Diagram över samarbetsbevis och närhetsfönster

Observera att för e-post behandlas meddelandetexten och varje bifogad fil som separata objekt.Note that for email, the message body and each attachment are treated as separate items. Det innebär att närhetsfönstret inte fortsätter utanför slutet av de här objekten.This means that the proximity window does not extend beyond the end of each of these items. Både idMatch och samarbetsbevis måste finnas i varje objekt (bifogad fil eller brödtext).For each item (attachment or body), both the idMatch and corroborative evidence needs to reside in that item.

Vad är rätt konfidensnivåer för olika mönster?What are the right confidence levels for different patterns? [attributet confidenceLevel, attributet recommendedConfidence][confidenceLevel attribute, recommendedConfidence attribute]

Ju mer bevis ett mönster kräver, desto större blir konfidensen att en faktisk entitet (till exempel ett medarbetar-ID) har identifierats när mönstret matchas.The more evidence that a pattern requires, the more confidence you have that an actual entity (such as employee ID) has been identified when the pattern is matched. Du har till exempel mer konfidens i ett mönster som kräver ett niosiffrigt ID-nummer, anställningsdatum och nyckelord i närheten än i ett mönster som endast kräver ett niosiffrigt ID-nummer.For example, you have more confidence in a pattern that requires a nine-digit ID number, hire date, and keyword in close proximity, than you do in a pattern that requires only a nine-digit ID number.

Pattern-elementet har ett obligatoriskt confidenceLevel-attribut.The Pattern element has a required confidenceLevel attribute. Du kan tänka på värdet för confidenceLevel (ett heltal mellan 1 och 100) som ett unikt ID för varje mönster i en entitet – mönster i en entitet måste ha olika konfidensnivåer, som du tilldelar.You can think of the value of confidenceLevel (an integer between 1 and 100) as a unique ID for each pattern in an entity — the patterns in an entity must have different confidence levels that you assign. Det exakta värdet för heltalet spelar ingen roll. Välj bara ett värde som är logiskt för ditt efterlevnadsteam.The precise value of the integer doesn't matter — simply pick numbers that make sense to your compliance team. När du har laddat upp din anpassade typ av känslig information och sedan skapar en princip kan du referera till dessa konfidensnivåer i villkoren i den regel som du skapar.After you upload your custom sensitive information type and then create a policy, you can reference these confidence levels in the conditions of the rules that you create.

XML-kod som visar Pattern-element med olika värden för attributet confidenceLevel

Utöver confidenceLevel för varje mönster har entiteten också ett recommendedConfidence-attribut.In addition to confidenceLevel for each Pattern, the Entity has a recommendedConfidence attribute. Det rekommenderade konfidensattributet kan ses som standardkonfidensnivå för regeln.The recommended confidence attribute can be thought of as the default confidence level for the rule. Om du inte anger en konfidensnivå för en regel när du skapar regeln i en princip utförs matchningen av regeln baserat på den rekommenderade konfidensnivån för entiteten.When you create a rule in a policy, if you don't specify a confidence level for the rule to use, that rule will match based on the recommended confidence level for the entity. Observera att attributet recommendedConfidence är obligatoriskt för varje entitets-ID i regelpaketet. Om det saknas kan du inte spara principer som använder typen av känslig information.Please note that the recommendedConfidence attribute is mandatory for each Entity ID in the Rule Package, if missing you won't be able to save policies that use the Sensitive Information Type.

Vill du använda andra språk i användargränssnittet i efterlevnadscentret?Do you want to support other languages in the UI of the Compliance center? [elementet LocalizedStrings][LocalizedStrings element]

Om ditt efterlevnadsteam använder Microsoft 365 Efterlevnadscenter för att skapa principer på olika språk kan du tillhandahålla lokaliserade versioner av namnet och beskrivningen av din anpassade typ av känslig information.If your compliance team uses the Microsoft 365 Compliance center to create polices policies in different locales and in different languages, you can provide localized versions of the name and description of your custom sensitive information type. När efterlevnadsteamet använder Microsoft 365 på ett språk som du stöder ser de det lokaliserade namnet i användargränssnittet.When your compliance team uses Microsoft 365 in a language that you support, they'll see the localized name in the UI.

Alternativ för antal instanser och matchningsnoggrannhet

Elementet Rules måste innehålla ett localizedStrings-element som innehåller ett Resource-element som refererar till GUID för din anpassade entitet.The Rules element must contain a LocalizedStrings element, which contains a Resource element that references the GUID of your custom entity. I sin tur innehåller varje Resource-element ett eller flera namn- och beskrivningselement som vart och ett använder attributet langcode för att tillhandahålla en lokaliserad sträng för ett visst språk.In turn, each Resource element contains one or more Name and Description elements that each use the langcode attribute to provide a localized string for a specific language.

XML-kod som visar innehållet i elementet LocalizedStrings

Observera att de lokaliserade strängarna endast påverkar hur din anpassade typ av känslig information visas i användargränssnittet i efterlevnadscentret.Note that you use localized strings only for how your custom sensitive information type appears in the UI of the Compliance center. Du kan inte använda lokaliserade strängar för att tillhandahålla olika lokaliserade versioner av en nyckelordslista eller ett reguljärt uttryck.You can't use localized strings to provide different localized versions of a keyword list or regular expression.

Annan regelpaketkod [RulePack GUID]Other rule package markup [RulePack GUID]

I början av varje RulePackage finns viss allmän information som du behöver fylla i.Finally, the beginning of each RulePackage contains some general information that you need to fill in. Du kan använda följande kod som mall och ersätta platshållarna ".You can use the following markup as a template and replace the ". .. ."." med egen information.placeholders with your own info.

Det viktigaste är att du skapar ett GUID för RulePack.Most importantly, you'll need to generate a GUID for the RulePack. Ovan genererade du ett GUID för entiteten. Detta är ett andra GUID för RulePack.Above, you generated a GUID for the entity; this is a second GUID for the RulePack. Det finns flera sätt att generera GUID. Ett enkelt sätt är att skriva [guid]::NewGuid() i PowerShell.There are several ways to generate GUIDs, but you can do it easily in PowerShell by typing [guid]::NewGuid().

Versionselementet är också viktigt.The Version element is also important. När du laddar upp regelpaketet för första gången registrerar Microsoft 365 versionsnumret.When you upload your rule package for the first time, Microsoft 365 notes the version number. Om du uppdaterar regelpaketet senare och laddar upp en ny version måste du uppdatera versionsnumret, annars distribuerar Microsoft 365 inte regelpaketet.Later, if you update the rule package and upload a new version, make sure to update the version number or Microsoft 365 won't deploy the rule package.

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

När allt är klart bör ditt RulePack-element se ut så här.When complete, your RulePack element should look like this.

XML-kod som visar RulePack-elementet

Ändringar för Exchange OnlineChanges for Exchange Online

Tidigare kanske du använde Exchange Online PowerShell för att importera anpassade typer av känslig information för DLP.Previously, you might have used Exchange Online PowerShell to import your custom sensitive information types for DLP. Nu kan dina anpassade typer av känslig information användas i både administrationscentret för Exchange och i efterlevnadscentret.Now your custom sensitive information types can be used in both the Exchange admin center and the Compliance center. Som en del av den här förbättringen bör du använda Compliance Center PowerShell för att importera anpassade typer av känslig information – du kan inte importera dem från Exchange PowerShell längre.As part of this improvement, you should use Compliance center PowerShell to import your custom sensitive information types — you can't import them from the Exchange PowerShell anymore. Dina anpassade typer av känslig information fortsätter att fungera som vanligt, men det kan ta upp till en timme innan ändringar av anpassade typer av känslig information som gjorts i efterlevnadscentret visas i administrationscentret för Exchange. Your custom sensitive information types will continue to work just like before; however, it may take up to one hour for changes made to custom sensitive information types in the Compliance center to appear in the Exchange admin center.

Observera att du kan ladda upp ett regelpaket med cmdleten New-DlpSensitiveInformationTypeRulePackage i efterlevnadscentret.Note that in the Compliance center, you use the New-DlpSensitiveInformationTypeRulePackage cmdlet to upload a rule package. (Tidigare kunde du använda cmdleten ClassificationRuleCollection i administrationscentret för Exchange.)(Previously, in the Exchange admin center, you used the ClassificationRuleCollection` cmdlet.)

Ladda upp regelpaketetUpload your rule package

Gör så här om du vill ladda upp regelpaketet:To upload your rule package, do the following steps:

  1. Spara det som en XML-fil med Unicode-kodning.Save it as an .xml file with Unicode encoding.

  2. Ansluta till Compliance Center PowerShellConnect to Compliance center PowerShell

  3. Använd följande syntax:Use the following syntax:

    New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "PathToUnicodeXMLFile" -Encoding Byte -ReadCount 0)
    

    I det här exemplet överförs Unicode XML-filen med namnet MyNewRulePack.xml från C:\My Documents.This example uploads the Unicode XML file named MyNewRulePack.xml from C:\My Documents.

    New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\My Documents\MyNewRulePack.xml" -Encoding Byte -ReadCount 0)
    

    Se New-DlpSensitiveInformationTypeRulePackage för detaljerad information om syntax och parametrar.For detailed syntax and parameter information, see New-DlpSensitiveInformationTypeRulePackage.

    Anteckning

    Det maximala antalet regelpaket som stöds är tio, men varje paket kan innehålla en definition för flera typer av känslig information.The maximum number of rule packages supported is 10, but each package can contain the definition of multiple sensitive information types.

  4. Gör något av följande för att kontrollera att du har skapat en ny typ av känslig information:To verify that you've successfully created a new sensitive information type, do any of the following steps:

    • Kör cmdleten Get-DlpSensitiveInformationTypeRulePackage och kontrollera att det nya regelpaketet visas:Run the Get-DlpSensitiveInformationTypeRulePackage cmdlet to verify the new rule package is listed:

      Get-DlpSensitiveInformationTypeRulePackage
      
    • Kör cmdleten Get-DlpSensitiveInformationType och kontrollera att typen av känslig information visas:Run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information type is listed:

      Get-DlpSensitiveInformationType
      

      För anpassade typer av känslig information är egenskapsvärdet för utgivare något annat än Microsoft Corporation.For custom sensitive information types, the Publisher property value will be something other than Microsoft Corporation.

    • Ersätt <Name> med namnvärdet för typen av känslig information (till exempel: medarbetar-ID) och kör cmdleten Get-DlpSensitiveInformationType:Replace <Name> with the Name value of the sensitive information type (example: Employee ID) and run the Get-DlpSensitiveInformationType cmdlet:

      Get-DlpSensitiveInformationType -Identity "<Name>"
      

Möjliga verifieringsproblem som du bör känna tillPotential validation issues to be aware of

När du laddar upp din XML-fil för regelpaket verifierar systemet XML-koden och söker efter kända felaktiga mönster och tydliga prestandaproblem.When you upload your rule package XML file, the system validates the XML and checks for known bad patterns and obvious performance issues. Här är några kända problem som verifieringen söker efter – ett reguljärt uttryck:Here are some known issues that the validation checks for — a regular expression:

  • Kan inte börja eller sluta med ”|”, som matchar allt eftersom den betraktas som en tom matchning.Cannot begin or end with alternator "|", which matches everything because it's considered an empty match.

    Till exempel godkänns inte ”|a” eller ”b|”.For example, "|a" or "b|" will not pass validation.

  • Kan inte börja eller sluta med ett ”.{0,m}”-mönster, som inte har något funktionssyfte utan bara försämrar prestanda.Cannot begin or end with a ".{0,m}" pattern, which has no functional purpose and only impairs performance.

    Till exempel godkänns inte ”.{0,50}ASDF” eller ”ASDF.{0,50}”.For example, ".{0,50}ASDF" or "ASDF.{0,50}" will not pass validation.

  • Kan inte ha ”.{0,m}” eller ”.{1,m}” i grupper, och kan inte ha ”.*” eller ”.+” i grupper.Cannot have ".{0,m}" or ".{1,m}" in groups, and cannot have ".*" or ".+" in groups.

    Till exempel godkänns inte ”(.{0,50000})”.For example, "(.{0,50000})" will not pass validation.

  • Kan inte ha något tecken med ”{0,m}”- eller ”{1,m}”-repeaters i grupper.Cannot have any character with "{0,m}" or "{1,m}" repeaters in groups.

    Till exempel godkänns inte ” (a*)”.For example, "(a*)" will not pass validation.

  • Kan inte börja eller sluta med ”. {1,m}”. I stället använder du bara ”.”.Cannot begin or end with ".{1,m}"; instead, use just "."

    Till exempel godkänns inte ”.{1,m}asdf”. I stället använder du bara ”.asdf”.For example, ".{1,m}asdf" will not pass validation; instead, use just ".asdf".

  • Kan inte ha en obunden repeater (till exempel ”*” eller ”+”) i en grupp.Cannot have an unbounded repeater (such as "*" or "+") on a group.

    Till exempel godkänns inte ”(xx)*” och ”(xx)+”.For example, "(xx)*" and "(xx)+" will not pass validation.

  • Nyckelorden får vara högst 50 tecken långa.Keywords have a maximum of 50 characters in Length. Om du ett nyckelord i en grupp som överskrider den här gränsen föreslår vi att du skapar en grupp med termer, till exempel en nyckelordsordlista och refererar till GUID för nyckelordsordlistan i XML-strukturen som en del i entiteten för Match eller idMatch i filen.If you have a keyword within a Group exceeding this, a suggested solution is to create the Group of terms as a Keyword Dictionary and reference the GUID of the Keyword Dictionary within the XML structure as part of the Entity for Match or idMatch in the file.

  • Varje anpassad typ av känslig information kan innehålla maximalt 2 048 nyckelord.Each Custom Sensitive Information Type can have a maximum of 2048 keywords total.

  • Den maximala storleken på nyckelordsordlistor i en enskild klientorganisation är 1 MB komprimerad.The maximum size of Keyword Dictionaries in a single tenant is 1 MB compressed. Du kan referera till samma ordlista så många gånger som behövs när du skapar anpassade typer av känslig information.Reference the same dictionary as many times as necessary when creating custom sensitive information types. Börja med att skapa anpassade nyckelordslistor i typen av känslig information och använd nyckelordsordlistor om du har fler än 2 048 nyckelord i en nyckelordslista eller om ett nyckelord är längre än 50 tecken.Start with creating custom keyword lists in the sensitive information type and use keyword dictionaries if you have more than 2048 keywords in a keyword list or a keyword is larger than 50 characters in length.

  • Högst 50 nyckelordsordlistebaserade typer av känslig information tillåts i en klientorganisation.A maximum of 50 keyword dictionary based sensitive information types are allowed in a tenant.

  • Kontrollera att varje Entity-element innehåller ett recommendedConfidence-attribut.Ensure each Entity element contains a recommendedConfidence attribute.

  • När du använder PowerShell-cmdleten finns en maximal returstorlek för deserialiserade data på ungefär 1 MB.When using the PowerShell Cmdlet there is a maximum return size of the Deserialized Data of approximately 1 megabyte. Det här påverkar storleken på XML-filen för regelpaketet.This will affect the size of your rule pack XML file. Vi föreslår att du begränsar den uppladdade filen till högst 770 kB så att du får konsekventa resultat utan fel vid bearbetningen.Keep the uploaded file limited to a 770 kilobyte maximum as a suggested limit for consistent results without error when processing.

  • XML-strukturen kräver inte formateringstecken som blanksteg, tabbar eller poster för vagnretur/radmatning.The XML structure does not require formatting characters such as spaces, tabs, or carriage return/linefeed entries. Tänk på det när du optimerar utrymme för uppladdningar.Take note of this when optimizing for space on uploads. Verktyg som Microsoft Visual Code tillhandahåller kopplingslinjefunktioner för att komprimera XML-filen.Tools such as Microsoft Visual Code provide join line features to compact the XML file.

Om en anpassad typ av känslig information innehåller ett problem som kan påverka prestanda laddas den inte upp och något av följande felmeddelanden visas:If a custom sensitive information type contains an issue that may affect performance, it won't be uploaded and you may see one of these error messages:

  • Allmänna kvantifierare som matchar mer innehåll än förväntat (t.ex. ”+”, ”*”)Generic quantifiers which match more content than expected (e.g., '+', '*')

  • Påståenden för sökningLookaround assertions

  • Komplex gruppering tillsammans med allmänna kvantifierareComplex grouping in conjunction with general quantifiers

Du måste crawla innehållet igen för att identifiera känslig informationRecrawl your content to identify the sensitive information

I Microsoft 365 används Search Crawler för att identifiera och klassificera känslig information i webbplatsinnehåll.Microsoft 365 uses the search crawler to identify and classify sensitive information in site content. Innehållet i SharePoint Online- och OneDrive för företag-webbplatserna crawlas igen automatiskt när det uppdateras.Content in SharePoint Online and OneDrive for Business sites is recrawled automatically whenever it's updated. Men för att identifiera den nya anpassade typen av känslig information i allt befintligt innehåll måste innehållet crawlas på nytt.But to identify your new custom type of sensitive information in all existing content, that content must be recrawled.

I Microsoft 365 kan du inte begära en ny crawlning av en hel klientorganisation manuellt, men du kan göra det för en webbplatssamling, en lista eller ett bibliotek. Se Manuellt begära crawlning och omindexering av en webbplats, ett bibliotek eller en lista.In Microsoft 365, you can't manually request a recrawl of an entire tenant, but you can do this for a site collection, list, or library — see Manually request crawling and re-indexing of a site, a library or a list.

Ta bort en anpassad typ av känslig informationRemove a custom sensitive information type

Anteckning

Innan du tar bort en anpassad typ av känslig information ska du kontrollera att inga DLP-principer eller e-postflödesregler i Exchange (kallas även transportregler) fortfarande refererar till den typ av känslig information som finns.Before your remove a custom sensitive information type, verify that no DLP policies or Exchange mail flow rules (also known as transport rules) still reference the sensitive information type.

Det finns två sätt att ta bort anpassade typer av känslig information i Compliance Center PowerShell:In Compliance center PowerShell, there are two methods to remove custom sensitive information types:

  • Ta bort enskilda anpassade typer av känslig information: Använd den metod som beskrivs i Ändra en anpassad typ av känslig information.Remove individual custom sensitive information types: Use the method documented in Modify a custom sensitive information type. Du kan exportera det anpassade regelpaketet som innehåller den anpassade typen av känslig information, ta bort typen av känslig information från XML-filen och importera den uppdaterade XML-filen tillbaka till det befintliga anpassade regelpaketet.You export the custom rule package that contains the custom sensitive information type, remove the sensitive information type from the XML file, and import the updated XML file back into the existing custom rule package.

  • Ta bort ett anpassat regelpaket och alla anpassade typer av känslig information som det innehåller: Den här metoden beskrivs i det här avsnittet.Remove a custom rule package and all custom sensitive information types that it contains: This method is documented in this section.

  1. Ansluta till Compliance Center PowerShellConnect to Compliance center PowerShell

  2. Om du vill ta bort ett anpassat regelpaket använder du cmdleten Remove-DlpSensitiveInformationTypeRulePackage:To remove a custom rule package, use the Remove-DlpSensitiveInformationTypeRulePackage cmdlet:

    Remove-DlpSensitiveInformationTypeRulePackage -Identity "RulePackageIdentity"
    

    Du kan använda namnvärdet (för vilket språk som helst) eller RulePack id-värdet (GUID) för att identifiera regelpaketet.You can use the Name value (for any language) or the RulePack id (GUID) value to identify the rule package.

    Det här exemplet tar bort regelpaketet med namnet ”Employee ID Custom Rule Pack”.This example removes the rule package named "Employee ID Custom Rule Pack".

    Remove-DlpSensitiveInformationTypeRulePackage -Identity "Employee ID Custom Rule Pack"
    

    Se Remove-DlpSensitiveInformationTypeRulePackage för detaljerad information om syntax och parametrar.For detailed syntax and parameter information, see Remove-DlpSensitiveInformationTypeRulePackage.

  3. Gör något av följande för att kontrollera att du har tagit bort en anpassad typ av känslig information:To verify that you've successfully removed a custom sensitive information type, do any of the following steps:

    • Kör cmdleten Get-DlpSensitiveInformationTypeRulePackage och kontrollera att regelpaketet inte längre visas:Run the Get-DlpSensitiveInformationTypeRulePackage cmdlet and verify the rule package is no longer listed:

      Get-DlpSensitiveInformationTypeRulePackage
      
    • Kör cmdleten Get-DlpSensitiveInformationType för att kontrollera att typerna av känslig information som ingick i det borttagna regelpaketet inte längre visas:Run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information types in the removed rule package are no longer listed:

      Get-DlpSensitiveInformationType
      

      För anpassade typer av känslig information är egenskapsvärdet för utgivare något annat än Microsoft Corporation.For custom sensitive information types, the Publisher property value will be something other than Microsoft Corporation.

    • Ersätt <Name> med namnvärdet för typen av känslig information (till exempel Employee ID (medarbetar-ID)) och kör cmdleten Get-DlpSensitiveInformationType för att kontrollera att typen av känslig information inte längre visas:Replace <Name> with the Name value of the sensitive information type (for example, Employee ID) and run the Get-DlpSensitiveInformationType cmdlet to verify the sensitive information type is no longer listed:

      Get-DlpSensitiveInformationType -Identity "<Name>"
      

Ändra en anpassad typ av känslig informationModify a custom sensitive information type

För att ändra en anpassad typ av känslig information i Compliance Center PowerShell måste du:In Compliance center PowerShell, modifying a custom sensitive information type requires you to:

  1. Exportera det befintliga regelpaketet som innehåller den anpassade typen av känslig information till en XML-fil (eller använda en befintlig XML-fil om du har en sådan).Export the existing rule package that contains the custom sensitive information type to an XML file (or use the existing XML file if you have it).

  2. Ändra den anpassade typen av känslig information i den exporterade XML-filen.Modify the custom sensitive information type in the exported XML file.

  3. Importera den uppdaterade XML-filen tillbaka till det befintliga regelpaketet.Import the updated XML file back into the existing rule package.

Information om hur du ansluter till Compliance Center PowerShell finns i Ansluta till Compliance Center PowerShell.To connect to Compliance Center PowerShell, see Connect to Compliance Center PowerShell.

Steg 1: Exportera det befintliga regelpaketet till en XML-filStep 1: Export the existing rule package to an XML file

Anteckning

Om du har en kopia av XML-filen (till exempel om du just har skapat och importerat den) kan du gå vidare till nästa steg och ändra XML-filen.If you have a copy of the XML file (for example, you just created and imported it), you can skip to the next step to modify the XML file.

  1. Om du inte redan visste det kan du köra cmdleten Get-DlpSensitiveInformationTypeRulePackage för att hitta namnet på det anpassade regelpaketet:If you don't already know it, run the Get-DlpSensitiveInformationTypeRulePackage cmdlet to find the name of the custom rule package:

    Get-DlpSensitiveInformationTypeRulePackage
    

    Anteckning

    Det inbyggda regelpaketet som innehåller de inbyggda typerna av känslig information heter Regelpaket för Microsoft.The built-in rule package that contains the built-in sensitive information types is named Microsoft Rule Package. Det regelpaket som innehåller anpassade typer av känslig information som du skapade i gränssnittet i efterlevnadscentret heter Microsoft.SCCManaged.CustomRulePack.The rule package that contains the custom sensitive information types that you created in the Compliance center UI is named Microsoft.SCCManaged.CustomRulePack.

  2. Använd cmdleten Get-DlpSensitiveInformationTypeRulePackage för att spara det anpassade regelpaketet i en variabel:Use the Get-DlpSensitiveInformationTypeRulePackage cmdlet to store the custom rule package to a variable:

    $rulepak = Get-DlpSensitiveInformationTypeRulePackage -Identity "RulePackageName"
    

    Om namnet på regelpaketet till exempel är "Employee ID Custom Rule Pack" kör du följande cmdlet:For example, if the name of the rule package is "Employee ID Custom Rule Pack", run the following cmdlet:

    $rulepak = Get-DlpSensitiveInformationTypeRulePackage -Identity "Employee ID Custom Rule Pack"
    
  3. Exportera det anpassade regelpaketet till en XML-fil med hjälp av cmdleten Set-Content:Use the Set-Content cmdlet to export the custom rule package to an XML file:

    Set-Content -Path "XMLFileAndPath" -Encoding Byte -Value $rulepak.SerializedClassificationRuleCollection
    

    I det här exemplet exporterar du regelpaketet till filen ExportedRulePackage.xml i mappen C:\My Documents.This example export the rule package to the file named ExportedRulePackage.xml in the C:\My Documents folder.

    Set-Content -Path "C:\My Documents\ExportedRulePackage.xml" -Encoding Byte -Value $rulepak.SerializedClassificationRuleCollection
    

Steg 2: Ändra typen av känslig information i den exporterade XML-filenStep 2: Modify the sensitive information type in the exported XML file

Typer av känslig information i XML-filen och andra element i filen beskrivs tidigare i det här avsnittet.Sensitive information types in the XML file and other elements in the file are described earlier in this topic.

Steg 3: Importera den uppdaterade XML-filen tillbaka till det befintliga regelpaketetStep 3: Import the updated XML file back into the existing rule package

Använd cmdleten Set-DlpSensitiveInformationTypeRulePackage för att importera den uppdaterade XML-filen tillbaka till det befintliga regelpaketet:To import the updated XML back into the existing rule package, use the Set-DlpSensitiveInformationTypeRulePackage cmdlet:

Set-DlpSensitiveInformationTypeRulePackage -FileData ([Byte[]]$(Get-Content -Path "C:\My Documents\External Sensitive Info Type Rule Collection.xml" -Encoding Byte -ReadCount 0))

Se Set-DlpSensitiveInformationTypeRulePackage för detaljerad information om syntax och parametrar.For detailed syntax and parameter information, see Set-DlpSensitiveInformationTypeRulePackage.

Referens: XML-schemadefinition för regelpaketReference: Rule package XML schema definition

Du kan kopiera den här koden, spara den som en XSD-fil och använda den för att verifiera XML-filen för regelpaketet.You can copy this markup, save it as an XSD file, and use it to validate your rule package XML file.

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

Mer informationMore information