通过

在 Exchange 2013 中开发敏感信息规则包

  • 项目

适用于：Exchange Server 2013

本主题中的 XML 架构和指导会帮助你开始创建自己的基本数据丢失预防 (DLP) XML 文件，这些文件在一个分类规则包中定义你自己的敏感信息类型。 创建格式正确的 XML 文件后，可以使用 Exchange 管理中心或 Exchange 命令行管理程序导入该文件，以帮助创建Microsoft Exchange Server 2013 DLP 解决方案。 XML 文件是一个自定义的 DLP 策略模板，可包含作为你的分类规则包的 XML。 有关将你自己的 DLP 模板定义为 XML 文件的概述，请参阅定义您自己的 DLP 模板和信息类型。

规则创作过程的概述

规则创作过程由以下一般步骤组成。

  1. 准备一系列代表其目标环境的测试文档。 测试文档集需要考虑的关键特征包括：文档的子集包含要为其创作规则的实体或相关性，文档的子集不包含要为其创作规则的实体或相关性。

  2. 确定满足接受要求（精度和调用）的规则以确定合格的内容。 此标识工作可能需要在规则中开发多个条件，这些条件与布尔逻辑绑定，这些逻辑共同满足标识目标文档的最低匹配要求。

  3. 为基于接受要求（精度和调用）的规则建立推荐的可信度。 推荐的可信元素可被视为规则的默认可信度。

  4. 通过将策略实例化并监视示例测试内容可验证规则。 根据结果调整规则或可信度，以将检测内容最大化，同时将误报和负面影响最小化。 继续验证循环和规则调整，直到正面和负面示例均达到内容检测的满意水平。

有关策略模板文件的 XML 架构定义的信息，请参阅开发 DLP 策略模板文件。

规则说明

可为 DLP 敏感信息检测引擎创作两种主要的规则类型：实体和相关性。 如之前部分所述，选择的规则类型基于应该应用到内容处理的处理逻辑类型。 规则定义在一个 XML 文档中配置，格式如标准化规则 XSD 中所述。 规则描述介绍匹配代表目标内容的要匹配的内容类型和可信度。 可信度指定如果在内容中发现一种模式而要显示的实体的概率，或如果在内容中发现证据而要显示的相关性的概率。

基本规则结构

规则定义包括三个主要组件：

  1. 实体 定义该规则的匹配和计数逻辑

  2. 相关性 定义规则的匹配逻辑

  3. 本地化字符串 规则名称及其说明的本地化

另外三个支持元素用于定义main组件中处理和引用的详细信息：Keyword、Regex 和 Function。 使用引用，可在多个实体或相关性规则中使用支持元素的一个单独定义，如社会保险号。 XML 格式的基本规则结构如下所示。

<?xml version="1.0" encoding="utf-8"?>
<RulePackage xmlns="http://schemas.microsoft.com/office/2011/mce">
  <RulePack id="DAD86A92-AB18-43BB-AB35-96F7C594ADAA">
    <Version major="1" minor="0" build="0" revision="0"/>
    <Publisher id="619DD8C3-7B80-4998-A312-4DF0402BAC04"/>
    <Details defaultLangCode="en-us">
      <LocalizedDetails langcode="en-us">
        <PublisherName>DLP by EPG</PublisherName>
        <Name>CSO Custom Rule Pack</Name>
        <Description>This is a rule package for a EPG demo.</Description>
      </LocalizedDetails>
    </Details>
  </RulePack>
  <Rules>
    <!-- Employee ID -->
    <Entity id="E1CC861E-3FE9-4A58-82DF-4BD259EAB378" patternsProximity="300" recommendedConfidence="75">
      <Pattern confidenceLevel="75">
        <IdMatch idRef="Regex_employee_id" />
        <Match idRef="Keyword_employee" />
      </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>
    <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 ID's
        </Description>
      </Resource>
    </LocalizedStrings>
  </Rules>
</RulePackage>

实体规则

