Criar um tipo de informação confidencial personalizado usando o Windows PowerShell

  • Artigo

Este artigo mostra como criar um arquivo de pacote de regra XML que define tipos de informações confidenciais personalizados. Este artigo descreve um tipo de informação confidencial personalizado que identifica uma ID do funcionário. Você pode usar o XML de exemplo neste artigo como ponto de partida para seu próprio arquivo XML.

Para obter mais informações sobre tipos de informações confidenciais, consulte Saiba mais sobre tipos de informações confidenciais.

Depois de criar um arquivo XML bem formado, você pode carregá-lo no Microsoft 365 usando o PowerShell. Em seguida, você está pronto para usar seu tipo de informações confidenciais personalizado em políticas. Você pode testar sua eficácia na detecção das informações confidenciais conforme pretendido.

Observação

Se você não precisar do controle refinado que o PowerShell fornece, poderá criar tipos de informações confidenciais personalizados no portal de conformidade do Microsoft Purview. Para saber mais informações, consulte Criar um tipo de informação confidencial personalizado.

Dica

Se você não for um cliente E5, use a avaliação de soluções do Microsoft Purview de 90 dias para explorar como recursos adicionais do Purview podem ajudar sua organização a gerenciar as necessidades de segurança e conformidade de dados. Comece agora no hub de avaliações portal de conformidade do Microsoft Purview. Saiba mais sobre os termos de inscrição e avaliação.

Aviso de isenção de responsabilidade importante

Suporte da Microsoft não pode ajudá-lo a criar definições de correspondência de conteúdo.

Para desenvolvimento, teste e depuração personalizados de correspondência de conteúdo, você precisa usar seus próprios recursos internos de TI ou usar serviços de consultoria, como o MCS (Microsoft Consulting Services). Suporte da Microsoft engenheiros podem fornecer suporte limitado para esse recurso, mas não podem garantir que as sugestões personalizadas de correspondência de conteúdo atendam totalmente às suas necessidades.

O MCS pode fornecer expressões regulares para fins de teste. Eles também podem fornecer assistência na solução de problemas de um padrão RegEx existente que não está funcionando conforme o esperado com um único exemplo de conteúdo específico.

Confira Possíveis problemas de validação a serem conhecidos neste artigo.

Para saber mais sobre o mecanismo de Boost.RegEx (conhecido anteriormente como RegEx + +) é usado para processar o texto, confira Boost.Regex 5.1.3.

Observação

Se você usar um caractere ampersand (&) como parte de uma palavra-chave no tipo de informações confidenciais personalizadas, precisará adicionar um termo adicional com espaços ao redor do caractere. Por exemplo, use L & PnãoL&P.

XML de exemplo de um pacote de regras

Aqui está o XML de exemplo do pacote de regras que criamos neste artigo. Elementos e atributos são explicados nas seções a seguir.

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

Quais são seus principais requisitos? [Regra, entidade, elementos padrão]

É importante que você entenda a estrutura básica do esquema XML para uma regra. Sua compreensão da estrutura ajuda o tipo de informações confidenciais personalizadas a identificar o conteúdo certo.

Uma regra define uma ou mais entidades (também conhecidas como tipos de informações confidenciais). Cada entidade define um ou mais padrões. Um padrão é o que uma política procura quando avalia o conteúdo (por exemplo, email e documentos).

Na marcação XML, "regras" significam os padrões que definem o tipo de informação confidencial. Não associe referências a regras neste artigo com "condições" ou "ações" comuns em outros recursos da Microsoft.

Cenário mais simples: entidade com um padrão

Aqui está um cenário simples: você deseja que sua política identifique o conteúdo que contém IDs de funcionários de nove dígitos que são usadas em sua organização. Um padrão refere-se à expressão regular na regra que identifica números de nove dígitos. Qualquer conteúdo que contenha um número de nove dígitos satisfaz o padrão.

Diagrama de entidade com um padrão.

