Erstellen eines benutzerdefinierten vertraulichen Informationstyps

Die Verhinderung von Datenverlust (Data Loss Prevention, DLP) in Office 365 umfasst viele Typen vertraulicher Informationen, die in DLP-Richtlinien verwendet werden können. Diese integrierten Typen helfen beim Erkennen und Schützen von Kreditkartennummern, Bankkontonummern, Reisepassnummern und vielem mehr.

Wenn Sie aber einen anderen vertraulichen Informationstyp erkennen und schützen müssen – z. B. eine Mitarbeiter-ID in einem für Ihre Organisation spezifischen Format – können Sie einen benutzerdefinierten vertraulichen Informationstyp erstellen. Ein vertraulicher Informationstyp ist in einer XML-Datei definiert, die als Regelpaket bezeichnet wird.

In diesem Thema wird gezeigt, wie Sie eine XML-Datei erstellen, in der Ihr eigener benutzerdefinierter vertraulicher Informationstyp definiert ist. Sie müssen wissen, wie ein regulärer Ausdruck erstellt wird. In diesem Thema wird als Beispiel ein benutzerdefinierter vertraulicher Informationstyp erstellt, der eine Mitarbeiter-ID identifiziert. Sie können diese XML-Beispieldatei als Ausgangspunkt für Ihre eigene XML-Datei verwenden.

Nachdem Sie eine wohlgeformte XML-Datei erstellt haben, können Sie diese mithilfe von PowerShell nach Office 365 hochladen. Anschließend können Sie den benutzerdefinierten vertraulichen Informationstyp in Ihren DLP-Richtlinien verwenden und testen, ob die vertraulichen Informationen wie beabsichtigt erkannt werden.

Inhalt

XML-Beispieldatei für ein Regelpaket

Hier sehen Sie die XML-Beispieldatei für das Regelpaket, das in diesem Thema erstellt wird. Elemente und Attribute werden in den folgenden Abschnitten erläutert.

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

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

<Rules>
<!-- Employee ID -->
	<Entity id="E1CC861E-3FE9-4A58-82DF-4BD259EAB378" patternsProximity="300" recommendedConfidence="70">
		<Pattern confidenceLevel="60">
			<IdMatch idRef="Regex_employee_id"/>
		</Pattern>
		<Pattern confidenceLevel="70">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
		</Pattern>
		<Pattern confidenceLevel="80">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
			<Any minMatches="1">
				<Match idRef="Keyword_badge" minCount=”2”/>
				<Match idRef="Keyword_employee"/>
			</Any>
			<Any 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>
			<Name default="true" langcode="de-de">Name for German locale</Name>
			<Description default="true" langcode="de-de">
			Description for German locale.
			</Description>
		</Resource>
	</LocalizedStrings>
</Rules>
</RulePackage>

Was sind die wichtigsten Anforderungen? [Elemente "Rule", "Entity", "Pattern"]

Bevor Sie beginnen, sollten Sie die grundlegende Struktur des XML-Schemas für eine Regel kennen und wissen, wie Sie mithilfe dieser Struktur den benutzerdefinierten vertraulichen Informationstyp so definieren können, dass die richtigen Inhalte erkannt werden.

Eine Regel definiert eine oder mehrere Entitäten (vertrauliche Informationstypen), und jede Entität definiert ein oder mehrere Muster. Ein Muster ist das, wonach DLP bei der Auswertung von Inhalten wie E-Mails und Dokumenten sucht.

(Ein kurzer Hinweis zur Terminologie: Wenn Sie mit DLP-Richtlinien vertraut sind, wissen Sie, dass eine Richtlinie eine oder mehrere Regeln enthält, die sich aus Bedingungen und Aktionen zusammensetzen. In diesem Thema jedoch bezeichnet der Begriff Regel im Zusammenhang mit dem XML-Markup die Muster, die eine Entität definieren. Dies wird auch als vertraulicher Informationstyp bezeichnet. Wenn Sie also in diesem Thema das Wort Regel lesen, denken Sie an Entität oder vertraulichen Informationstyp und nicht an Bedingungen und Aktionen.)

Einfachstes Szenario: Entität mit einem Muster

