Compartilhar via

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

  • Artigo

Este artigo mostra-lhe como criar um ficheiro de pacote de regras XML que define tipos de informações confidenciais personalizados. Este artigo descreve um tipo de informação confidencial personalizado que identifica um ID de funcionário. Pode utilizar o XML de exemplo neste artigo como ponto de partida para o seu próprio ficheiro 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 ficheiro XML bem formado, pode carregá-lo para o Microsoft 365 com o PowerShell. Em seguida, está pronto para utilizar o tipo de informações confidenciais personalizadas nas políticas. Pode testar a sua eficácia ao detetar as informações confidenciais como pretendia.

Observação

Se não precisar do controlo detalhado fornecido pelo PowerShell, pode 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 é um cliente E5, use a avaliação das soluções do Microsoft Purview de 90 dias para explorar como os 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 testes do portal de conformidade do Microsoft Purview. Saiba mais detalhes sobre os termos de inscrição e avaliação.

Aviso de isenção de responsabilidade importante

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

Para o desenvolvimento, teste e depuração de correspondência de conteúdos personalizados, tem de utilizar os seus próprios recursos de TI internos ou utilizar serviços de consultoria, como o Microsoft Consulting Services (MCS). Os engenheiros do Suporte da Microsoft podem fornecer suporte limitado para esta funcionalidade, mas não podem garantir que as sugestões personalizadas de correspondência de conteúdos satisfaçam totalmente as suas necessidades.

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

Veja Potenciais problemas de validação a ter em conta 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 utilizar um caráter de e comercial (&) como parte de uma palavra-chave no seu tipo de informações confidenciais personalizado, terá de adicionar um termo adicional com espaços à volta do caráter. Por exemplo, nãoL&P utilizeL & P.

XML de exemplo de um pacote de regras

Eis o XML de exemplo do pacote de regras que criamos neste artigo. Os elementos e atributos são explicados nas secções que se seguem.

<?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 os seus principais requisitos? [Rule, Entity, Pattern elements]

É importante que compreenda a estrutura básica do esquema XML de uma regra. A sua compreensão da estrutura ajuda o seu tipo de informações confidenciais personalizado 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 conteúdo (por exemplo, e-mail e documentos).

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

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

Eis um cenário simples: quer que a sua política identifique conteúdos que contenham IDs de colaborador de nove dígitos que são utilizados na 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 da entidade com um padrão.

No entanto, este 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. Este tipo de correspondência indesejada é conhecida como falso positivo.

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

Devido ao potencial de falsos positivos, normalmente utiliza mais do que um padrão para definir uma entidade. Vários padrões fornecem provas 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ário de nove dígitos).

Por exemplo, para aumentar a probabilidade de identificar conteúdos que contenham um ID de funcionário, pode definir outros padrões a procurar:

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

Diagrama de entidade com múltiplos padrões.

Existem pontos importantes a considerar para correspondências de múltiplos 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, pode efetuar as seguintes ações:

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

  • Os elementos e Match suporte IdMatch referenciam RegExes e palavras-chave que são, na verdade, subordinados do Rule elemento, não o Pattern. AsPattern referências suportam elementos, mas estão incluídas no Rule. Este comportamento significa que uma única definição de um elemento de suporte, como uma expressão regular ou uma lista de palavras-chave, pode ser referenciada por várias entidades e padrões.

