Criar um tipo personalizado de informações confidenciais

A Prevenção contra perda de dados (DLP) no Office 365 inclui vários tipos de informações confidenciais que estão prontos para você usar nas suas políticas DLP. Esses tipos internos podem ajudar a identificar e proteger números de cartão de crédito, números de contas bancárias, números de passaporte e muito mais.

Porém, se você precisa identificar e proteger um tipo diferente de informações confidenciais (como uma ID de funcionário que usa um formato específico para a sua organização), é possível criar um tipo personalizado de informações confidenciais. Um tipo de informações confidenciais é definido em um arquivo XML chamado de pacote de regras.

Este tópico mostra como criar um arquivo XML que define seu próprio tipo personalizado de informações confidenciais. Você precisa saber como criar uma expressão regular. Como exemplo, este tópico cria um tipo personalizado de informações confidenciais que identifica uma ID de funcionário. Você pode usar esse XML de exemplo como ponto de partida para o seu próprio arquivo XML.

Depois de criar um arquivo XML bem formado, você poderá carregá-lo no Office 365 usando o PowerShell. Em seguida, você estará pronto para usar o tipo personalizado de informações confidenciais nas suas políticas DLP e testar se ele está detectando informações confidenciais conforme planejado.

Sumário

Exemplo de XML de um pacote de regras

Veja a seguir um exemplo de XML do pacote de regras que criaremos neste tópico. Os elementos e atributos são explicados nas seções abaixo.

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

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

<Rules>
<!-- Employee ID -->
	<Entity id="E1CC861E-3FE9-4A58-82DF-4BD259EAB378" patternsProximity="300" recommendedConfidence="70">
		<Pattern confidenceLevel="60">
			<IdMatch idRef="Regex_employee_id"/>
		</Pattern>
		<Pattern confidenceLevel="70">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
		</Pattern>
		<Pattern confidenceLevel="80">
			<IdMatch idRef="Regex_employee_id"/>
			<Match idRef="Func_us_date"/>
			<Any minMatches="1">
				<Match idRef="Keyword_badge" minCount=”2”/>
				<Match idRef="Keyword_employee"/>
			</Any>
			<Any minMatches="0" maxMatches="0">
				<Match idRef="Keyword_false_positives_local"/>
				<Match idRef="Keyword_false_positives_intl"/>
			</Any>
		</Pattern>
	</Entity>

	<Regex id="Regex_employee_id">(\s)(\d{9})(\s)</Regex>
	<Keyword id="Keyword_employee">
		<Group matchStyle="word">
			<Term>Identification</Term>
			<Term>Contoso Employee</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_badge">
		<Group matchStyle="string">
			<Term>card</Term>
			<Term>badge</Term>
			<Term caseSensitive="true">ID</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_false_positives_local">
		<Group matchStyle="word">
			<Term>credit card</Term>
			<Term>national ID</Term>
		</Group>
	</Keyword>
	<Keyword id="Keyword_false_positives_intl">
		<Group matchStyle="word">
			<Term>identity card</Term>
			<Term>national ID</Term>
			<Term>EU debit card</Term>
		</Group>
	</Keyword>
	<LocalizedStrings>
		<Resource idRef="E1CC861E-3FE9-4A58-82DF-4BD259EAB378">
			<Name default="true" langcode="en-us">Employee ID</Name>
			<Description default="true" langcode="en-us">
			A custom classification for detecting Employee IDs.
			</Description>
			<Name default="true" langcode="de-de">Name for German locale</Name>
			<Description default="true" langcode="de-de">
			Description for German locale.
			</Description>
		</Resource>
	</LocalizedStrings>
</Rules>
</RulePackage>

Quais são as suas principais necessidades? [elementos Rule, Entity e Pattern]

Antes de começar, é útil compreender a estrutura básica do esquema XML de uma regra e como você pode usar essa estrutura para definir seu tipo personalizado de informações confidenciais de modo que ele identifique o conteúdo certo.

Uma regra define uma ou mais entidades (tipos de informações confidenciais), e cada entidade define um ou mais padrões. Um padrão é o elemento que a DLP procura ao avaliar conteúdo como emails e documentos.

(Uma breve observação sobre a terminologia: se você está familiarizado com políticas de DLP, sabe que uma política contém uma ou mais regras formadas por condições e ações. No entanto, neste tópico, a marcação XML usa uma regra para significar os padrões que definem uma entidade, também conhecida como um tipo de informações confidenciais. Portanto, neste tópico, ao ver uma regra, pense em entidade ou tipo de informações confidenciais, e não em condições e ações.)

