Crear un tipo de información confidencial

Prevención de pérdida de datos (DLP) de Office 365 incluye muchos tipos de información confidencial listos para que los use en sus directivas DLP. Estos tipos integrados pueden ayudar a identificar y proteger números de tarjeta de crédito, números de cuenta bancaria, números de pasaporte, etc.

Si necesita identificar y proteger otro tipo de información confidencial, como un Id. de empleado que usa un formato específico en su organización, puede crear un tipo personalizado. Un tipo de información confidencial se define en un archivo XML denominado “paquete de reglas”.

En este tema, se muestra cómo crear un archivo XML que defina su propio tipo de información confidencial personalizado. Necesitará saber cómo crear una expresión regular. Por ejemplo, en este caso se crea un tipo de información confidencial personalizado que identifica un Id. de empleado. Puede usar el XML de este ejemplo como punto de partida para su propio archivo XML.

Una vez que haya creado un archivo XML con formato correcto, puede cargarlo en Office 365 mediante PowerShell. A partir de ese momento, ya podrá usar su tipo de información confidencial personalizado en las directivas DLP y comprobar que detecta la información según lo previsto.

Contenido

XML de ejemplo de paquete de reglas

Aquí puede ver el XML de ejemplo del paquete de reglas que vamos a crear en este tema. Los elementos y atributos se describen en la sección siguiente.

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

¿Cuáles son sus principales requisitos? [elementos Rule, Entity, Pattern]

Antes de empezar, conviene comprender la estructura básica del esquema XML de una regla y cómo puede usarse esta estructura para definir el tipo de información confidencial personalizado de modo que identifique el contenido correcto.

Una regla define una o más entidades (tipos de información confidencial) y cada entidad define uno o varios patrones. Un patrón es lo que busca DLP al evaluar contenido como correo electrónico y documentos.

(Nota rápida sobre terminología: Si está familiarizado con las directivas DLP, sabe que una directiva contiene una o más reglas que constan de condiciones y acciones. Pero en este tema, el formato XML usa una regla para indicar los patrones que definen una entidad, también conocida como tipo de información confidencial. Por lo que en este tema, cuando vea una regla, piense en entidad o tipo de información confidencial, no en condiciones y acciones).

Escenario más sencillo: entidad con un solo patrón

Aquí puede ver el escenario más sencillo. Quiere que la directiva DLP identifique contenido que incluya el Id. de empleado de su organización, cuyo formato sea un número de nueve dígitos. Por lo que el patrón se refiere a una expresión regular contenida en la regla que identifica los números de nueve dígitos. Cualquier contenido que incluya un número de nueve dígitos se ajusta al patrón.

Diagrama de entidad con un patrón

Pero, aunque sencillo, este patrón puede identificar muchos falsos positivos al encontrar contenido que incluye cualquier número de nueve dígitos que no necesariamente es un Id. de empleado

Escenario más frecuente: entidad con varios patrones

Por este motivo, lo más habitual es definir una entidad con varios patrones, donde los patrones identifican evidencia auxiliar (como una palabra clave o una fecha) además de la entidad (como un número de nueve dígitos).

Por ejemplo, para aumentar las probabilidades de identificar contenido que incluya un Id. de empleado, puede definir otro patrón que identifique también una fecha de contratación y definir todavía otro patrón que identifique una fecha de contratación y una palabra clave (como "Id. de empleado"), además del número de nueve dígitos.

Diagrama de entidad con múltiples patrones

Tenga en cuenta dos aspectos importantes de esta estructura:

  • Los patrones que requieren más evidencia tienen un nivel de confianza mayor. Esto resulta útil porque al usar este tipo de información confidencial en una directiva DLP más adelante, puede usar acciones más restrictivas (como bloquear contenido) solo con las coincidencias de mayor confianza y usar acciones menos restrictivas (como enviar una notificación) con las coincidencias de menor confianza.

  • Los elementos auxiliares IdMatch y Match hacen referencia a expresiones regulares y palabras clave que son en realidad secundarios del elemento Rule, no del elemento Pattern. Pattern hace referencia a estos elementos auxiliares, que se incluyen en el elemento Rule. Esto significa que varios patrones y entidades podrán hacer referencia a una única definición de un elemento auxiliar, como una expresión regular o una lista de palabras clave.