Hier ist das einfachste Szenario. Mit Ihrer DLP-Richtlinie sollen Inhalte erkannt werden, die die Mitarbeiter-ID Ihrer Organisation enthalten, die als neunstellige Nummer formatiert ist. Das Muster verweist also auf einen regulären Ausdruck, der in der Regel enthalten ist und neunstellige Nummern erkennt. Jeder Inhalt, der eine neunstellige Nummer umfasst, entspricht dem Muster.

Entität mit einem einzigen Muster

Zwar ist dieses Muster einfach, doch kann es zu vielen falschen positiven Ergebnissen führen, da es Inhalte mit beliebigen neunstelligen Nummern abgleicht, bei denen es sich nicht zwangsläufig um eine Mitarbeiter-ID handeln muss.

Gebräuchlicheres Szenario: Entität mit mehreren Mustern

Aus diesem Grund wird eine Entität zumeist mithilfe mehrerer Muster definiert, wobei die Muster unterstützende Nachweise (z. B. ein Schlüsselwort oder Datum) zusätzlich zur Entität (z. B. eine neunstellige Nummer) angeben.

Um die Wahrscheinlichkeit zu erhöhen, dass Inhalte mit einer Mitarbeiter-ID erkannt werden, können Sie beispielsweise zusätzlich zur neunstelligen Nummer ein weiteres Muster definieren, das ein Einstellungsdatum identifiziert, und noch ein weiteres Muster definieren, das sowohl ein Einstellungsdatum als auch ein Schlüsselwort (z. B. "Mitarbeiter-ID") identifiziert.

Diagramm einer Entität mit mehreren Mustern

Beachten Sie einige wichtige Aspekte dieser Struktur:

  • Muster, die mehr Nachweise erfordern, weisen ein höheres Konfidenzniveau auf. Dies ist nützlich, denn wenn Sie später diesen vertraulichen Informationstyp in einer DLP-Richtlinie verwenden, können Sie restriktivere Aktionen (z. B. Inhalt blockieren) nur für Übereinstimmungen mit höherem Konfidenzniveau und weniger restriktive Aktionen (z. B. Benachrichtigung senden) für Übereinstimmungen mit geringerem Konfidenzniveau verwenden.

  • Die unterstützenden Elemente "IdMatch" und "Match" verweisen auf reguläre Ausdrücke und Schlüsselwörter, die tatsächlich untergeordnete Elemente des Elements "Rule" und nicht des Elements "Pattern" sind. Auf diese unterstützenden Elemente wird von "Pattern" Bezug genommen, sie sind aber in "Rule" enthalten. Das bedeutet, dass auf eine einzelne Definition eines unterstützenden Elements, z. B. einen regulären Ausdruck oder eine Schlüsselwortliste, von mehreren Entitäten und Mustern Bezug genommen werden kann.

Welche Entität muss erkannt werden? [Element "Entity", Attribut "id"]

Eine Entität ist ein vertraulicher Informationstyp (z. B. eine Kreditkartennummer), der ein klar definiertes Muster aufweist. Jede Entität hat eine eindeutige GUID als ID.

Benennen der Entität und Generieren der GUID

Fügen Sie die Elemente "Rules" und "Entity" hinzu. Dann fügen Sie einen Kommentar hinzu, der den Namen Ihrer benutzerdefinierten Entität enthält – in diesem Beispiel "Employee ID". Später fügen Sie den Entitätsnamen zum Abschnitt mit den lokalisierten Zeichenfolgen hinzu, und dieser Name wird beim Erstellen einer DLP-Richtlinie auf der Benutzeroberfläche angezeigt.

Als Nächstes generieren Sie eine GUID für die Entität. GUIDs können auf verschiedene Arten generiert werden, besonders einfach ist es aber in PowerShell. Dort müssen Sie nur [guid]::NewGuid() eingeben. Später fügen Sie auch die Entitäts-GUID zum Abschnitt mit den lokalisierten Zeichenfolgen hinzu.

XML-Markup mit den Elementen "Regeln" und "Entität"

Mit welchem Muster soll verglichen werden? [Element "Pattern", Element "IdMatch", Element "Regex"]

Das Muster enthält die Liste dessen, wonach der vertrauliche Informationstyp sucht. Dies kann reguläre Ausdrücke, Schlüsselwörter und integrierte Funktionen umfassen (die Aufgaben durchführen wie das Ausführen von regulären Ausdrücken zum Auffinden von Datumsangaben oder Adressen). Vertrauliche Informationstypen können mehrere Muster mit eindeutigen Konfidenzen aufweisen.