实体规则面向定义完善的标识符（例如社会安全号码），由可计数模式的集合表示。 实体规则返回一个计数和匹配的可信度，其中计数是发现的实体实例的总数，可信度是给定文档中存在的给定实体的概率。 实体包含“Id”属性作为其唯一标识符。 该标识符用于本地化、版本控制和查询。 实体 ID 必须是 GUID。 实体 ID 不能在其他实体或关联中重复。 本地化字符串部分中引用了它。

实体规则包含可选的 patternsProximity 属性 (默认值 = 300) 在应用布尔逻辑时使用此属性来指定满足匹配条件所需的多个模式的相邻性。 实体元素包含一个或多个子 Pattern 元素，其中每个模式都是实体（如信用卡实体或驾照实体）的不同表示形式。 Pattern 元素具有 confidenceLevel 的必需属性，该属性表示基于示例数据集的模式精度。 Pattern 元素可以有三个子元素：

  1. IdMatch - 此元素是必需的。

  2. Match

  3. 任意

如果任何 Pattern 元素返回"true"，则满足该模式。 Pattern 元素的计数等于所有检测到的 Pattern 计数的总和。

实体计数的数学公式。

其中 k 是实体模式元素的数量。

一个 Pattern 元素必须只有一个 IdMatch 元素。 IdMatch 代表模式要匹配的标识符，例如一个信用卡号或 ITIN 号。 模式计数是与 Pattern 元素匹配的 IdMatch 的数量。 IdMatch 元素为 Pattern 元素锚定邻近感应窗口。

Pattern 元素的另一个可选子元素是 Match 元素，它表示需要匹配的确证证据，以支持查找 IdMatch 元素。 例如，置信度较高的规则可能要求，除了查找信用卡编号外，文档中还存在额外的项目，如地址和名称等信用卡的邻近窗口内。 这些额外的项目将通过 Match 元素或 Any 元素来表示， (在匹配方法和技术部分) 详细描述。 模式定义中可以包含多个 Match 元素，该定义可以直接包含在 Pattern 元素中，也可以使用 Any 元素组合来定义匹配语义。 如在围绕 IdMatch 内容锚定的邻近感应窗口中找到一个匹配，则返回 true。

IdMatch 和 Match 元素都不定义需要匹配的内容的详细信息，而是通过 idRef 属性引用它。 此引用可提高多个模式构造中定义的可重用性。

<Entity id="..." patternsProximity="300" >
    <Pattern confidenceLevel="85">
        <IdMatch idRef="FormattedSSN" />
        <Any minMatches="1">
            <Match idRef="SSNKeyword" />
            <Match idRef="USDate" />
            <Match idRef="USAddress" />
            <Match idRef="Name" />
        </Any>
    </Pattern>
    <Pattern confidenceLevel="65">
        <IdMatch idRef="UnformattedSSN" />
        <Match idRef="SSNKeyword" />
        <Any minMatches="1">
            <Match idRef="USDate" />
            <Match idRef="USAddress" />
            <Match idRef="Name" />
        </Any>
    </Pattern>
</Entity>

实体 ID 元素，在上一个 XML 中由“...” 表示应为 GUID，并在“本地化字符串”部分中引用。

实体模式接近窗口