Mas esse padrão pode identificar qualquer número de nove dígitos, incluindo números mais longos ou outros tipos de números de nove dígitos que não são IDs de funcionários. Esse tipo de correspondência indesejada é conhecido como falso positivo.

Cenário mais comum: entidade com vários padrões

Devido ao potencial de falsos positivos, normalmente você usa mais de um padrão para definir uma entidade. Vários padrões fornecem evidências de suporte para a entidade de destino. Por exemplo, palavras-chave adicionais, datas ou outro texto podem ajudar a identificar a entidade original (por exemplo, o número de funcionários de nove dígitos).

Por exemplo, para aumentar a probabilidade de identificar o conteúdo que contém uma ID do funcionário, você pode definir outros padrões a serem buscados:

  • Um padrão que identifica uma data de contratação.
  • Um padrão que identifica uma data de contratação e a "ID do funcionário" palavra-chave.

Diagrama de entidade com vários padrões.

Há pontos importantes a serem considerados para correspondências de vários padrões:

  • Padrões que exigem mais evidência têm maior nível de confiança. Com base no nível de confiança, você pode executar as seguintes ações:

    • Use ações mais restritivas (como bloquear conteúdo) com correspondências de maior confiança.
    • Use ações menos restritivas (como enviar notificações) com correspondências de menor confiança.

  • O suporte IdMatch e Match os elementos fazem referência a RegExes e palavras-chave que são, na verdade, filhos do Rule elemento, não do Pattern. AsPattern referências dão suporte a elementos, mas eles são incluídos no Rule. Esse comportamento significa que uma única definição de um elemento de suporte, como uma expressão regular ou uma lista de palavra-chave, pode ser referenciada por várias entidades e padrões.

Qual entidade você precisa identificar? [Elemento Entity, atributo ID]

Uma entidade é um tipo de informação confidencial, como um número de cartão de crédito, que tem um padrão bem definido. Cada entidade tem um GUID exclusivo como sua ID.

Nomear a entidade e gerar seu GUID

  1. No editor de escolha do XML, adicione os Rules elementos e Entity .
  2. Adicione um comentário que contém o nome de sua entidade personalizada, como ID do funcionário. Posteriormente, você adiciona o nome da entidade à seção cadeias de caracteres localizadas e esse nome aparece no centro de administração quando você cria uma política.
  3. Gere um GUID exclusivo para sua entidade. Por exemplo, em Windows PowerShell, você pode executar o comando [guid]::NewGuid(). Posteriormente, você também adicionará o GUID à seção cadeias de caracteres localizadas da entidade.

Marcação XML mostrando elementos Regras e Entidade.

Qual padrão você deseja corresponder? [Elemento Pattern, elemento IdMatch, elemento Regex]

O padrão contém a lista do que o tipo de informações confidenciais está procurando. O padrão pode incluir RegExes, palavras-chave e funções internas. Funções fazem tarefas como executar RegExes para localizar datas ou endereços. Tipos de informações confidenciais podem ter vários padrões com confianças exclusivas.

No diagrama a seguir, todos os padrões fazem referência à mesma expressão regular. Este RegEx procura um número (\d{9}) de nove dígitos cercado por espaço (\s) ... (\s)em branco . O IdMatch elemento faz referência a essa expressão regular e é o requisito comum para todos os padrões que procuram a entidade ID do funcionário. IdMatch é o identificador que o padrão está tentando corresponder. Um Pattern elemento deve ter exatamente um IdMatch elemento.

Marcação XML mostrando vários elementos Pattern fazendo referência ao elemento Regex único.

Uma correspondência de padrão satisfeita retorna um nível de contagem e confiança, que você pode usar nas condições em sua política. Ao adicionar uma condição para detectar um tipo de informação confidencial a uma política, você pode editar o nível de contagem e confiança, conforme mostrado no diagrama a seguir. O nível de confiança (também chamado de precisão de correspondência) é explicado mais tarde neste artigo.

Opções de contagem de instâncias e precisão de correspondência.