Allen folgenden Mustern ist gemeinsam, dass sie auf den gleichen regulären Ausdruck verweisen, mit dem nach einer neunstelligen Nummer (\d{9}) umgeben von Leerzeichen (\s) … (\s) gesucht wird. Auf diesen regulären Ausdruck wird vom Element "IdMatch" verwiesen, und er stellt die allgemeine Anforderung für alle Muster dar, mit denen nach der Entität "Employee ID" gesucht wird. "IdMatch" ist der Bezeichner, für den das Muster eine Übereinstimmung sucht, z. B. eine Mitarbeiter-ID, eine Kreditkartennummer oder eine Sozialversicherungsnummer. Ein Element "Pattern" muss genau ein Element "IdMatch" aufweisen.

XML-Markup mit mehreren "Muster"-Elementen, die auf ein einzelnes "Regex"-Element verweisen

Wenn eine Übereinstimmung gefunden wird, gibt ein Muster eine Anzahl und ein Konfidenzniveau zurück, die Sie in den Bedingungen Ihrer DLP-Richtlinie verwenden können. Wenn Sie eine Bedingung für das Erkennen eines vertraulichen Informationstyps zu einer DLP-Richtlinie hinzufügen, können Sie die Anzahl und das Konfidenzniveau bearbeiten, wie es hier gezeigt wird. Das Konfidenzniveau (auch als Übereinstimmungsgenauigkeit bezeichnet) wird weiter unten in diesem Thema erläutert.

Optionen "Instanzenzahl" und "Übereinstimmungsgenauigkeit"

Beachten Sie beim Erstellen des regulären Ausdrucks, dass potenzielle Probleme bestehen, deren Sie sich bewusst sein müssen. Wenn Sie beispielsweise einen regulären Ausdruck schreiben und hochladen, mit dem zu viel Inhalt erkannt wird, kann sich dies auf die Leistung auswirken. Weitere Informationen zu diesen potenziellen Problemen finden Sie im Abschnitt Mögliche Überprüfungsprobleme, die zu beachten sind weiter unten.

Sollen weitere Nachweise erforderlich sein? [Element "Match", Attribut "minCount"]

Zusätzlich zu "IdMatch" kann in einem Muster das Element "Match" verwendet werden, um zusätzliche unterstützende Nachweise anzufordern, z. B. ein Schlüsselwort, einen regulären Ausdruck, ein Datum oder eine Adresse.

Ein Muster kann mehrere "Match"-Elemente umfassen, die direkt im Element "Pattern" enthalten sein oder mithilfe des Elements "Any" kombiniert werden können. "Match"-Elemente werden mit einem impliziten AND-Operator verknüpft. Es müssen alle "Match"-Elemente erfüllt sein, damit eine Übereinstimmung mit dem Muster erkannt wird. Sie können das Element "Any" zum Einführen von AND- oder OR-Operatoren verwenden (weitere Informationen dazu sind in einem späteren Abschnitt enthalten).

Mit dem optionalen Attribut "minCount" können Sie angeben, wie viele Instanzen einer Übereinstimmung für jedes der "Match"-Elemente gefunden werden müssen. Sie können z. B. angeben, dass einem Muster nur dann entsprochen wird, wenn mindestens zwei Schlüsselwörter aus einer Schlüsselwortliste gefunden werden.

XML-Markup mit dem Element "Übereinstimmung" und dem Attribut "minVorkommen"

Schlüsselwörter [Elemente "Keyword", "Group" und "Term", Attribute "matchStyle" und "caseSensitive"]

Wenn Sie vertrauliche Informationen wie z. B. eine Mitarbeiter-ID identifizieren, sollen häufig Schlüsselwörter als bestätigende Nachweise erforderlich sein. Beispielsweise können Sie zusätzlich zur Übereinstimmung mit einer neunstelligen Nummer nach Wörtern wie "Karte", "Ausweis" oder "ID" suchen. Dazu verwenden Sie das Element "Keyword". Das Element "Keyword" verfügt über ein "id"-Attribut, auf das von mehreren "Match"-Elementen in mehreren Mustern oder Entitäten verwiesen werden kann.