¿Qué entidad tiene que identificar? [elemento Entity, atributo id]

Una entidad es un tipo de información confidencial, como un número de tarjeta de crédito, que tiene un patrón bien definido. Cada entidad tiene un GUID único como Id.

Asignar nombre a la entidad y generar su GUID

Agregue los elementos Rules y Entity. Luego agregue un comentario que contenga el nombre de la entidad personalizada (en este caso, Employee ID). Posteriormente, asignará el nombre de la entidad a la sección de cadenas localizadas, y ese será el nombre que aparece en la interfaz de usuario al crear una directiva DLP.

Después, genere un GUID para la entidad. Hay varias maneras de generar los GUID, pero puede hacerlo fácilmente en PowerShell escribiendo [guid]:: NewGuid(). Posteriormente, agregará también el GUID de la entidad a la sección de cadenas localizadas.

Formato XML que muestra elementos de Rules y Entity

¿Qué patrón quiere encontrar? [elemento Pattern, elemento IdMatch, elemento Regex]

El patrón contiene la lista de lo que busca el tipo de información confidencial. Puede incluir expresiones regulares, palabras clave y funciones integradas (que ejecutan tareas tales como ejecutar expresiones regulares para encontrar fechas o direcciones). Los tipos de información confidencial pueden tener varios patrones con confianzas únicas.

Lo que los patrones siguientes tienen en común es que todos hacen referencia a la misma expresión regular, que busca un número de nueve dígitos (\d{9}) entre espacios en blanco (\s) … (\s). El elemento IdMatch hace referencia a esta expresión regular, que es el requisito común para todos los patrones que buscan la entidad Id. de empleado. IdMatch es el identificador que el patrón intenta encontrar, como Employee ID, un número de tarjeta de crédito o un número de la seguridad social. Un elemento Pattern debe tener exactamente un solo elemento IdMatch.

Formato XML que muestra varios elementos Pattern con referencia a un único elemento Regex

Cuando se cumple, un patrón devuelve un recuento y un nivel de confianza, que puede usarse usar en las condiciones de la directiva DLP. Cuando agregue una condición que detecte un tipo de información confidencial en una directiva DLP, puede editar el recuento y el nivel de confidencia, tal y como se muestra aquí. El nivel de confidencia (también denominado precisión de coincidencia) se describe más adelante en este tema.

Opciones de recuento de instancias y precisión de coincidencia

Cuando cree una expresión regular, tenga en cuenta que existen posibles problemas que tiene que considerar. Por ejemplo, si escribe y carga un elemento Regex que identifica demasiado contenido, puede afectar al rendimiento. Para obtener más información sobre estos posibles problemas, vea más adelante la sección Posibles problemas de validación que tiene que considerar.

¿Quiere exigir una evidencia adicional? [Elemento Match, atributo minCount]

Además del IdMatch, un patrón puede usar el elemento Match para exigir evidencia auxiliar adiciona, como una palabra clave, expresión regular, fecha o dirección.

Un Pattern puede incluir varios elementos Match; Pueden incluirse directamente en el elemento Pattern o combinados mediante el elemento Any. Los elementos Match se combinan mediante un operador AND implícito; todos los elementos Match deben cumplirse para que el patrón coincida. Puede usar el elemento Any para introducir los operadores AND u OR (más información al respecto en una sección posterior).

Puede usar el atributo opcional minCount para especificar cuántas instancias de una coincidencia es necesario encontrar por cada uno de los elementos Match. Por ejemplo, puede especificar que un patrón solo se cumpla cuando se encuentren como mínimo dos palabras clave de una lista de palabras clave.

Formato XML que muestra el elemento Match con el atributo minOccurs

Palabras clave [elementos Keyword, Group y Term, atributos matchStyle y caseSensitive]

Cuando se identifica información confidencial, como un Id. de empleado, a menudo quieren exigirse palabras clave como evidencia de corroboración. Por ejemplo, puede que además de encontrar un número de nueve dígitos, quiera buscar palabras tales como "tarjeta", "distintivo" o "Id.". Para ello, use el elemento Keyword. El elemento Keyword tiene un atributo id al que pueden hacer referencia varios elementos Match en muchos patrones o entidades.