O cenário mais simples: entidade com um padrão

Aqui está o cenário mais simples. Você quer que sua política DLP identifique conteúdo que inclua a ID de funcionário da sua organização, formatada como um número de nove dígitos. Portanto, o padrão faz referência a uma expressão regular contida na regra que identifica números de nove dígitos. Qualquer conteúdo que inclua um número de nove dígitos satisfaz esse padrão.

Diagrama de entidade com um padrão

No entanto, embora simples, esse padrão pode identificar muitos falsos positivos ao combinar conteúdo que inclui qualquer número de nove dígitos que não é necessariamente uma ID de funcionário.

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

Por esse motivo, é mais comum definir uma entidade usando mais de um padrão, cada um identificando evidências de suporte (como uma palavra-chave ou data) além da entidade (como um número de nove dígitos).

Por exemplo, para aumentar as chances de identificar um conteúdo que inclui uma ID de funcionário, além do número de nove dígitos, você pode definir outro padrão que também identifica a data de contratação e ainda outro padrão que identifica tanto uma data de contratação quanto uma palavra-chave (como "ID do funcionário").

Diagrama de entidade com vários padrões

Observe alguns aspectos importantes dessa estrutura:

  • Padrões que exigem mais evidência têm maior nível de confiança. Isso é útil porque, mais tarde, quando você usar esse tipo de informações confidenciais em uma política DLP, poderá usar ações mais restritivas (como bloquear conteúdo) com apenas as correspondências de maior confiança e poderá usar ações menos restritivas (como enviar notificação) com as correspondências de menor confiança.

  • Os elementos IdMatch e Match de suporte fazem referência a expressões regulares e palavras-chave que são na verdade filhos do elemento Rule, e não o Padrão. Esses elementos de suporte são referenciados pelo Padrão, mas são incluídos na Regra. Isso 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 você precisa identificar? [elemento Entity, atributo id]

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

Nomeie a entidade e gere seu GUID

Adicione os elementos Rules e Entity. Em seguida, adicione um comentário que contenha o nome da sua entidade personalizada – neste exemplo, ID do funcionário. Mais tarde, você adicionará o nome da entidade à seção de cadeias de caracteres localizadas, e é esse nome que aparecerá na interface do usuário quando uma política DLP for criada.

Em seguida, gere um GUID para a sua entidade. Há várias maneiras de gerar GUIDs, mas você pode fazer isso facilmente no PowerShell digitando [guid]::NewGuid(). Mais tarde, você também adicionará a GUID de entidade à seção de cadeias de caracteres localizadas.

Marcação XML mostrando os elementos Rules e Entity

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

O padrão contém a lista daquilo que o tipo de informações confidenciais está procurando. Isso pode incluir expressões regulares, palavras-chave e funções internas (que realizam tarefas como executar expressões regulares para encontrar datas ou endereços). Tipos de informações confidenciais podem ter vários padrões com confianças exclusivas.

O que todos os padrões abaixo têm em comum é que eles fazem referência à mesma expressão regular, que procura um número de nove dígitos (\d\{9\)} delimitado por um espaço em branco (\s) … (\s). Essa expressão regular é referenciada pelo elemento IdMatch e é a exigência comum de todos os padrões que procuram a entidade ID do funcionário. IdMatch é o identificador que o padrão está tentando corresponder, como a ID do funcionário, o número do cartão de crédito ou o número do seguro social. Um elemento Pattern deve ter exatamente um elemento IdMatch.

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

Quando satisfeito, um padrão retorna uma contagem e um nível de confiança, que você pode usar nas condições da sua política DLP. Ao adicionar uma condição para detectar um tipo de informações confidenciais a uma política DLP, você pode editar a contagem e o nível de confiança conforme mostrado aqui. O nível de confiança (também chamado de precisão de correspondência) é explicado mais adiante neste tópico.

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

Ao criar sua expressão regular, lembre-se de que existem possíveis problemas para considerar. Por exemplo, se você escrever e carregar uma expressão regular que identifica muito conteúdo, isso poderá afetar o desempenho. Para saber mais sobre esses possíveis problemas, veja a seção Possíveis problemas de validação para considerar, mais adiante.

Você deseja exigir evidências adicionais? [elemento Match, atributo minCount]

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