Expressões regulares são poderosas, portanto, há problemas que você precisa saber. Por exemplo, um RegEx que identifica muito conteúdo pode afetar o desempenho. Para saber mais sobre essas questões, confira a seção Possíveis problemas de validação a serem cientes posteriormente neste artigo.

Deseja exigir evidências adicionais? [Elemento Match, atributo minCount]

Além de IdMatch, um padrão pode usar o Match elemento para exigir evidências de suporte adicionais, como um palavra-chave, RegEx, data ou endereço.

Um Pattern pode incluir vários Match elementos:

  • Diretamente no Pattern elemento.
  • Combinado usando o Any elemento.

Match os elementos são associados a um operador E implícito. Em outras palavras, todos os Match elementos devem ser satisfeitos para que o padrão seja correspondido.

Você pode usar o Any elemento para introduzir operadores AND ou OR. O Any elemento é descrito posteriormente neste artigo.

Você pode usar o atributo opcional minCount para especificar quantas instâncias de uma correspondência precisam ser encontradas para cada Match elemento. Por exemplo, você pode especificar que um padrão só é satisfeito quando pelo menos duas palavras-chave de uma lista de palavra-chave são encontradas.

Marcação XML mostrando elemento Match com atributo minOccurs.

Palavras-chave [elementos Keyword, Group e Term, atributos matchStyle e caseSensitive]

Conforme descrito anteriormente, identificar informações confidenciais geralmente requer palavras-chave adicionais como evidência corroborativa. Por exemplo, além de corresponder a um número de nove dígitos, você pode procurar palavras como "cartão", "selo" ou "ID" usando o elemento Palavra-chave. O Keyword elemento tem um ID atributo que pode ser referenciado por vários Match elementos em vários padrões ou entidades.

As palavras-chave são incluídas como uma lista de Term elementos em um Group elemento. O Group elemento tem um matchStyle atributo com dois valores possíveis:

  • matchStyle="word": uma correspondência de palavras identifica palavras inteiras cercadas por espaço em branco ou outros delimitadores. Você sempre deve usar a palavra , a menos que precise corresponder partes de palavras ou palavras em idiomas asiáticos.

  • matchStyle="string": uma correspondência de cadeia de caracteres identifica cadeias de caracteres, independentemente do que elas estejam cercadas. Por exemplo, "ID" corresponde a "b id" e "idea". Use string somente quando precisar corresponder às palavras asiáticas ou se o palavra-chave puder ser incluído em outras cadeias de caracteres.

Por fim, você pode usar o caseSensitive atributo do Term elemento para especificar que o conteúdo deve corresponder exatamente ao palavra-chave, incluindo letras minúsculas e maiúsculas.

Marcação XML mostrando elementos match fazendo referência a palavras-chave.

Expressões regulares [elemento Regex]

Neste exemplo, a entidade de funcionário ID já usa o IdMatch elemento para fazer referência a uma expressão regular para o padrão: um número de nove dígitos cercado por whitespace. Além disso, um padrão pode usar um Match elemento para fazer referência a um elemento adicional Regex para identificar evidências corroborativas, como um número de cinco dígitos ou nove dígitos no formato de um código postal dos EUA.

Padrões adicionais, como datas ou endereços [funções internas]

Tipos de informações confidenciais também podem usar funções internas para identificar evidências corroborantes. Por exemplo, uma data dos EUA, data da UE, data de validade ou endereço dos EUA. O Microsoft 365 não dá suporte ao carregamento de suas próprias funções personalizadas. Mas, quando você cria um tipo de informação confidencial personalizado, sua entidade pode fazer referência a funções internas.

Por exemplo, um selo de ID do funcionário tem uma data de contratação, portanto, essa entidade personalizada pode usar a função interna Func_us_date para identificar uma data no formato comumente usado nos EUA.

Para obter mais informações, consulte Funções de tipo de informações confidenciais.

Marcação XML mostrando o elemento Match fazendo referência à função interna.

Diferentes combinações de evidências [elemento Any, atributos minMatches e maxMatches]