Schlüsselwörter werden als eine Liste von "Term"-Elementen in ein "Group"-Element eingeschlossen. Das Element "Group" verfügt über ein "matchStyle"-Attribut mit zwei möglichen Werten:

  • matchStyle="word" Beim Abgleich vom Typ "word" werden ganze Wörter umgeben von Leerzeichen oder anderen Trennzeichen identifiziert. Sie sollten stets "word" verwenden, es sei denn, Sie müssen nach Übereinstimmungen mit Teilen von Wörtern oder Wörtern in asiatischen Sprachen suchen.

  • matchStyle="string" Beim Abgleich vom Typ "string" werden Zeichenfolgen ungeachtet der umgebenden Zeichen identifiziert. Beispielsweise ergibt "id" eine Übereinstimmung mit "Bid" und "idee". Verwenden Sie "string" nur, wenn Sie nach Übereinstimmungen mit Wörtern in asiatischen Sprachen suchen müssen oder wenn das Schlüsselwort als Teil anderer Zeichenfolgen enthalten sein kann.

Schließlich können Sie noch das Attribut "caseSensitive" des Elements "Term" verwenden, um anzugeben, dass der Inhalt exakt mit dem Schlüsselwort übereinstimmen muss, einschließlich Groß-und Kleinbuchstaben.

XML-Markup mit "Übereinstimmung"-Elementen, die auf Stichwörter verweisen

Reguläre Ausdrücke [Element "Regex"]

In diesem Beispiel verwendet die Entität der Mitarbeiter-ID bereits das Element "IdMatch" zum Verweisen auf einen regulären Ausdruck für das Muster – eine neunstellige Nummer umgeben von Leerzeichen. Darüber hinaus kann in einem Muster ein Element "Match" verwendet werden, um auf ein zusätzliches Element "Regex" zur Identifizierung bestätigender Nachweise zu verweisen, z. B. eine fünf- oder neunstellige Nummer im Format einer US-Postleitzahl.

Zusätzliche Muster wie Datumsangaben oder Adressen [integrierte Funktionen]

Zusätzlich zu den integrierten vertraulichen Informationstypen umfasst DLP auch integrierte Funktionen, mit denen bestätigende Nachweise wie ein US-Datum, EU-Datum, ein Ablaufdatum oder eine US-Adresse identifiziert werden können. DLP bietet keine Unterstützung für das Hochladen eigener benutzerdefinierter Funktionen, doch wenn Sie einen benutzerdefinierten vertraulichen Informationstyp erstellen, kann die Entität auf die integrierten Funktionen verweisen.

Wenn beispielsweise ein Mitarbeiterausweis ein Einstellungsdatum aufweist, kann diese benutzerdefinierte Entität die integrierte Funktion Func_us_date verwenden, um ein Datum in dem für die USA gebräuchlichen Format zu identifizieren.

Weitere Informationen finden Sie unter Wonach die DLP-Funktionen suchen.

XML-Markup mit dem Element "Übereinstimmung", das auf eine integrierte Funktion verweist

Verschiedene Kombinationen von Nachweisen [Element "Any", Attribute "minMatches" und "maxMatches"]

In einem "Pattern"-Element werden alle Elemente vom Typ "IdMatch" und "Match" durch einen impliziten AND-Operator verknüpft – es müssen alle Übereinstimmungen gegeben sein, bevor das Muster als erfüllt betrachtet wird. Allerdings können Sie eine flexiblere Abgleichlogik erstellen, indem Sie "Match"-Elemente mithilfe des Elements "Any" gruppieren. Mit dem Element "Any" können Sie beispielsweise einen Abgleich aller, keiner oder einer genauen Teilmenge der untergeordneten "Match"-Elemente vornehmen.

Das Element "Any" verfügt über die optionalen Attribute "minMatches" und "maxMatches", mit denen Sie festlegen können, wie viele der untergeordneten "Match"-Elemente erfüllt sein müssen, bevor eine Übereinstimmung mit dem Muster gegeben ist. Beachten Sie, dass diese Attribute die Anzahl von "Match"-Elementen definieren, die erfüllt sein müssen, und nicht die Anzahl von Instanzen gefundener Nachweise für die Übereinstimmungen. Wenn Sie eine Mindestanzahl von Instanzen für eine bestimmte Übereinstimmung definieren möchten, z. B. zwei Schlüsselwörter aus einer Liste, verwenden Sie das Attribut "minCount" für ein "Match"-Element (siehe oben).

Übereinstimmung mit mindestens einem untergeordneten "Match"-Element