Que entidade precisa de identificar? [Elemento de entidade, 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 o respetivo ID.

Nomear a entidade e gerar seu GUID

  1. No editor XML de eleição, adicione os Rules elementos e Entity .
  2. Adicione um comentário que contenha o nome da sua entidade personalizada, como ID de Funcionário. Mais tarde, adicione o nome da entidade à secção de cadeias localizadas e esse nome aparece no centro de administração quando cria uma política.
  3. Gere um GUID exclusivo para a sua entidade. Por exemplo, no Windows PowerShell, pode executar o comando [guid]::NewGuid(). Mais tarde, também irá adicionar o GUID à secção de cadeias localizadas da entidade.

Marcação XML a mostrar regras e elementos de entidade.

Que padrão pretende corresponder? [Elemento pattern, elemento IdMatch, elemento Regex]

O padrão contém a lista do que o tipo de informação confidencial procura. O padrão pode incluir RegExes, palavras-chave e funções incorporadas. As 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 seguinte, todos os padrões referenciam a mesma expressão regular. Este RegEx procura um número (\d{9}) de nove dígitos rodeado de espaço (\s) ... (\s)em branco. O IdMatch elemento referencia esta 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á a tentar corresponder. Um Pattern elemento tem de ter exatamente um IdMatch elemento.

Marcação XML a mostrar vários elementos do Padrão que referenciam um único elemento Regex.

Uma correspondência de padrão satisfeita devolve um nível de contagem e confiança, que pode utilizar nas condições da sua política. Quando adiciona uma condição para detetar um tipo de informação confidencial a uma política, pode editar o nível de contagem e confiança, conforme mostrado no diagrama seguinte. O nível de confiança (também denominado precisão da correspondência) é explicado mais à frente neste artigo.

Contagem de instâncias e opções de precisão de correspondência.

As expressões regulares são poderosas, pelo que existem problemas que precisa de conhecer. Por exemplo, um RegEx que identifique demasiado conteúdo pode afetar o desempenho. Para saber mais sobre estes problemas, veja a secção Potenciais problemas de validação a ter em conta mais à frente neste artigo.

Quer exigir provas adicionais? [Elemento Match, atributo minCount]

Além do IdMatch, um padrão pode utilizar o Match elemento para exigir provas de suporte adicionais, como uma palavra-chave, RegEx, data ou endereço.

Um Pattern pode incluir vários Match elementos:

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

Match os elementos são associados a um operador AND implícito. Por outras palavras, todos os Match elementos têm de estar satisfeitos para que o padrão seja correspondido.

Pode utilizar o Any elemento para introduzir operadores AND ou OR. O Any elemento é descrito mais à frente neste artigo.

Pode utilizar o atributo opcional minCount para especificar quantas instâncias de uma correspondência têm de ser encontradas para cada Match elemento. Por exemplo, pode especificar que um padrão é satisfeito apenas quando forem encontradas, pelo menos, duas palavras-chave de uma lista de palavras-chave.

Marcação XML a mostrar o elemento Match com o atributo minOccurs.

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

Conforme descrito anteriormente, a identificação de informações confidenciais requer frequentemente palavras-chave adicionais como provas corroborativas. Por exemplo, para além de corresponder a um número de nove dígitos, pode procurar palavras como "cartão", "distintivo" ou "ID" com o elemento Palavra-chave. O Keyword elemento tem um ID atributo que pode ser referenciado por vários Match elementos em múltiplos padrões ou entidades.

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

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

  • matchStyle="string": uma correspondência de cadeia identifica as cadeias independentemente do que estejam entre elas. Por exemplo, "ID" corresponde a "bid" e "idea". Utilize string apenas quando precisar de corresponder a palavras asiáticas ou se a palavra-chave pode estar incluída noutras cadeias.

Por fim, pode utilizar o caseSensitive atributo do Term elemento para especificar que o conteúdo tem de corresponder exatamente à palavra-chave, incluindo letras minúsculas e maiúsculas.

Marcação XML a mostrar a opção Corresponder elementos que referenciam palavras-chave.

Expressões regulares [elemento Regex]

Neste exemplo, a entidade employee ID já utiliza o IdMatch elemento para referenciar uma expressão regular para o padrão: um número de nove dígitos rodeado por espaço em branco. Além disso, um padrão pode utilizar um Match elemento para referenciar um elemento adicional Regex para identificar provas 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]

Os tipos de informações confidenciais também podem utilizar funções incorporadas para identificar provas de corroboração. Por exemplo, uma data dos EUA, data da UE, data de validade ou endereço dos EUA. O Microsoft 365 não suporta o carregamento das suas próprias funções personalizadas. No entanto, quando cria um tipo de informação confidencial personalizado, a sua entidade pode referenciar funções incorporadas.

Por exemplo, um distintivo de ID de funcionário tem uma data de contratação, pelo que esta entidade personalizada pode utilizar a função incorporada Func_us_date para identificar uma data no formato normalmente utilizado nos EUA.

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