Um Padrão pode incluir vários elementos Match, que podem ser incluídos diretamente no elemento Pattern ou combinados com o uso do elemento Any. Elementos Match são unidos por um operador AND implícito; todos os elementos Match devem ser satisfeitos para que o padrão seja correspondido. É possível o elemento Any para introduzir operadores AND ou OR (mais sobre isso em uma seção posterior).

É possível usar o atributo opcional minCount para especificar quantas instâncias de uma correspondência precisam ser encontradas para cada um dos elementos Match. Por exemplo, você pode especificar que um padrão apenas será satisfeito quando pelo menos duas palavras-chave de uma lista de palavras-chave forem encontradas.

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

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

Ao identificar informações confidenciais, como uma ID de funcionário, muitas vezes você deseja exigir palavras-chave como evidências comprobatórias. Por exemplo, além de corresponder um número de nove dígitos, você pode querer procurar palavras como "cartão", "crachá" ou "ID". Para fazer isso, use o elemento Keyword. O elemento Keyword tem um atributo id que pode ser referenciado por vários elementos Match em vários padrões ou entidades.

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

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

  • matchStyle=”string” A correspondência por cadeia de caracteres identifica cadeias de caracteres independentemente daquilo que as circunda. Por exemplo, "id" terá correspondência com "bid" e "idea". Apenas use "string" quando precisar corresponder palavras asiáticas ou se a sua palavra-chave puder ser incluída como parte de outras cadeias de caracteres.

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

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

Expressões regulares [elemento Regex]

Neste exemplo, a entidade ID do funcionário já usa o elemento IdMatch para fazer referência a uma expressão regular para o padrão – um número de nove dígitos delimitado por espaços em branco. Além disso, um padrão pode usar um elemento Match para fazer referência a um elemento Regex adicional a fim de identificar evidências comprobatórias, como um número de cinco ou nove dígitos no formato de um código postal americano.

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

Além dos tipos internos de informações confidenciais, a DLP também inclui funções internas capazes de identificar evidências comprobatórias, como uma data no formato dos EUA, uma data no formato europeu, uma data de vencimento ou um endereço nos EUA. A DLP não dá suporte ao carregamento das suas próprias funções personalizadas, porém, quando você criar um tipo personalizado de informações confidenciais, sua entidade poderá fazer referência às funções internas.

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

Para saber mais, veja O que as funções DLP procuram.

Marcação XML mostrando o elemento Match fazendo referência a uma função interna

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

Em um elemento Pattern, todos os elementos IdMatch e Match são unidos por um operador AND implícito – todas as correspondências devem ser satisfeitas para que o padrão possa ser satisfeito. No entanto, é possível criar uma lógica de correspondência mais flexível usando o elemento Any para agrupar elementos Match. Por exemplo, você pode usar o elemento Any para corresponder todos os seus elementos Match filhos, nenhum deles ou ainda um subconjunto exato dos mesmos.

O elemento Any tem atributos minMatches e maxMatches opcionais que você pode usar para definir quantos dos elementos Match filhos devem ser satisfeitos para que o padrão possa ser correspondido. Observe que esses atributos definem o número de elementos Match que devem ser satisfeitos, e não o número de instâncias de evidências 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 atributo minCount para um elemento Match (veja acima).

Corresponder pelo menos um elemento Match filho

Se você quiser exigir que apenas um número mínimo de elementos Match seja atendido, poderá usar o atributo minMatches. Com efeito, esses elementos Match são unidos por um operador OR implícito. Esse elemento Any será satisfeito se uma data no formato dos EUA ou uma palavra-chave de qualquer uma das listas for encontrada.

Marcação XML mostrando o elemento Any com o atributo minMatches

Corresponder um subconjunto exato de qualquer elemento Match filho

Se você quiser exigir que um número exato de elementos Match seja atendido, poderá definir minMatches e maxMatches como o mesmo valor. Esse elemento Any apenas será satisfeito se exatamente uma data ou uma palavra-chave for encontrada – qualquer coisa além disso fará com que o padrão não seja correspondido.

Marcação XML mostrando o elemento Any com os atributos minMatches e maxMatches

Corresponder nenhum dos elementos Match filhos

Se você pretende exigir a ausência de evidências específicas para atender a um padrão, defina minMatches e maxMatches como 0. Convém fazer isso quando você tem uma lista de palavras-chave ou outras evidências propensas a indicar falsos positivos.

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

Marcação XML mostrando o valor zero do atributo maxMatches