Las palabras clave se incluyen como lista de elementos Term en un elemento Group. El elemento Group tiene un atributo matchStyle con dos valores posibles:

  • matchStyle="palabra". La coincidencia de palabra identifica palabras completas entre espacios en blanco u otros delimitadores. Debe usar siempre una palabra salvo que tenga que encontrar coincidencias parciales de palabras o palabras en idiomas asiáticos.

  • matchStyle="cadena". La coincidencia de cadena identifica cadenas independientemente de lo que las rodee. Por ejemplo, "id" encontrará "guid" e "idea". Use una cadena solo cuando tenga que encontrar palabras asiáticas o si la palabra clave puede formar parte de otras cadenas.

Por último, puede usar el atributo caseSensitive del elemento Term para especificar que el contenido debe coincidir exactamente con la palabra clave, incluidas las letras mayúsculas y minúsculas.

Formato XML que muestra elementos Match con referencia a palabras clave

Expresiones regulares [elemento Regex]

En este ejemplo, la entidad Id. de empleado ya usa el elemento IdMatch para hacer referencia a una expresión regular para el patrón: un número de nueve dígitos entre espacios en blanco. Además, un patrón puede usar un elemento Match que haga referencia a un elemento Regex adicional para identificar evidencia de corroboración, como, por ejemplo, un número de cinco o nueve dígitos con formato de código postal de Estados Unidos.

Patrones adicionales tales como fechas o direcciones [funciones integradas]

Además de los tipos de información confidencial integrados, DLP incluye también funciones integradas que pueden identificar evidencia de corroboración, por ejemplo, una fecha de Estados Unidos, una fecha de la Unión Europea, una fecha de expiración o una dirección de Estados Unidos. DLP no admite la carga de funciones personalizadas propias, pero al crear un tipo de información, la entidad puede hacer referencia a las funciones integradas.

Por ejemplo, un distintivo de Id. de empleado incluye una fecha de contratación, por lo que esta entidad personalizada puede usar la función integrada Func_us_date para identificar una fecha en el formato que habitualmente se usa en Estados Unidos.

Para obtener más información, vea Qué buscan las funciones de DLP.

Formato XML que muestra el elemento Match con referencia a una función integrada

Diferentes combinaciones de evidencia [elemento Any, atributos minMatches y maxMatches]

En un elemento Pattern, todos los elementos IdMatch y Match se combinan mediante un operador AND implícito; todas las coincidencias deben cumplirse para que el patrón pueda cumplirse. Pero se puede crear una lógica coincidente más flexible si se usa el elemento Any para agrupar elementos Match. Por ejemplo, puede usar el elemento Any para encontrar todos, ninguno o un subconjunto exacto de las elementos Match secundarios.

El elemento Any tiene los atributos opcionales minMatches y maxMatches, que pueden usarse para definir cuántos elementos Match secundarios tienen que cumplirse para que el patrón coincida. Tenga en cuenta que estos atributos definen el número de elementos Match que tienen que cumplirse, no el número de instancias de evidencia encontradas para las coincidencias. Para definir un número mínimo de instancias para una coincidencia específica (por ejemplo, dos palabras clave de una lista), use el atributo minCount en un elemento Match (como puede ver arriba).

Coincidencia con al menos con un elemento Match secundario

Si quiere exigir que solo tenga que cumplirse un número mínimo de elementos Match, puede usar el atributo minMatches. De hecho, estos elementos Match se combinan mediante un operador OR implícito. Este elemento Any se cumple si se encuentra una fecha con formato de Estados Unidos o una palabra clave de cualquier lista.

Formato XML que muestra el elemento Any con atributo minMatches

Coincidencia con un subconjunto exacto de elementos Match secundarios

Si quiere exigir que tenga que cumplirse un número exacto de elementos Match, puede establecer minMatches y maxMatches en el mismo valor. Este elemento Any solo se cumple si se encuentra exactamente una fecha o palabra clave; en cualquier otro caso, el patrón no coincidirá.

Formato XML que muestra el elemento Any con atributos minMatches y maxMatches

Sin coincidencia con ninguno de los elementos Match secundarios

