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

Este artigo mostra como criar um arquivo de pacote de regras XML que define tipos de informações confidenciais personalizados. Este artigo descreve um tipo de informação confidencial personalizado que detecta números de ID de funcionários. 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ê poderá carregá-lo no Microsoft 365 usando o PowerShell. Em seguida, você estará pronto para usar seu tipo de informação confidencial personalizado em políticas. Você pode testar sua eficácia na detecção das informações confidenciais conforme pretendido.

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ú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). Os engenheiros de Suporte da Microsoft podem fornecer suporte limitado para esse recurso, mas não podem garantir que as sugestões personalizadas de correspondência de conteúdo atenderão 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 esteja funcionando conforme o esperado com um único exemplo de conteúdo específico.

Para obter mais informações, consulte a seção Possíveis problemas de validação a serem observados .

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

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 sobre elementos Regra, Entidade e Padrão; Elementos de correspondência; combinações de evidências; proximidade; níveis de confiança; LocalizedStrings; e marcação RulePack.

<?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="00aa00aa-bb11-cc22-dd33-44ee44ee44ee" 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="00aa00aa-bb11-cc22-dd33-44ee44ee44ee">
      <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? [Elementos Regra, Entidade, Padrão]

É importante que você entenda a estrutura básica do esquema XML de uma regra. Sua compreensão da estrutura ajuda seu tipo de informação confidencial personalizado a identificar o conteúdo correto.

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 a "condições" ou "ações" que são 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 contenha 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.

Porém, 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 sejam 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, você normalmente 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, datas ou outro texto adicionais 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 um conteúdo que contenha uma ID de funcionário, você pode definir outros padrões a serem procurados:

• 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 funcionário".

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 confiança mais baixas.

• 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 a elementos de apoio, mas estão incluídas no Rule. Esse 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.

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

Uma entidade é um tipo de informação confidencial, como um número de card 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

Use as etapas a seguir para criar a marcação de entidade e gerar seu identificador exclusivo:

1. No editor XML de sua escolha, adicione os Rules elementos and Entity .
2. Adicione um comentário que contenha o nome de sua entidade personalizada, como ID do funcionário. Posteriormente, você adiciona o nome da entidade à seção de 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, no Windows PowerShell, você pode executar o comando [guid]::NewGuid(). Posteriormente, você também adicionará o GUID à seção de cadeias de caracteres localizadas da entidade.

Qual padrão você deseja combinar? [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. As funções realizam 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 deve tentar corresponder. Um Pattern elemento deve ter exatamente um IdMatch elemento.

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

Expressões regulares são poderosas, portanto, há problemas que você precisa conhecer. Por exemplo, um RegEx que identifica muito conteúdo pode afetar o desempenho. Para saber mais sobre validação de expressões regulares e problemas de desempenho, consulte a seção Possíveis problemas de validação a serem observados .

Deseja exigir evidências adicionais? [Match element, minCount attribute]

Além de IdMatch, um padrão pode usar o Match elemento para exigir evidências 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 usando o Any elemento.

Match são unidos com um operador AND 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. Para obter detalhes, consulte a seção Diferentes combinações de evidências .

Você pode usar o atributo optional 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 será atendido somente quando pelo menos duas palavras-chave de uma lista de palavras-chave forem encontradas.

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

A identificação de 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 "card", "badge" ou "ID" usando o elemento Keyword. 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ços em branco ou outros delimitadores. Você deve sempre usar palavras , a menos que precise combinar 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 as rodeia. Por exemplo, "ID" corresponde a "bid" e "idea". Use string somente quando precisar combinar palavras asiáticas ou se a palavra-chave estiver incluída 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 à palavra-chave, incluindo letras minúsculas e maiúsculas.

Expressões regulares [elemento Regex]

Neste exemplo, a entidade employee 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 espaços em branco. Além disso, um padrão pode usar um Match elemento para fazer referência a outro Regex elemento para identificar evidências comprobatórias, como um número de cinco 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 usar funções internas para identificar evidências corroborantes. Por exemplo, uma data dos EUA, uma data da UE, uma data de validade ou um endereço dos EUA. O Microsoft 365 não dá suporte ao upload 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 de 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ção confidencial.

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

Em um Pattern elemento, todos os IdMatch elementos and Match são unidos com um operador AND implícito. Em outras palavras, todas as correspondências devem ser satisfeitas 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 que maxMatches você pode usar para definir quantos dos elementos filho Match devem ser atendidos antes que o padrão seja correspondido. Os minMatches atributos and maxMatches 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, conforme descrito na seção Corresponder elemento, atributo minCount .

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 com 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 com o mesmo valor. Esse Any elemento será satisfeito somente se exatamente uma data ou uma palavra-chave for encontrada. Se houver mais correspondências, o padrão não será correspondente.

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

Não corresponder a nenhum dos elementos de "correspondência" dos filhos

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

Por exemplo, a entidade de ID do funcionário procura a palavra-palavra-chave "card" porque ela pode se referir a um "ID card". No entanto, se card aparecer apenas na frase "credit card", "card" neste conteúdo provavelmente não significa "ID card". Portanto, você pode adicionar "credit card" como uma palavra-chave a uma lista de termos que deseja 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>

Correspondam 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 estar a outra evidência? [atributo patternsProximity]

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

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

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 de ID do funcionário requer pelo menos uma correspondência corroborante de palavra-chave ou data. Apenas o ID1 corresponde porque, para o ID2 e o ID3, nenhuma evidência corroborante ou apenas parcial é encontrada na 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), tanto o idMatch quanto a evidência corroborativa precisam residir nesse item.

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