O quão perto da entidade a outra evidência deve estar? [atributo patternsProximity]

Seu tipo de informações confidenciais está à procura de um padrão que represente uma ID de funcionário e, como parte desse padrão, também está à procura de evidências comprobatórias, por exemplo, uma palavra-chave como "ID". Faz sentido que, quanto mais próxima essa evidência estiver, maiores serão as chances de que o padrão seja de fato um ID de funcionário. Usando o atributo necessário patternsProximity do elemento Entity, você pode determinar o quão próximas as outras evidências do padrão devem estar da entidade.

Marcação XML mostrando o atributo patternsProximity

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

Diagrama da janela de proximidade

O exemplo abaixo ilustra como a janela de proximidade afeta a correspondência de padrões, em que o elemento IdMatch da entidade personalizada ID do funcionário requer pelo menos uma correspondência comprobatória da palavra-chave ou da data. Apenas ID1 tem correspondência pois, para ID2 e ID3, nenhuma evidência comprobatória, ou apenas uma parcial, foi localizada dentro da janela de proximidade.

Diagrama da janela de proximidade e evidências comprobatórias

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

Quais são os níveis de confiança certos 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 ID do funcionário) foi identificada quando esse padrão for correspondido. Por exemplo, você tem mais confiança em um padrão que exige uma ID de nove dígitos, uma data de contratação e uma palavra-chave com proximidade imediata do que em um padrão que exige apenas uma ID de nove dígitos.

O elemento Pattern tem um atributo confidenceLevel necessário. Você pode pensar no valor de confidenceLevel (um inteiro entre 1 e 100) como uma ID exclusiva para cada padrão em uma entidade – os padrões em uma entidade devem ter níveis de confiança diferentes que você atribui. O valor preciso do inteiro não importa – basta escolher números que façam sentido para a sua equipe de conformidade. Depois de carregar seu tipo personalizado de informações confidenciais e criar uma política DLP, você poderá fazer referência a esses níveis de confiança nas condições das regras que criar.

Marcação XML mostrando elementos Pattern com valores diferentes para 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. Ao criar uma regra em uma política DLP, se você não especificar um nível de confiança a ser usado pela regra, esta será correspondida com base no nível de confiança recomendado para a entidade.

Você deseja oferecer suporte a outros idiomas na interface do usuário do Centro de Conformidade e Segurança? [elemento LocalizedStrings]

Se a sua equipe de conformidade usa o Centro de Conformidade e Segurança do Office 365 para criar políticas DLP em localidades e idiomas diferentes, você pode fornecer versões localizadas do nome e da descrição do seu tipo personalizado de informações confidenciais. Quando sua equipe de conformidade usar o Office 365 em um idioma compatível, seus membros verão o nome localizado na interface do usuário.

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

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

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

Observe que você apenas utiliza cadeias de caracteres localizadas para como o seu tipo personalizado de informações confidenciais é exibido na interface do usuário do Centro de Conformidade e Segurança. Não é possível usar cadeias de caracteres localizadas para fornecer diferentes versões localizadas de uma lista de palavra-chave ou de uma expressão regular.

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

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

O mais importante, você precisará gerar um GUID para o RulePack. Acima, 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 PowerShell digitando [guid]::NewGuid().

O elemento Version também é importante. Quando você carregar seu pacote de regras pela primeira vez, o Office 365 anotará o número de versão. Mais tarde, se você atualizar o pacote de regras e carregar uma nova versão, certifique-se de atualizar o número da versão, ou o Office 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>

Quando concluído, seu elemento RulePack deve ter a seguinte aparência.

Marcação XML mostrando o elemento RulePack

Alterações no Exchange Online

Anteriormente, talvez você tenha usado o PowerShell do Exchange Online para importar tipos de informações confidenciais personalizados para DLP. Agora, os tipos de informações confidenciais personalizados podem ser usados no Centro de Administração do Exchange e no Centro de Conformidade e Segurança. Como parte dessa melhoria, você deve usar o PowerShell do Centro de Conformidade e Segurança para importar tipos de informações confidenciais personalizados. Não é mais possível importá-los do Exchange PowerShell. Os tipos de informações confidenciais personalizados continuarão a funcionar como antes. No entanto, pode levar até uma hora para que as alterações feitas nos tipos de informações confidenciais personalizados no Centro de Conformidade e Segurança apareçam no Centro de Administração do Exchange.