Si quiere exigir la ausencia de evidencia concreta para que un patrón se cumpla, puede establecer minMatches y maxMatches en 0. Esto puede resultar útil si tiene una lista de palabras clave u otra evidencia que es probable que indiquen un falso positivo.

Por ejemplo, la entidad Id. de empleado busca la palabra clave "tarjeta" porque podría referirse a una "tarjeta de identidad". Pero si "tarjeta" solo aparece en la frase "tarjeta de crédito", es poco probable que en este contexto "tarjeta" signifique "tarjeta de identidad". Por lo que puede agregar "tarjeta de crédito" como palabra clave a una lista de términos que quiera excluir del cumplimiento del patrón.

Formato XML que muestra el atributo maxMatches de valor cero

¿A qué distancia de la entidad debe estar la otra evidencia? [atributo patternsProximity]

El tipo de información confidencial busca un patrón que represente in Id. de empleado y, como parte de ese patrón, busca también evidencia de corroboración, por ejemplo, una palabra clave como “Id.”. Parece lógico que cuanto más cerca esté esta evidencia, más probabilidades hay de que el patrón sea un Id. de empleado real. Puede determinar a qué distancia de la entidad debe estar otra evidencia en el patrón mediante el atributo obligatorio patternsProximity el elemento Entity.

Formato XML que muestra el atributo patternsProximity

Para cada patrón de la entidad, el valor del atributo patternsProximity define la distancia (en caracteres Unicode) de los demás elementos Match especificados para dicho Pattern con respecto a la ubicación de IdMatch. El margen de proximidad se basa en la ubicación del IdMatch y se extiende a su izquierda y a su derecha.

Diagrama de ventana de proximidad

En el ejemplo siguiente se muestra cómo afecta el margen de proximidad al patrón coincidente cuando el elemento IdMatch de la entidad personalizada Id. de empleado requiere al menos una coincidencia de corroboración de palabra clave o fecha. Solo coincide ID1, porque para ID2 e ID3, no se encuentra ninguna evidencia de corroboración, o solo se encuentra una parcial, en el margen de proximidad.

Diagrama de evidencia corroborativa y ventana de proximidad

Tenga en cuenta que en el correo electrónico, el cuerpo del mensaje y los datos adjuntos se tratan como elementos independientes. Esto significa que el margen de proximidad no se extiende más allá del final de cada uno de estos elementos. Cada elemento (cuerpo o datos adjuntos), debe contener tanto su propio elemento idMatch como su evidencia de corroboración.

¿Cuáles son los niveles de confianza correctos para los distintos patrones? [atributo confidenceLevel, atributo recommendedConfidence]

Cuanta más evidencia requiera un patrón, mayor confianza se tiene en que se haya identificado una entidad real (como Id. de empleado) cuando el patrón coincide. Por ejemplo, se tiene más confianza en un patrón que requiere un número de Id. de nueve dígitos, una fecha de contratación y una palabra clave que estén muy cerca, que la que se tiene en un patrón que requiere solo un número de Id. de nueve dígitos.

El elemento Pattern tiene un atributo confidenceLevel obligatorio. Puede considerar el valor de confidenceLevel (un entero entre 1 y 100) como un Id. único de cada patrón de una entidad: los patrones de una entidad deben tener distintos niveles de confianza asignados por el usuario. No importa el valor exacto del entero, simplemente elija números que resulten lógicos para el equipo de cumplimiento. Después de cargar el tipo de información confidencial personalizado y de crear una directiva a DLP, podrá hacer referencia a estos niveles de confianza en las condiciones de las reglas que cree.

Formato XML que muestra elementos Pattern con diferentes valores para el atributo confidenceLevel

Además del atributo confidenceLevel de cada elemento Pattern, el elemento Entity tiene un atributo recommendedConfidence. El atributo de confianza recomendada puede considerarse como el nivel de confianza predeterminado de la regla. Cuando se crea una regla en una directiva DLP, si no se especifica el uso de un nivel de confianza en la regla, está buscará coincidencias en función del nivel de confianza recomendada de la entidad.

¿Quiere admitir otros idiomas en la interfaz de usuario del Centro de seguridad y cumplimiento? [elemento LocalizedStrings]