Em um Pattern elemento, todos e MatchIdMatch elementos são unidos a um operador E implícito. Em outras palavras, todas as correspondências devem ser atendidas antes que o padrão possa ser satisfeito.

Você pode criar uma lógica de correspondência mais flexível usando o Any elemento para agrupar Match elementos. Por exemplo, você pode usar o Any elemento para corresponder a todos, nenhum ou um subconjunto exato de seus elementos filho Match .

O Any elemento tem atributos opcionais minMatches e maxMatches que você pode usar para definir quantos elementos filho Match devem ser atendidos antes que o padrão seja correspondido. Esses atributos definem o número de Match elementos, não o número de instâncias de evidência encontradas para as correspondências. Para definir um número mínimo de instâncias para uma correspondência específica, como duas palavras-chave de uma lista, use o minCount atributo para um Match elemento (consulte acima).

Corresponder pelo menos um elemento Match filho

Para exigir apenas um número mínimo de Match elementos, você pode usar o minMatches atributo. Na verdade, esses Match elementos são unidos a um operador or implícito. Esse Any elemento será satisfeito se uma data formatada nos EUA ou uma palavra-chave de qualquer lista for encontrada.

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

Corresponder um subconjunto exato dos elementos filhos de Match

Para exigir um número exato de Match elementos, defina minMatches e maxMatches para o mesmo valor. Esse Any elemento só será satisfeito se exatamente uma data ou palavra-chave for encontrada. Se houver mais correspondências, o padrão não será correspondido.

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

Corresponder nenhum dos elementos "Match" de crianças

Se você quiser exigir a ausência de evidências específicas para que um padrão seja satisfeito, você pode definir minMatches e maxMatches como 0. Isso pode ser útil se você tiver uma lista palavra-chave ou outra evidência que provavelmente indicará um falso positivo.

Por exemplo, a entidade de ID do funcionário procura o palavra-chave "cartão" porque pode se referir a um "cartão de ID". No entanto, se cartão aparecer apenas na frase "cartão de crédito", "cartão" nesse conteúdo não significará "ID cartão". Portanto, você pode adicionar "cartão de crédito" como um palavra-chave a uma lista de termos que deseja excluir de satisfazer o padrão.

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

Corresponder a vários termos exclusivos

Se você quiser corresponder a vários termos exclusivos, use o parâmetro uniqueResults , definido como true, conforme mostrado no exemplo a seguir:

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

Neste exemplo, um padrão é definido para revisão salarial usando pelo menos três correspondências exclusivas.

Quão perto da entidade deve ser a outra evidência? [atributo patternsProximity]

Seu tipo de informação confidencial está procurando um padrão que represente uma ID do funcionário e, como parte desse padrão, ele também está procurando evidências corroborativas como um palavra-chave como "ID". Faz sentido que quanto mais próxima essa evidência for, maior a probabilidade de o padrão ser uma ID real do funcionário. Você pode determinar o quão próximas outras evidências no padrão devem ser para a entidade usando o atributo patternsProximity necessário do elemento Entity.

Marcação XML mostrando o atributo patternsProximity.

Para cada padrão na entidade, o valor do atributo patternsProximity define a distância (em caracteres Unicode) do local IdMatch para todas as outras Correspondências especificadas para esse Padrão. A janela de proximidade é ancorada pelo local IdMatch, com a janela se estendendo para a esquerda e para a direita do IdMatch.

Diagrama da janela de proximidade.

O exemplo a seguir ilustra como a janela de proximidade afeta a correspondência de padrões em que o elemento IdMatch para a entidade personalizada da ID do funcionário requer pelo menos uma correspondência corroborante de palavra-chave ou data. Somente a ID1 corresponde porque para ID2 e ID3, nenhuma ou apenas evidência de corroboração parcial é encontrada dentro da janela de proximidade.

Diagrama de evidência corroborativa e janela de proximidade.

Para email, o corpo da mensagem e cada anexo são tratados como itens separados. Isso significa que a janela de proximidade não se estende além do final de cada um desses itens. Para cada item (anexo ou corpo), a evidência idMatch e corroborativa precisa residir nesse item.