Observe que, no Centro de Conformidade e Segurança, você usa o cmdlet DlpSensitiveInformationTypeRulePackage para carregar um pacote de regras. Anteriormente, no Centro de Administração do Exchange, você usava o cmdlet ClassificationRuleCollection.

Carregar seu pacote de regras

Para carregar seu pacote de regras, faça o seguinte.

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

  2. Conectar-se ao Centro de Conformidade e Segurança do Office 365 usando o PowerShell remoto

  3. No PowerShell do Centro de Conformidade e Segurança do Office 365, digite New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\custompath\MyNewRulePack.xml" -Encoding Byte).

    Certifique-se de usar a localização de arquivo na qual o pacote de regras está realmente armazenado. C:\custompath\ é um espaço reservado.

  4. Para confirmar, digite Y e pressione ENTER.

  5. Verifique se o novo tipo de informações confidenciais foi carregado, digitando Get-DlpSensitiveInformationType para ver uma lista de todos os tipos confidenciais. Observando a coluna Fornecedor, você pode separar rapidamente os tipos de informações confidenciais personalizados dos internos. É possível filtrar a lista para um tipo específico de informações confidenciais, executando Get-DlpSensitiveInformationType -Identity "nome do tipo de informações confidenciais".

Possíveis problemas de validação para considerar

Ao carregar seu arquivo XML de pacote de regras, o sistema valida o XML e verifica se há padrões inválidos conhecidos e problemas de desempenho óbvios. Veja a seguir alguns problemas conhecidos procurados pela validação – uma expressão regular:

  • Não pode começar ou terminar com um alternador "|", que corresponde tudo por ser considerado uma correspondência vazia.

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

  • Não pode começar ou terminar com um padrão ".{0,m}", que não tem finalidade funcional e apenas prejudica o desempenho.

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

  • Não pode ter caracteres com os repetidores "{0,m}" ou "{1,m}" em grupos.

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

  • Não pode começar ou terminar com ".{1,m}"; em vez disso, use simplesmente "."

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

  • Não pode ter um repetidor não vinculado (como "*" ou "+") em um grupo.

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

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 destas mensagens de erro:

  • Quantificadores genéricos que correspondem mais conteúdo do que o esperado (por exemplo, ‘+’, ‘*’)

  • Declarações de pesquisa

  • Agrupamento complexo em conjunto com quantificadores gerais

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

A DLP usa o rastreador de pesquisa para identificar e classificar informações confidenciais no conteúdo de sites. O conteúdo em sites do SharePoint Online e do OneDrive for Business é novamente rastreado 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 Office 365, não é possível solicitar manualmente um novo rastreamento de um locatário inteiro, mas você pode fazer isso para um conjunto de sites, uma lista ou uma biblioteca – veja Solicitar manualmente o rastreamento e a reindexação de um site, uma biblioteca ou uma lista.

Remover um tipo personalizado de informações confidenciais

  1. Conectar-se ao Centro de Conformidade e Segurança do Office 365 usando o PowerShell remoto

  2. No PowerShell do Centro de Conformidade e Segurança, siga um destes procedimentos:

    • Para remover um pacote de regras inteiro e todas as entidades que ele contém

      Digite Remove-DlpSensitiveInformationTypeRulePackage "NameOfYourRulePack" – para o exemplo de XML acima, você digitaria Remove-DlpSensitiveInformationTypeRulePackage "Pacote de regras personalizado para ID do funcionário".

      Observe que, para identificar seu pacote de regras, você pode usar o elemento <Name> (para qualquer idioma) no elemento <Rule Pack> ou o GUID do atributo id do elemento RulePack.

    • Para remover uma única entidade de um pacote de regras

      Você deve carregar uma nova versão do seu pacote de regras com essa entidade específica removida, usando Set-DlpSensitiveInformationTypeRulePackage. Será necessário garantir que nenhuma política DLP ou regra de transporte do Exchange ainda faça referência ao tipo de informações confidenciais antes de removê-lo.

  3. Para confirmar, digite Y e pressione ENTER.

  4. Verifique se a nova regra foi removida, digitando Get- DlpSensitiveInformationType, o que deixará de exibir o nome do seu tipo de informações confidenciais.

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

Mais informações

Expanda suas habilidades
Explore o treinamento
Obtenha novos recursos primeiro
Ingressar no Office Insider

Essas informações foram úteis?

Obrigado por seus comentários!

Agradecemos pelos seus comentários! Parece que pode ser útil conectar você a um de nossos agentes de suporte do Office.

×