Si su equipo de cumplimiento usa el Centro de seguridad y cumplimiento de Office 365 para crear directivas DLP con distintas configuraciones regionales y en distintos idiomas, puede proporcionar versiones localizadas del nombre y la descripción del tipo de información confidencial. Cuando el equipo de cumplimiento use Office 365 en un idioma compatible, verá el nombre localizado en la interfaz de usuario.

Opciones de recuento de instancias y precisión de coincidencia

El elemento Rules debe contener un elemento LocalizedStrings, que contenga un elemento Resource que haga referencia al GUID de la entidad personalizada. Cada elemento Resource contiene a su vez uno o más elementos Name y Description, y cada uno usa el atributo langcode para proporcionar una cadena localizada para un idioma concreto.

Formato XML que muestra el contenido del elemento LocalizedStrings

Tenga en cuenta que las cadenas localizadas solo se usan para indicar cómo aparece el tipo de información personalizada en la interfaz de usuario del Centro de seguridad y cumplimiento. No puede usar cadenas localizadas para especificar distintas versiones localizadas de una lista de palabras clave o una expresión regular.

Otro marcado de paquete de reglas [GUID de RulePack]

Por último, al principio de cada RulePackage se incluye cierta información general que es preciso rellenar. Puede usar el marcado siguiente como plantilla y reemplazar los marcadores de posición ". . ." por su propia información.

Sobre todo, tendrá que generar un GUID para el RulePack. Anteriormente se ha generado un GUID para la entidad; este es un segundo GUID para el RulePack. Hay varias maneras de generar los GUID, pero puede hacerlo fácilmente en PowerShell escribiendo [guid]:: NewGuid().

El elemento Version es también importante. Cuando se carga el paquete de reglas por primera vez, Office 365 toma nota del número de versión. Posteriormente, si actualiza el paquete de reglas y carga una nueva versión, asegúrese de actualizar el número de versión u Office 365 no implementará el paquete de reglas.

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

Cuando haya terminado, el elemento RulePack debe tener el siguiente aspecto.

Formato XML que muestra el elemento RulePack

Cambios para Exchange Online

Antes se podía usar PowerShell de Exchange Online para importar tipos de información confidencial personalizados para DLP. Ahora, los tipos de información confidencial personalizados se pueden usar tanto en el Centro de administración de Exchange como en el Centro de seguridad y cumplimiento. Como parte de esta mejora, necesita usar PowerShell del Centro de seguridad y cumplimiento para importar los tipos de información confidencial personalizados (ya no se pueden importar desde Exchange PowerShell). Los tipos de información confidencial personalizados seguirán funcionando como hasta ahora, pero los cambios realizados en los tipos de información confidencial personalizados en el Centro de seguridad y cumplimiento pueden tardar hasta una hora en mostrarse en el Centro de administración de Exchange.

Tenga en cuenta que, en el Centro de seguridad y cumplimiento, usará el cmdlet DlpSensitiveInformationTypeRulePackage para cargar un paquete de reglas. Antes, en el Centro de administración de Exchange, usó el cmdlet ClassificationRuleCollection.

Cargar el paquete de reglas

Para cargar el paquete de reglas, haga lo siguiente.

  1. Guárdelo como archivo .xml con codificación Unicode.

  2. Conectarse al Centro de cumplimiento y seguridad de Office 365 con el PowerShell remoto

  3. En PowerShell del Centro de seguridad y cumplimiento, escriba New-DlpSensitiveInformationTypeRulePackage -FileData (Get-Content -Path "C:\custompath\MyNewRulePack.xml" -Encoding Byte).

    Asegúrese de usar la ubicación del archivo donde realmente se almacena el paquete de reglas. C:\custompath\ es un marcador de posición.

  4. Para confirmar, escriba Y y presione ENTRAR.

  5. Para comprobar que el nuevo tipo de información confidencial se cargó, escriba Get-DlpSensitiveInformationType para ver la lista de todos los tipos confidenciales. Para distinguir rápidamente los tipos de información confidencial personalizados de los predefinidos, vea la columna Editor. Para filtrar la lista por un tipo de información confidencial específico, ejecute Get-DlpSensitiveInformationType -Identity “nombre de tipo de información confidencial”.

Posibles problemas de validación que tiene que considerar