Marcação XML a mostrar o elemento Match que referencia a função incorporada.

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

Num Pattern elemento, todos os IdMatch elementos e Match são associados a um operador AND implícito. Por outras palavras, todas as correspondências têm de ser satisfeitas antes de o padrão poder ser satisfeito.

Pode criar uma lógica de correspondência mais flexível com o Any elemento para agrupar Match elementos. Por exemplo, pode utilizar o Any elemento para corresponder a todos, nenhum ou um subconjunto exato dos respetivos elementos subordinados Match .

O Any elemento tem atributos opcionais minMatches e maxMatches que pode utilizar para definir quantos dos elementos subordinados Match têm de ser satisfeitos antes de o padrão ser correspondido. Estes atributos definem o número de Match elementos, não o número de instâncias de provas 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, utilize o minCount atributo para um Match elemento (ver acima).

Corresponder pelo menos um elemento Match filho

Para exigir apenas um número mínimo de Match elementos, pode utilizar o minMatches atributo . Com efeito, estes Match elementos são associados a um operador OR implícito. Este Any elemento é satisfeito se for encontrada uma data formatada nos EUA ou uma palavra-chave de qualquer uma das listas.

<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. Este Any elemento só é satisfeito se for encontrada exatamente uma data ou palavra-chave. Se existirem 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>

Não corresponder nenhum dos elementos subordinados "Correspondência"

Se quiser exigir a ausência de provas específicas para que um padrão seja satisfeito, pode definir minMatches e maxMatches como 0. Isto pode ser útil se tiver uma lista de palavras-chave ou outras provas que possam indicar um falso positivo.

Por exemplo, a entidade ID do funcionário procura a palavra-chave "cartão" porque pode referir-se a um "cartão de ID". No entanto, se o cartão aparecer apenas na expressão "cartão de crédito", é pouco provável que "cartão" neste conteúdo signifique "Cartão de ID". Assim, pode adicionar "cartão de crédito" como palavra-chave a uma lista de termos que pretende excluir da satisfação do 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 quiser corresponder a vários termos exclusivos, utilize o parâmetro uniqueResults , definido como verdadeiro, conforme mostrado no exemplo seguinte:

<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 tem de estar a outra prova? [patternsProximity attribute]

O seu tipo de informações confidenciais está à procura de um padrão que represente um ID de funcionário e, como parte desse padrão, também está à procura de provas corroborativas, como uma palavra-chave como "ID". Faz sentido que quanto mais perto estiverem estas provas, maior é a probabilidade de o padrão ser um ID de empregado real. Pode determinar a proximidade de outras evidências no padrão à entidade com o atributo patternsProximity necessário do elemento Entity.

Marcação XML a mostrar padrões Atributo de proximidade.

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

Diagrama da janela de proximidade.

O exemplo abaixo ilustra como a janela de proximidade afeta a correspondência do padrão em que o elemento IdMatch para a entidade personalizada do ID do funcionário requer, pelo menos, uma correspondência de corroboração de palavra-chave ou data. Apenas o ID1 corresponde porque para ID2 e ID3, não são encontradas provas de corroboração parciais ou apenas na janela de proximidade.

Diagrama de provas corroborativas e janela de proximidade.

Para o e-mail, o corpo da mensagem e cada anexo são tratados como itens separados. Isto significa que a janela de proximidade não se estende para além do fim de cada um destes itens. Para cada item (anexo ou corpo), as provas idMatch e corroborativas têm de residir nesse item.

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

Quanto mais provas exigirem um padrão, maior é a confiança de que uma entidade real (como o ID do funcionário) foi identificada quando o padrão é correspondido. Por exemplo, tem mais confiança num padrão que requer um número de ID de nove dígitos, data de contratação e palavra-chave em proximidade do que num padrão que requer apenas um número de ID de nove dígitos.

O elemento Pattern tem um atributo confidenceLevel necessário. Pode pensar no valor de confidenceLevel (um valor entre 75/65/85 que indica níveis de confiança Baixo/Médio/Alto) como um ID exclusivo para cada padrão numa 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 a mostrar elementos de Padrão com valores diferentes para o 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 cria uma regra numa política, se não especificar um nível de confiança para a regra a utilizar, essa regra corresponde com base no nível de confiança recomendado para a entidade. Tenha em atenção que o atributo recommendedConfidence é obrigatório para cada ID de Entidade no Pacote de Regras, se não estiver em falta, não poderá guardar políticas que utilizem o Tipo de Informação Confidencial.