Quanto mais evidências um padrão exigir, mais confiança você terá 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 exige um número de identificação de nove dígitos, data de contratação e palavra-chave próxima do que em um padrão que requer apenas um número de identificação de nove dígitos.

O elemento Pattern tem um atributo confidenceLevel necessário. Você pode pensar no valor de confidenceLevel (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.

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 usar, essa regra corresponderá com base no nível de confiança recomendado para a entidade. O atributo recommendedConfidence é obrigatório para cada ID de Entidade no Pacote de Regras. Se estiver ausente, você não poderá salvar políticas que usam o Tipo de Informações Confidenciais.

Deseja oferecer suporte a outros idiomas na interface do usuário do portal do Purview? [Elemento Strings Localizado]

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

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

Você usa cadeias de caracteres localizadas apenas para como seu tipo de informações confidenciais personalizado aparece na interface do usuário 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 seguinte marcação como modelo e substituir o ". . ." espaços reservados com suas próprias informações.

Mais importante ainda, 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. Quando você carrega seu pacote de regras pela primeira vez, o Microsoft 365 anota 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.

Validadores

O Microsoft 365 expõe processadores de função para SITs comumente usados como validadores. Veja uma lista deles.

Lista de validadores disponíveis no momento

As seguintes funções de validador estão atualmente disponíveis para uso em definições personalizadas de tipo de informações confidenciais:

• 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 lhe dá a capacidade de definir seu próprio RegEx e validá-lo. Para usar validadores, defina seu próprio RegEx e use a Validator propriedade para adicionar o processador de função de sua escolha. Depois de definido, você pode usar esse RegEx em um SIT.

No exemplo abaixo, uma expressão regular - Regex_credit_card_AdditionalDelimiters é definida para Credit card, que é então validada usando a função checksum para card 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 soma de verificação para a ID do funcionário é definido 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 data

Neste exemplo, um validador de data é definido 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, seus tipos de informações confidenciais personalizados podem ser usados no Centro de Administração do Exchange e no portal do Microsoft Purview. Como parte dessa melhoria, você deve usar o PowerShell de Segurança & Conformidade 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ê usava 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 se há padrões ruins conhecidos e problemas óbvios de desempenho. Aqui estão alguns problemas conhecidos que a validação verifica se há uma expressão regular:

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

  Por exemplo, "(?<=^|\s|_)" não passará na validação. O primeiro padrão (^) tem comprimento zero, enquanto os próximos dois 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 nem terminar com alternador |, que corresponde a tudo porque é considerado uma correspondência vazia.

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

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

  Por exemplo, .{0,50}ASDF ou ASDF.{0,50} não passará na 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á na validação.

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

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

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

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

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

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

• O padrão regex deve conter exatamente um grupo de captura primário (o único grupo de captura). Use grupos sem captura para qualquer prefixo/sufixo (por exemplo: (?:prefix)(primary capturing group)(?:suffix)). Consolide variantes de correspondência dentro de um único grupo de captura usando |; padrões como (group1)|(group2) são rejeitados.

  Por exemplo, (?:[\s,;])([A-Z]{2}[0-9]{3})(?:[\s,;])|(?:[\s,;])([A-Z]{2}[A-Z]{4}[0-9])(?:[\s,;]) não passará na validação porque contém vários grupos de captura. Em vez disso, use (?:[\s,;])([A-Z]{2}[0-9]{3}|[A-Z]{2}[A-Z]{4}[0-9])(?:[\s,;]).

• 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 Personalizado 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 é de 480 KB compactados 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 usar o cmdlet do PowerShell, há um tamanho máximo de retorno dos dados desserializados de aproximadamente 1 megabyte. Isso afeta 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 formatação de caracteres, como espaços, tabulações ou entradas de retorno/avanço de linha de carro. 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.

Para reavaliar o conteúdo em vários locais ao mesmo tempo, você pode criar uma verificação usando a classificação sob demanda. Saiba mais sobre a classificação sob demanda\

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>

Recursos relacionados para tipos de informações confidenciais personalizados

• Saiba mais sobre a Prevenção Contra Perda de Dados do Microsoft Purview
• Definições da entidade do tipo de informações confidenciais
• Funções de tipo de informações confidenciais