Cuando carga el archivo XML del paquete de reglas, el sistema valida el XML y busca patrones incorrectos conocidos y problemas de rendimiento evidentes. Aquí puede ver algunos problemas conocidos que busca la validación (una expresión a regular):

  • No puede empezar ni terminar con un alternador "|", que busca todo porque se considera una coincidencia vacía.

    Por ejemplo, "|a" o "b|" no superará la validación.

  • No puede empezar ni terminar con un patrón ".{0,m}", que no tiene ningún propósito funcional y solo perjudica el rendimiento.

    Por ejemplo, ".{0,50}ASDF" o "ASDF.{0,50}" no superará la validación.

  • No puede tener ".{0,m}" o ".{1,m}" en grupos ni tener ".*" o ".+" en grupos.

    Por ejemplo, "(.{0,50000})" no superará la validación.

  • No puede tener ningún carácter con repetidores "{0,m}" o "{1,m}" en grupos.

    Por ejemplo, "(a*)" no superará la validación.

  • No puede empezar ni terminar con ".{1,m}"; en su lugar, use solo ".".

    Por ejemplo, ".{1,m}asdf" no superará la validación; en su lugar, use solo ".asdf".

  • No puede tener un repetidor ilimitado (como "*" o "+") en un grupo.

    Por ejemplo, "(xx)*" y "(xx)+" no superarán la validación.

Si un tipo de información confidencial contiene un problema que pueda afectar al rendimiento, no se cargará y puede que vea alguno de los mensajes de error siguientes:

  • Cuantificadores genéricos que encuentran más contenido de lo esperado (por ejemplo, ‘+’, ‘*’)

  • Aserciones lookaround

  • Agrupación compleja con cuantificadores generales

Volver a rastrear el contenido para identificar la información confidencial

DLP usa el rastreador de búsqueda para identificar y clasificar información confidencial en el contenido del sitio. El contenido de sitios de SharePoint Online y OneDrive para la Empresa se vuelve a rastrear automáticamente siempre que se actualiza. Pero para identificar el nuevo tipo de información confidencial personalizado de todo el contenido existente, es preciso volver a rastrear ese contenido.

En Office 365, no puede solicitar manualmente que se vuelva a rastrear un inquilino entero, pero puede hacerlo para una colección, una lista o una biblioteca de sitios: vea Solicitar de forma manual que se rastree y se actualice el índice de un sitio.

Quitar un tipo de información confidencial personalizado

  1. Conectarse al Centro de cumplimiento y seguridad de Office 365 con el PowerShell remoto

  2. En PowerShell del Centro de seguridad y cumplimiento, siga uno de estos procedimientos:

    • Para quitar un paquete de reglas entero y todas las entidades que contiene

      Escriba Remove-DlpSensitiveInformationTypeRulePackage "NameOfYourRulePack"; en el XML de ejemplo anterior escribiría Remove-DlpSensitiveInformationTypeRulePackage "Paquete de reglas personalizado de id. de empleado".

      Tenga en cuenta que, para identificar el paquete de reglas, puede usar el elemento <nombre> (en cualquier idioma) en el elemento <paquete de reglas> del GUID del atributo id del elemento RulePack.

    • Para quitar una única entidad de un paquete de reglas

      Tiene que cargar una nueva versión del paquete de reglas con la entidad específica que se quitó con Set-DlpSensitiveInformationTypeRulePackage. Antes de quitarla, asegúrese de que ninguna directiva DLP ni regla de transporte de Exchange sigan haciendo referencia al tipo de información confidencial.

  3. Para confirmar, escriba Y y presione ENTRAR.

  4. Compruebe que la nueva regla se ha quitado escribiendo Get- DlpSensitiveInformationType, que ya no debe mostrar el nombre del tipo de información confidencial.

Referencia: Definición del esquema XML de paquete de reglas

Puede copiar este marcado, guardarlo como archivo XSD y usarlo para validar el archivo XML del paquete de reglas.

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

Más información

Ampliar sus conocimientos
Explorar los cursos
Obtener nuevas características primero
Únase a los participantes de Office Insider

¿Le ha sido útil esta información?

¡Gracias por sus comentarios!

Gracias por sus comentarios. Quizá le interese ponerse en contacto con uno de nuestros agentes de soporte de Office.

×