Pretende suportar outros idiomas na IU do portal de conformidade? [Elemento Strings Localizado]

Se a sua equipa de conformidade utilizar o portal de conformidade do Microsoft Purview para criar políticas em diferentes regiões e em idiomas diferentes, pode fornecer versões localizadas do nome e descrição do seu tipo de informações confidenciais personalizadas. 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 tem de conter um elemento LocalizedStrings, que contém um Elemento de recurso que referencia o GUID da sua entidade personalizada. Por sua vez, cada Elemento de recurso contém um ou mais elementos Nome e Descrição que cada um utiliza o langcode atributo para fornecer uma cadeia localizada para um idioma específico.

Marcação XML a mostrar 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 precisa de preencher. Pode utilizar a seguinte marcação como modelo e substituir ". . ." marcadores de posição com as suas próprias informações.

Mais importante ainda, tem de gerar um GUID para o RulePack. Anteriormente, 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 Versão também é importante. Quando carrega o pacote de regras pela primeira vez, o Microsoft 365 anota o número da versão. Mais tarde, se atualizar o pacote de regras e carregar uma nova versão, certifique-se de que atualiza o número da versão ou o Microsoft 365 não implementará 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 a mostrar o elemento RulePack.

Validadores

O Microsoft 365 expõe processadores de funções para SITs utilizados frequentemente como validadores. Eis uma lista deles.

Lista de validadores atualmente disponíveis

  • 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

Isto dá-lhe a capacidade de definir o seu próprio RegEx e validá-los. Para utilizar validadores, defina o seu próprio RegEx e utilize a Validator propriedade para adicionar o processador de funções à sua escolha. Uma vez definido, pode utilizar este RegEx num SIT.

No exemplo abaixo, é definida uma expressão regular - Regex_credit_card_AdditionalDelimiters para Cartão de crédito, que é validada com a função soma de verificação para cartão de crédito ao utilizar Func_credit_card como um 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, é definido um validador de soma de verificação para o ID do funcionário para validar o RegEx para 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, é definido um validador de data para uma parte RegEx da qual é 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, os tipos de informações confidenciais personalizados podem ser utilizados 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 desta melhoria, deve utilizar o PowerShell de Conformidade do & de Segurança para importar os seus tipos de informações confidenciais personalizados. Já não pode importá-los do PowerShell do Exchange Online. 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, utilizou 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 carrega o ficheiro XML do pacote de regras, o sistema valida o XML e verifica se existem padrões incorretos conhecidos e problemas de desempenho óbvios. Seguem-se alguns problemas conhecidos que a validação verifica — uma expressão regular:

  • As asserções lookbehind na expressão regular devem ter apenas um comprimento fixo. Asserções de comprimento variável resultarão em erros.

    Por exemplo, "(?<=^|\s|_)" não transmitirá a validação. O primeiro padrão (^) é de comprimento zero, enquanto os dois padrões seguintes (\s e _) têm um comprimento de um. Uma forma alternativa de escrever esta 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 transmitirá a validação.

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

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

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

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

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

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

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

    Por exemplo, .{1,m}asdf não transmitirá a validação. Em vez disso, utilize .asdf.

  • Não é possível ter um repetidor não vinculado (como * ou +) num grupo.

    Por exemplo, (xx)\* e (xx)+ não transmitirá 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 num único inquilino é de 480 KB comprimidos para cumprir os limites do 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 utilizar o Cmdlet do PowerShell, existe um tamanho máximo de retorno dos Dados Deserializados 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 carateres de formatação, como espaços, separadores ou entradas de retorno/linefeed de símbolos. 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, não pode pedir manualmente uma nova tarefa de toda a organização, mas pode pedir manualmente um novo pedido para uma coleção de sites, lista ou biblioteca. Para obter mais informações, consulte Pedido manual de pesquisa e reindexação de um site, biblioteca ou 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