Quais são os níveis de confiança certos para padrões diferentes? [atributo confidenceLevel, atributo RecommendedConfidence]

Quanto mais evidência de que um padrão requer, mais confiança você tem de que uma entidade real (como A ID do funcionário) foi identificada quando o padrão é correspondido. Por exemplo, você tem mais confiança em um padrão que requer um número de ID de nove dígitos, data de contratação e palavra-chave próximos, do que em um padrão que requer apenas um número de ID de nove dígitos.

O elemento Pattern tem um atributo confidenceLevel necessário. Você pode pensar no valor de confiançaLevel (um valor entre 65/75/85 indicando níveis de confiança baixo/médio/alto) como uma ID exclusiva para cada padrão em uma entidade. Depois de fazer upload de seu tipo de informação confidencial personalizado e criar uma política, você pode fazer referência a esses níveis de confiança nas condições das regras que criar.

Marcação XML mostrando elementos Pattern com valores diferentes para atributo confidenceLevel.

Além do atributo confidenceLevel para cada Padrão, a Entidade tem um atributo recommendedConfidence. O atributo recommendedConfidence pode ser visto como o nível de confiança padrão para a regra. Quando você cria uma regra em uma política, se não especificar um nível de confiança para a regra ser usada, essa regra corresponderá com base no nível de confiança recomendado para a entidade. Observe que o atributo recomendadoConfidence é obrigatório para cada ID de entidade no Pacote de Regras, se não for possível salvar políticas que usam o Tipo de Informações Confidenciais.

Deseja dar suporte a outros idiomas na interface do usuário do portal de conformidade? [Elemento Strings Localizado]

Se sua equipe de conformidade usar o portal de conformidade do Microsoft Purview para criar políticas em diferentes localidades e em idiomas diferentes, você poderá fornecer versões localizadas do nome e da descrição do tipo de informações confidenciais personalizados. Quando sua equipe de conformidade usar o Microsoft 365 em um idioma que você oferece suporte, eles verão o nome localizado na interface do usuário.

Contagem de instâncias e configuração de precisão de correspondência.

O elemento Regras deve conter um elemento LocalizedStrings, que contém um elemento Resource que faz referência ao GUID de sua entidade personalizada. Por sua vez, cada elemento Resource contém um ou mais elementos Name e Description que usam o langcode atributo para fornecer uma cadeia de caracteres localizada para um idioma específico.

Marcação XML mostrando o conteúdo do elemento LocalizedStrings.

Observe que você usa strings localizadas apenas para como seu tipo de informação confidencial personalizada aparece na IU do Centro de Conformidade. Você não pode usar strings localizadas para fornecer diferentes versões localizadas de uma lista de palavras-chave ou expressão regular.

Outra marcação de pacote de regras [GUID RulePack]

Por fim, o início de cada RulePackage contém algumas informações gerais que você precisa preencher. Você pode usar a marcação a seguir como modelo e substituir o ". . ." espaços reservados com suas próprias informações.

Mais importante, você precisa gerar um GUID para o RulePack. Anteriormente, você gerou um GUID para a entidade; este é um segundo GUID para o RulePack. Há várias maneiras de gerar GUIDs, mas você pode fazer isso facilmente no Windows PowerShell digitando [guid]::NewGuid().

O elemento Version também é importante. Ao carregar seu pacote de regras pela primeira vez, o Microsoft 365 observa o número da versão. Posteriormente, se você atualizar o pacote de regras e carregar uma nova versão, atualize o número da versão ou o Microsoft 365 não implantará o pacote de regras.

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

Ao concluir, seu elemento RulePack deve ter esta aparência.

Marcação XML mostrando o elemento RulePack.

Validadores

O Microsoft 365 expõe processadores de funções para SITs comumente usados como validadores. Aqui está uma lista deles.

Lista de validadores disponíveis no momento

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

Isso oferece a capacidade de definir seu próprio RegEx e validá-los. Para usar validadores, defina seu próprio RegEx e use a Validator propriedade para adicionar o processador de funções de sua escolha. Depois de definido, você pode usar este RegEx em um SIT.