Wenn Sie möchten, dass nur eine Mindestanzahl von "Match"-Elementen erfüllt sein muss, können Sie das Attribut "minMatches" verwenden. Diese "Match"-Elemente werden durch einen impliziten OR-Operator verknüpft. Dieses "Any"-Element ist erfüllt, wenn ein US-formatiertes Datum oder ein Schlüsselwort aus einer der Listen gefunden wird.

XML-Markup mit dem Element "Beliebig" und dem Attribut "minÜbereinstimmungen"

Übereinstimmung mit einer genauen Teilmenge von untergeordneten "Match"-Elementen

Wenn Sie möchten, dass eine genaue Anzahl von "Match"-Elementen erfüllt sein muss, können Sie "minMatches" und "maxMatches" auf denselben Wert festlegen. Dieses "Any"-Element ist nur erfüllt, wenn genau ein Datum oder Schlüsselwort gefunden wird. Werden mehr Instanzen gefunden, ist keine Übereinstimmung mit dem Muster gegeben.

XML-Markup mit dem Element "Beliebig" und den Attributen "minÜbereinstimmungen" und "maxÜbereinstimmungen"

Übereinstimmung mit keinem der untergeordneten "Match"-Elemente

Wenn Sie möchten, dass ein spezifischer Nachweis nicht vorhanden sein soll, um einem Muster zu entsprechen, können Sie "minMatches" und "maxMatches" auf "0" festlegen. Dies kann nützlich sein, wenn Sie über eine Schlüsselwortliste oder andere Nachweise verfügen, die wahrscheinlich ein falsches positives Ergebnis angeben.

Beispielsweise wird bei der Entität der Mitarbeiter-ID nach dem Schlüsselwort "card" gesucht, da sich dies auf eine "ID card" beziehen kann. Wenn "card" aber nur im Ausdruck "credit card" vorkommt, bedeutet "card" bei diesem Inhalt wahrscheinlich nicht "id card". Sie können also "credit card" als Schlüsselwort zu einer Liste mit Ausdrücken hinzufügen, die Sie von einer Übereinstimmung mit dem Muster ausschließen möchten.

XML-Markup mit dem "maxÜbereinstimmungen"-Attributwert "0" (null)

Wie nahe der Entität muss der andere Nachweis sein? [Attribut "patternsProximity"]

Mit dem vertraulichen Informationstyp wird nach einem Muster gesucht, das eine Mitarbeiter-ID darstellt, und als Teil dieses Musters wird auch nach einem bestätigenden Nachweis wie einem Schlüsselwort (z. B. "ID") gesucht. Je näher dieser Nachweis liegt, desto wahrscheinlicher handelt es sich bei dem Muster um eine tatsächliche Mitarbeiter-ID. Mithilfe des erforderlichen Attributs "patternsProximity" des "Entity"-Elements können Sie festlegen, wie nahe andere Nachweise im Muster der Entität sein müssen.

XML-Markup mit dem Attribut "MusterNäherung"

Für jedes Muster in der Entität definiert der Attributwert "patternsProximity" den Abstand (in Unicode-Zeichen) von der "IdMatch"-Position für alle anderen Übereinstimmungen, die für dieses Muster angegeben wurden. Das Näherungsfenster wird von der "IdMatch"-Position verankert, wobei das Fenster links und rechts von "IdMatch" erweitert wird.

Diagramm des Näherungsfensters

Das folgende Beispiel veranschaulicht, wie sich das Näherungsfenster auf den Musterabgleich auswirkt, wobei das "IdMatch"-Element für die benutzerdefinierte Entität der Mitarbeiter-ID mindestens eine bestätigende Übereinstimmung des Schlüsselworts oder Datums erfordert. Eine Übereinstimmung trifft nur für "ID1" zu, da für "ID2" und "ID3" entweder keine oder nur teilweise bestätigende Nachweise innerhalb des Näherungsfensters gefunden werden.

Diagramm von bestätigenden Nachweisen und Näherungsfenster

Beachten Sie, dass bei E-Mails der Textbereich und jede einzelne Anlage als gesonderte Elemente behandelt werden. Das bedeutet, dass sich das Näherungsfenster nicht über das Ende des jeweiligen Elements hinaus erstreckt. Für jedes Element (Anlage oder Text) müssen sich "IdMatch" und bestätigende Nachweise in diesem Element befinden.

Welches sind die richtigen Konfidenzniveaus für verschiedene Muster? [Attribut "confidenceLevel", Attribut "recommendedConfidence"]