实体保留用于查找模式的可选 patternsProximity 属性值（整数，默认 = 300）。 对于每个模式，属性值定义与为该模式指定的所有其他匹配项的 IdMatch 位置) Unicode 字符 (距离。 邻近感应窗口通过 IdMatch 位置锚定，窗口扩展到 IdMatch 的左右。

调出匹配元素的文本模式。

下面的示例说明了邻近度窗口如何影响匹配算法，其中 SSN IdMatch 元素需要至少一个地址、名称或日期验证匹配项。 只有 SSN1 和 SSN4 匹配，这是因为，对于 SSN2 和 SSN3，在邻近感应窗口中没有或只发现部分确认证据。

邻近度规则匹配和不匹配示例。

邮件正文和每个附件被视为独立项。 这种情况意味着邻近度窗口不会超出其中每个项的末尾。 对于每个项目（附件或正文），idMatch 和确凿证据需要驻留在每个项目中。

实体可信度

Entity 元素的可信度是所有满意的模式可信度的组合。 它们使用以下公式进行组合：

实体置信度级别的数学公式。

其中 k 是实体的 Pattern 元素数，不匹配的 Pattern 返回置信度级别 0。

追溯到示例实体元素结构代码示例，如果匹配两种模式，根据以下计算方法得出实体的可信度为 94.75%：

CLEntity= 1-[(1-CLPattern1) x (1-CLPattern1)]

= 1-[(1-0.85) x (1-0.65)]

= 1-(0.15 x 0.35)

= 94.75%

同理，如果只有第二种模式匹配，根据以下计算方法得出实体的可信度为 65%：

CLEntity= 1 - [(1 - CLPattern1) X (1 - CLPattern1)]

= 1 - [(1 - 0) X (1 - 0.65)]

= 1 - (1 X 0.35)

= 65%

这些可信值按照单个模式的规则进行分配，基于验证为规则创作过程一部分的一系列测试文档。

相关性规则

相关性规则针对没有良好定义标识符的内容，例如 Sarbanes-Oxley 或公司财务内容。 对于此内容，找不到单个一致的标识符，相反，分析需要确定是否存在证据集合。 相关性规则不返回计数，而是返回（如果找到）和关联的置信度级别。 相关性内容由一组独立证据表示。 证据是某个相关性内的所需匹配聚合。 对于相关性规则，邻近感应由 evidencesProximity 属性（默认为 600）定义，而最低可信度由 thresholdConfidenceLevel 属性定义。

相关性规则包含用于本地化、版本管理和查询的唯一标识符的 Id 属性。 与实体规则不同，由于地缘规则不依赖于定义完善的标识符，因此它们不包含 IdMatch 元素。

每个相关性规则包含一个或多个子证据元素，这些元素定义要找到的证据以及促成相关性规则的置信度级别。 如果生成的置信度低于阈值级别，则不会考虑找到相关性。 每种证据都在逻辑方面代表这种文档"类型"的确凿证据，并且 confidenceLevel 属性是该证据在测试数据集上的精度。

Evidence 元素有一个或多个 Match 或 Any 子元素。 如所有子 Match 和 Any 元素匹配，则会发现证据并且可信度对规则可信度计算起作用。 在实体规则方面，相同的说明适用于实体规则的 Match 或 Any 元素。

<Affinity id="..."
          evidencesProximity="1000"
          thresholdConfidenceLevel="65">
    <Evidence confidenceLevel="40">
        <Any>
            <Match idRef="AssetsTerms" />
            <Match idRef="BalanceSheetTerms" />
            <Match idRef="ProfitAndLossTerms" />
        </Any>
    </Evidence>
    <Evidence confidenceLevel="40">
        <Any minMatches="2">
            <Match idRef="TaxTerms" />
            <Match idRef="DollarAmountTerms" />
            <Match idRef="SECTerms" />
            <Match idRef="SECFilingFormTerms" />
            <Match idRef="DollarTotalRegex" />
        </Any>
    </Evidence>
</Affinity>

相关性接近窗口

相关性的邻近感应窗口和实体模式的计算方法不同。 相关性邻近感应遵循一种滑动窗口模式。 相关性邻近感应算法尝试在给定窗口中找到匹配证据的最大数量。 邻近感应窗口中证据的可信度必须大于为要找到的相关性规则定义的阈值。

与地缘规则匹配的邻近文本。

相关性可信度

相关性可信度等于相关性规则的邻近感应窗口中找到证据的组合。 类似于实体规则的可信度，关键差异是邻近感应窗口的应用。 和实体规则类似，Affinity 元素的可信度是所有满意的证据可信度的组合，但是对于相关性规则，它只代表在邻近感应窗口中找到的 Evidence 元素的最高组合。 证据可信度使用以下公式组合：

相关性规则置信度数学公式。

其中 k 是接近窗口中匹配相关性的证据元素的数量。

追溯到"图 4 示例相关性"规则结构，如果全部三个证据在邻近感应滑动窗口中都匹配，根据以下计算方法得出相关性可信度为 85.6%。 此值超过相关性规则阈值 65，这会导致规则匹配。

CL相关性= 1 - [(1 - CL证据 1) X (1 - CL证据 2) X (1 - CL证据 2)]

= 1 - [(1 - 0.6) X (1 - 0.4) X (1 - 0.4)]

= 1 - (0.4 X 0.6 X 0.6)

= 85.6%

高置信度相关性规则匹配示例。

使用相同的示例规则定义，如果只有第一个证据匹配，因为第二个证据在邻近窗口之外，则根据下面的计算，最高相关性置信度级别为 60%，并且相关性规则不匹配，因为未满足阈值 65。

CL相关性= 1 - [(1 - CL证据 1) X (1 - CL证据 2) X (1 - CL证据 2)]

= 1 - [(1 - 0.6) X (1 - 0) X (1 - 0) ]

= 1 - (0.4 X 1 X 1)

= 60%

低置信度相关性规则匹配示例。

微调可信度

规则创作过程的关键方面之一是为实体和相关性规则微调可信度。 创建规则定义后，根据代表内容运行规则并收集准确数据。 根据测试文档的预计结果，对比每个模式或证据返回的结果。

包含规则匹配证据比较的表。

如果规则满足验收要求，即模式或证据的置信度高于已建立的阈值 (例如 75% ) ，则匹配表达式已完成，并且可以将其移动到下一步。

如果模式或证据不符合置信度级别，则重新授权它 (例如，添加更多确凿证据：删除或添加额外的模式/证据;等 ) 并重复此步骤。

然后，根据上一步的结果微调你的规则中每个模式或证据的可信度。 对于每个模式或证据，聚合 (TP) 的真阳性数、包含要创作规则并导致匹配的实体或相关性的文档子集，以及 (FP) 的误报数，这些文档子集不包含要创作规则的实体或相关性，并且还返回匹配项。 为使用以下计算的每个模式/证据设置可信度：

可信度 = 真正的误报 /（真正的误报 + 误报）

模式或证据 真正的误报 误报 可信度
P1或 E1 4 1 80%
P2或 E2 2 2 50%
Pn或 En 9 10 47%

在您的 XML 文件中使用当地语言

规则架构支持每个 Entity 元素和 Affinity 元素的本地化名称和说明的存储。 每个 Entity 元素和 Affinity 元素必须在 LocalizedStrings 部分中包含一个相应的元素。 要本地化每个元素，包括作为 LocalizedStrings 元素的子元素的 Resource 元素，以便为每个元素的多个地区存储名称和说明。 Resource 元素包括一个必需的 idRef 属性，该属性与要本地化的每个元素的相应 idRef 属性匹配。 Resource 元素的区域设置子元素包含每个指定区域设置的本地化名称和说明。

<LocalizedStrings>
    <Resource idRef="guid">
        <Locale langcode="en-US" default="true">
            <Name>affinity name en-us</Name>
            <Description>
                affinity description en-us
            </Description>
        </Locale>
        <Locale langcode="de">
            <Name>affinity name de</Name>
            <Description>
                affinity description de
            </Description>
        </Locale>
    </Resource>
</LocalizedStrings>

分类规则包 XML 架构定义

<?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">
  <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"/>
          <xs:field xpath="@id"/>
        </xs:key>
        <xs:key name="UniqueProcessorId">
          <xs:selector xpath="mce:Regex|mce:Keyword"></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"/>
          <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="512"/>
    </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:choice>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="Regex" type="mce:RegexType"/>
        <xs:element name="Keyword" type="mce:KeywordType"/>
      </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: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: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: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:restriction base="xs:positiveInteger">
      <xs:minInclusive value="1"/>
    </xs:restriction>
  </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: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="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>

详细信息

数据丢失防护

定义您自己的 DLP 模板和信息类型