No exemplo abaixo, uma expressão regular - Regex_credit_card_AdditionalDelimiters é definida para Credit cartão, que é validada usando a função checksum para cartão de crédito usando Func_credit_card como validador.

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

O Microsoft 365 fornece dois validadores genéricos

Validador de soma de verificação

Neste exemplo, um validador de verificação para ID do funcionário é definido para validar o RegEx for EmployeeID.

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

Validador de Datas

Neste exemplo, um validador de datas é definido para uma parte RegEx da qual é a data.

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

Mudanças para o Exchange Online

Anteriormente, talvez você tenha usado o Windows PowerShell do Exchange Online para importar tipos de informações confidenciais personalizados para DLP. Agora, seus tipos de informações confidenciais personalizados podem ser usados no centro de administração do Exchange]"https://go.microsoft.com/fwlink/p/?linkid=2059104") e no portal de conformidade do Microsoft Purview. Como parte desse aprimoramento, você deve usar o Security & Compliance PowerShell para importar seus tipos de informações confidenciais personalizados, não é mais possível importá-los do Exchange Online PowerShell. Seus tipos de informações confidenciais personalizados continuarão a funcionar como antes; entretanto, pode levar até uma hora para que as alterações feitas nos tipos de informações confidenciais personalizados no Centro de conformidade apareçam no centro de administração do Exchange.

Observe que, no Centro de conformidade, você usa o cmdlet New-DlpSensitiveInformationTypeRulePackage para carregar um pacote de regras. (Anteriormente, no centro de administração do Exchange, você usou o cmdlet ClassificationRuleCollection.)

Carregar o pacote de regras

Para carregar o pacote de regras, siga as etapas:

  1. Salve-o como um arquivo .xml com codificação Unicode.

  2. Conectar-se ao PowerShell de Segurança e Conformidade

  3. Use a seguinte sintaxe:

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

    Este exemplo carrega o arquivo XML Unicode chamado MyNewRulePack.xml de C:\Meus documentos.

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

    Para informações detalhadas de sintaxe e parâmetros, confira New-DlpSensitiveInformationTypeRulePackage.

    Observação

    O número máximo de pacotes de regras com suporte é 10, mas cada pacote pode conter a definição de vários tipos de informações confidenciais.

  4. Para confirmar que você criou um novo tipo de informação confidencial com êxito, execute uma destas etapas:

    • Execute o cmdlet Get-DlpSensitiveInformationTypeRulePackage para verificar se o novo pacote de regras está listado:

      Get-DlpSensitiveInformationTypeRulePackage

    • Execute o cmdlet Get-DlpSensitiveInformationType para verificar se o tipo de informação confidencial está listado:

      Get-DlpSensitiveInformationType

      Para tipos personalizados de informação confidencial, o valor da propriedade Publisher será diferente do Microsoft Corporation.

    • Substitua <Name> pelo valor Name do tipo de informação sensível (exemplo: ID do Funcionário) e execute o cmdlet Get-DlpSensitiveInformationType:

      Get-DlpSensitiveInformationType -Identity "<Name>"

Possíveis problemas de validação a serem considerados