Je mehr Nachweise ein Muster erfordert, desto größer ist die Konfidenz, dass eine tatsächliche Entität (z. B. eine Mitarbeiter-ID) beim Abgleich des Musters erkannt wurde. Beispielsweise besteht größere Konfidenz bei einem Muster, das eine neunstellig ID-Nummer, ein Einstellungsdatum und ein Schlüsselwort in nächster Nähe erfordert, als bei einem Muster, das nur eine neunstellige ID-Nummer erfordert.

Das Element "Pattern" weist ein erforderliches Attribut "confidenceLevel" auf. Sie können sich den Wert für "confidenceLevel" (eine ganze Zahl zwischen 1 und 100) als eine eindeutige ID für jedes Muster in einer Entität vorstellen – die Muster in einer Entität müssen unterschiedliche Konfidenzniveaus aufweisen, die von Ihnen zugewiesen werden. Der genaue Wert der Zahl spielt keine Rolle – wählen Sie einfach Zahlen aus, die Ihrem Complianceteam sinnvoll erscheinen. Nachdem Sie den benutzerdefinierten vertraulichen Informationstyp hochgeladen und anschließend eine DLP-Richtlinie erstellt haben, können Sie in den Bedingungen der von Ihnen erstellten Regeln auf diese Konfidenzniveaus verweisen.

XML-Markup mit "Muster"-Elementen und verschiedenen Werten für das Attribut "Konfidenzniveau"

Zusätzlich zu "confidenceLevel" für jedes Muster weist "Entity" ein Attribut "recommendedConfidence" auf. Dieses Attribut für die empfohlene Konfidenz kann man sich als das Standardkonfidenzniveau für die Regel vorstellen. Wenn Sie beim Erstellen einer Regel in einer DLP-Richtlinie kein zu verwendendes Konfidenzniveau für die Regel angeben, erfolgt der Abgleich für diese Regel basierend auf dem empfohlenen Konfidenzniveau für die Entität.

Sollen andere Sprachen auf der Benutzeroberfläche des Security & Compliance Centers unterstützt werden? [Element "LocalizedStrings"]

Wenn Ihr Complianceteam das Office 365 Security & Compliance Center zum Erstellen von DLP-Richtlinien in verschiedenen Gebietsschemas und in verschiedenen Sprachen verwendet, können Sie lokalisierte Versionen des Namens und der Beschreibung Ihres benutzerdefinierten vertraulichen Informationstyps bereitstellen. Wenn Ihr Complianceteam Office 365 in einer von Ihnen unterstützten Sprache verwendet, wird der lokalisierte Name auf der Benutzeroberfläche angezeigt.

Optionen "Instanzenzahl" und "Übereinstimmungsgenauigkeit"

Das Element "Rules" muss ein "LocalizedStrings"-Element enthalten, das wiederum ein Element "Resource" enthält, welches auf die GUID Ihrer benutzerdefinierten Entität verweist. Jedes "Resource"-Element enthält wiederum ein oder mehrere Elemente des Typs "Name" und "Description", die jeweils das Attribut "langcode" verwenden, um eine lokalisierte Zeichenfolge für eine bestimmte Sprache bereitzustellen.

XML-Markup mit Inhalten des Elements "LokalisierteZeichenfolgen"

Beachten Sie, dass Sie lokalisierte Zeichenfolgen nur für die Anzeige Ihres benutzerdefinierten vertraulichen Informationstyps auf der Benutzeroberfläche des Security & Compliance Centers verwenden. Sie können lokalisierte Zeichenfolgen nicht verwenden, um verschiedene lokalisierte Versionen einer Schlüsselwortliste oder eines regulären Ausdrucks bereitzustellen.

Anderes Regelpaket-Markup [RulePack-GUID]

Am Anfang jedes Regelpakets sind einige allgemeine Informationen enthalten, die Sie ausfüllen müssen. Sie können das folgende Markup als Vorlage verwenden und die Platzhalter vom Typ ". . ." durch eigene Informationen ersetzen.

Sie müssen vor allem eine GUID für das Regelpaket generieren. Oben haben Sie eine GUID für die Entität generiert. Dies hier ist eine zweite GUID für das Regelpaket. GUIDs können auf verschiedene Arten generiert werden, besonders einfach ist es aber in PowerShell. Dort müssen Sie nur [guid]::NewGuid() eingeben.