Quando você carrega o arquivo XML do pacote de regras, o sistema valida o XML e verifica padrões ruins conhecidos e problemas óbvios de desempenho. Aqui estão alguns problemas conhecidos que a validação verifica : uma expressão regular:

  • As declarações lookbehind na expressão regular devem ser apenas de comprimento fixo. As declarações de comprimento de variável resultarão em erros.

    Por exemplo, "(?<=^|\s|_)" não passará validação. O primeiro padrão (^) é de comprimento zero, enquanto os dois próximos padrões (\s e _) têm um comprimento de um. Uma maneira alternativa de escrever essa expressão regular é "(?:^|(?<=\s|_))".

  • Não é possível começar ou terminar com o alternador |, que corresponde a tudo porque é considerado uma correspondência vazia.

    Por exemplo, |a ou b| não passará a validação.

  • Não é possível começar ou terminar com um .{0,m} padrão, que não tem nenhuma finalidade funcional e prejudica apenas o desempenho.

    Por exemplo, .{0,50}ASDF ou ASDF.{0,50} não passará a validação.

  • Não é possível ter .{0,m} ou .{1,m} em grupos e não pode ter .\* ou .+ em grupos.

    Por exemplo, (.{0,50000}) não passará validação.

  • Não é possível ter nenhum caractere com {0,m} ou {1,m} repetidores em grupos.

    Por exemplo, (a\*) não passará validação.

  • Não é possível começar ou terminar com .{1,m}; em vez disso, use ..

    Por exemplo, .{1,m}asdf não passará validação. Em vez disso, use .asdf.

  • Não é possível ter um repetidor desvinculado (como * ou +) em um grupo.

    Por exemplo, (xx)\* e (xx)+ não passará validação.

  • As palavras-chave têm no máximo 50 caracteres de comprimento. Se você tiver uma palavra-chave dentro de um Grupo que exceda isso, uma solução sugerida é criar o Grupo de termos como Dicionário de Palavras-chave e fazer referência ao GUID do Dicionário de Palavras-chave dentro da estrutura XML como parte da Entidade para Correspondência ou idMatch no Arquivo.

  • Cada tipo de informação confidencial personalizada pode ter no máximo 2.048 palavras-chave no total.

  • O tamanho máximo dos Dicionários de Palavras-Chave em um único locatário é 480 KB compactado para cumprir os limites de esquema do AD. Consulte o mesmo dicionário quantas vezes forem necessárias ao criar tipos de informações confidenciais personalizados. Inicie criando listas de palavras-chave personalizadas no tipo de informação confidencial e use dicionários de palavras-chave se você tiver mais de 2.048 palavras-chave em uma lista de palavras-chave ou se uma palavra-chave tiver mais de 50 caracteres.

  • Um máximo de 50 tipos de informações confidenciais com base no dicionário de palavras-chave são permitidas em um locatário.

  • Certifique-se de que cada elemento de Entidade contenha um atributo recommendedConfidence.

  • Ao usar o Cmdlet do PowerShell, há um tamanho de retorno máximo dos Dados Desserializados de aproximadamente 1 megabyte. Isso afetará o tamanho do arquivo XML do pacote de regras. Mantenha o arquivo carregado limitado a um máximo de 770 kilobytes como um limite sugerido para resultados consistentes sem erros durante o processamento.

  • A estrutura XML não requer caracteres de formatação, como espaços, guias ou entradas de retorno/alimentação de transporte. Observe isso ao otimizar o espaço em uploads. Ferramentas como o Microsoft Visual Code fornecem recursos de linha de junção para compactar o arquivo XML.

Se um tipo personalizado de informações confidenciais contiver um problema que pode afetar o desempenho, ele não será carregado e você poderá ver uma dessas mensagens de erro:

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

  • Lookaround assertions

  • Complex grouping in conjunction with general quantifiers

Repetir o rastreamento de seu conteúdo para identificar informações confidenciais

O Microsoft 365 usa o rastreador de pesquisa para identificar e classificar informações confidenciais no conteúdo do site. O conteúdo dos sites do SharePoint Online e do OneDrive for Business é rastreado novamente de forma automática sempre que é atualizado. Porém, para identificar seu novo tipo personalizado de informações confidenciais em todo o conteúdo existente, esse conteúdo deve ser novamente rastreado.

No Microsoft 365, você não pode solicitar manualmente um recrawl de uma organização inteira, mas você pode solicitar manualmente uma recrawl para uma coleção de sites, lista ou biblioteca. Para obter mais informações, consulte Rastreamento de solicitação manual e reindexação de um site, uma biblioteca ou uma lista.

Referência: Definição do esquema XML do pacote de regras

Você pode copiar essa marcação, salvá-la como um arquivo XSD e usá-la para validar o arquivo XML do seu pacote de regras.

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

Mais informações