Das Element "Version" ist ebenfalls wichtig. Wenn Sie das Regelpaket zum ersten Mal hochladen, merkt sich Office 365 die Versionsnummer. Wenn Sie später das Regelpaket aktualisieren und eine neue Version hochladen, achten Sie darauf, die Versionsnummer zu aktualisieren, da Office 365 das Regelpaket sonst nicht bereitstellt.

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

Wenn Sie fertig sind, sollte das Element "RulePack" wie folgt aussehen:

XML-Markup mit dem Element "Regelpaket"

Änderungen für Exchange Online

In früheren Versionen haben Sie Ihre benutzerdefinierten vertraulichen Informationstypen für DLP möglicherweise mit Exchange Online PowerShell importiert. Nun können Ihre benutzerdefinierten vertraulichen Informationstypen sowohl im Exchange Admin Center als auch im Security & Compliance Center verwendet werden. Als Teil dieser Verbesserung sollten Sie die Security & Compliance Center-PowerShell verwenden, um Ihre benutzerdefinierten vertraulichen Informationstypen zu importieren. Sie können sie nicht mehr aus Exchange PowerShell importieren. Ihre benutzerdefinierten vertraulichen Informationstypen funktionieren weiterhin wie zuvor, es kann jedoch bis zu einer Stunde dauern, bis Änderungen, die Sie im Security & Compliance Center an benutzerdefinierten vertraulichen Informationstypen vorgenommen haben, im Exchange Admin Center angezeigt werden.

Beachten Sie, dass Sie im Security & Compliance Center das Cmdlet DlpSensitiveInformationTypeRulePackage verwenden müssen, um ein Regelpaket hochzuladen. Im Exchange Admin Center wurde früher das Cmdlet ClassificationRuleCollection verwendet.

Hochladen des Regelpakets

Zum Hochladen des Regelpakets gehen Sie wie folgt vor:

  1. Speichern Sie es als eine XML-Datei mit Unicode-Codierung.

  2. Herstellen einer Verbindung zum Office 365 Security & Compliance Center mithilfe von Remote-PowerShell

  3. Geben Sie in der PowerShell des Security & Compliance Centers Folgendes ein: New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\custompath\MyNewRulePack.xml" -Encoding Byte).

    Stellen Sie sicher, dass der Dateispeicherort verwendet wird, in dem das Regelpaket tatsächlich gespeichert ist. C:\custompath\ ist ein Platzhalter.

  4. Geben Sie zur Bestätigung Y ein, und drücken Sie dann die EINGABETASTE.

  5. Stellen Sie sicher, dass der neue vertrauliche Informationstyp hochgeladen wurde, indem Sie Get-DlpSensitiveInformationType eingeben, um eine Liste aller vertraulichen Informationstypen anzuzeigen. Sie können schnell zwischen benutzerdefinierten vertraulichen Informationstypen und integrierten Typen unterscheiden, indem Sie sich die Spalte "Publisher" ansehen. Sie können die Liste nach einem bestimmten vertraulichen Informationstyp filtern, indem Sie Get-DlpSensitiveInformationType -Identity "Name des vertraulichen Informationstyps" ausführen.

Mögliche Überprüfungsprobleme, die zu beachten sind

Wenn Sie die XML-Datei für das Regelpaket hochladen, überprüft das System die XML-Datei und sucht nach bekannten fehlerhaften Mustern und offensichtlichen Leistungsproblemen. Nachfolgend sind einige bekannte Probleme aufgeführt, auf die geprüft wird:

  • Ein regulärer Ausdruck kann nicht mit dem Zeichen "|" beginnen oder enden, da dies als eine leere Übereinstimmung angesehen wird und daher allem entspricht.

    Beispielsweise bewirkt "|a" oder "b|" einen Fehler bei der Überprüfung.

  • Ein regulärer Ausdruck kann nicht mit einem Muster vom Typ ".{0,m}" beginnen oder enden, das keine Funktion hat und nur die Leistung beeinträchtigt.

    Beispielsweise bewirkt ".{0,50}ASDF" oder "ASDF.{0,50}" einen Fehler bei der Überprüfung.

  • Ein regulärer Ausdruck kann nicht ".{0,m}" oder ".{1,m}" in Gruppen und nicht ".*" oder ".+" in Gruppen aufweisen.

    Beispielsweise bewirkt "(.{0,50000})" einen Fehler bei der Überprüfung.

  • Ein regulärer Ausdruck kann kein Zeichen mit den Repeatern "{0,m}" oder "{1,m}" in Gruppen aufweisen.

    Beispielsweise bewirkt "(a*)" einen Fehler bei der Überprüfung.

  • Ein regulärer Ausdruck kann nicht mit ".{1,m}" beginnen oder enden. Verwenden Sie stattdessen einfach "."

    Beispielsweise bewirkt ".{1,m}asdf" einen Fehler bei der Überprüfung. Verwenden Sie stattdessen einfach ".asdf".

  • Ein regulärer Ausdruck kann keinen ungebundenen Repeater (z. B. "*" oder "+") für eine Gruppe aufweisen.

    Beispielsweise bewirken "(xx)*" und "(xx)+" einen Fehler bei der Überprüfung.

Enthält ein benutzerdefinierter vertraulicher Informationstyp ein Problem, das sich auf die Leistung auswirken könnte, wird dieser nicht hochgeladen, und es wird möglicherweise eine der folgenden Fehlermeldungen angezeigt:

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

  • Lookaround assertions

  • Complex grouping in conjunction with general quantifiers

Neues Durchforsten des Inhalts, um vertrauliche Informationen zu identifizieren

DLP verwendet den Suchcrawler zum Erkennen und Klassifizieren vertraulicher Informationen in Websiteinhalten. Inhalte von SharePoint Online- und OneDrive for Business-Websites werden automatisch erneut durchforstet, sobald sie aktualisiert wurden. Um aber den neuen benutzerdefinierten vertraulichen Informationstyp in allen vorhandenen Inhalten zu identifizieren, müssen diese Inhalte erneut durchforstet werden.

In Office 365 können Sie das erneute Durchforsten eines gesamten Mandanten nicht manuell anfordern, doch ist dies für eine Websitesammlung, Liste oder Bibliothek möglich. Informationen hierzu finden Sie unter Manuelles Anfordern des Durchforstens und des erneuten Indizierens einer Website, Bibliothek oder Liste.

Entfernen eines benutzerdefinierten vertraulichen Informationstyps

  1. Herstellen einer Verbindung zum Office 365 Security & Compliance Center mithilfe von Remote-PowerShell

  2. Führen Sie in der PowerShell des Security & Compliance Centers eine der folgenden Aktionen aus:

    • Entfernen eines gesamten Regelpakets und aller enthaltenen Entitäten

      Geben Sie Remove-DlpSensitiveInformationTypeRulePackage "Name Ihres Regelpakets" ein. Für die oben angegebene XML-Beispieldatei würden Sie Remove-DlpSensitiveInformationTypeRulePackage "Employee ID Custom Rule Pack" eingeben.

      Beachten Sie, dass Sie zum Identifizieren des Regelpakets das Element <Name> (für jede Sprache) im Element <Rule Pack> oder die GUID des Attributs "id" des Elements "RulePack" verwenden können.

    • Entfernen einer einzelnen Entität aus einem Regelpaket

      Sie müssen mithilfe von Set-DlpSensitiveInformationTypeRulePackage eine neue Version des Regelpakets hochladen, bei dem diese bestimmte Entität entfernt wurde. Sie müssen sicherstellen, dass keine DLP-Richtlinien oder Exchange-Transportregeln mehr auf den vertraulichen Informationstyp verweisen, bevor Sie diesen entfernen.

  3. Geben Sie zur Bestätigung Y ein, und drücken Sie dann die EINGABETASTE.

  4. Stellen Sie sicher, dass die neue Regel entfernt wurde. Geben Sie dazu Get- DlpSensitiveInformationType ein. Der Name des vertraulichen Informationstyps sollte nicht mehr angezeigt werden.

Referenz: XML-Schemadefinition für Regelpaket

Sie können dieses Markup kopieren, als eine XSD-Datei speichern und diese zum Überprüfen der XML-Datei für das Regelpaket verwenden.

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

Weitere Informationen

Ihre Fähigkeiten erweitern
Schulung erkunden
Neue Funktionen als Erster erhalten
An Office Insider teilnehmen

War diese Information hilfreich?

Vielen Dank für Ihr Feedback!

Vielen Dank für Ihr Feedback. Es klingt, als ob es hilfreich sein könnte, Sie mit einem unserer Office-Supportmitarbeiter zu verbinden.

×