Guía del desarrollador de Windows Information Protection (WIP)Windows Information Protection (WIP) developer guide

Una aplicación habilitada diferencia los datos corporativos y personales y sabe cuáles tiene que proteger en función de las directivas de Windows Information Protection (WIP) definidas por el administrador.An enlightened app differentiates between corporate and personal data and knows which to protect based on Windows Information Protection (WIP) policies defined by the administrator.

En esta guía te mostraremos cómo crear una.In this guide, we'll show you how to build one. Una vez finalizada, los administradores de las directivas confiarán en tu aplicación para que pueda consumir datos de su organización.When you're done, policy administrators will be able to trust your app to consume their organization's data. Y los empleados estarán encantados de que sus datos personales se mantengan intactos en sus dispositivos, incluso si dejan de formar parte de la administración de dispositivos móviles (MDM) de la organización o si ellos mismos la abandonan.And employees will love that you've kept their personal data intact on their device even if they un-enroll from the organization's mobile device management (MDM) or leave the organization entirely.

Nota: Esta guía le ayuda a optimizar una aplicación para UWP.Note This guide helps you enlighten a UWP app. Si desea optimizar una aplicación de escritorio de Windows de C++, consulte la Guía del desarrollador de windows Information Protection (WIP) (c++).If you want to enlighten a C++ Windows desktop app, see Windows Information Protection (WIP) developer guide (C++).

Puedes leer más sobre WIP y las aplicaciones habilitadas aquí: Windows Information Protection (WIP).You can read more about WIP and enlightened apps here: Windows Information Protection (WIP).

Encontrarás una muestra completa aquí.You can find a complete sample here.

Si estás listo para realizar cada una de las tareas, empecemos.If you're ready to go through each task, let's start.

En primer lugar, recopila aquello que necesites.First, gather what you need

Necesitarás lo siguiente:You'll need these:

  • Una máquina virtual de prueba (VM) que ejecute Windows 10, versión 1607 o posterior.A test Virtual Machine (VM) that runs Windows 10, version 1607 or higher. Vas a depurar la aplicación usando esta VM de prueba.You'll debug your app against this test VM.

  • Un equipo de desarrollo que ejecute Windows 10, versión 1607 o posterior.A development computer that runs Windows 10, version 1607 or higher. Este podría ser la VM de prueba si tienes Visual Studio instalado.This could be your test VM if you have Visual Studio installed on it.

Configuración de tu entorno de desarrolloSetup your development environment

Para ello deberás hacer lo siguiente:You'll do these things:

Instalar WIP Setup Developer Assistant en la VM de pruebaInstall the WIP Setup Developer Assistant onto your test VM

Usa esta herramienta para configurar una directiva de Windows Information Protection en la VM de prueba.Use this tool to setup a Windows Information Protection policy on your test VM.

Descarga la herramienta aquí: WIP Setup Developer Assistant.Download the tool here: WIP Setup Developer Assistant.

Creación de una directiva de protecciónCreate a protection policy

Para definir la directiva, agrega información a cada sección del asistente del desarrollador para la configuración de WIP.Define your policy by adding information to each section in the WIP setup developer assistant. Elige el icono de ayuda junto a cualquier configuración para obtener más información sobre cómo usarla.Choose the help icon next to any setting to learn more about how to use it.

Para obtener instrucciones más generales sobre cómo usar esta herramienta, consulta la sección de notas de la versión en la página de descarga de la aplicación.For more general guidance about how to use this tool, see the Version notes section on the app download page.

Configuración de un proyecto de Visual StudioSetup a Visual Studio project

  1. Abre el proyecto en tu equipo de desarrollo.On your development computer, open your project.

  2. Agrega una referencia a las extensiones móviles y de escritorio para la Plataforma universal de Windows (UWP).Add a reference to the desktop and mobile extensions for Universal Windows Platform (UWP).

    Agregar extensiones de UWP

  3. Agregue esta funcionalidad al archivo de manifiesto del paquete:Add this capability to your package manifest file:

       <rescap:Capability Name="enterpriseDataPolicy"/>
    

    Lectura opcional: El prefijo "rescap" significa Funcionalidad restringida.Optional Reading: The "rescap" prefix means Restricted Capability. Consulta Funcionalidades especiales y restringidas.See Special and restricted capabilities.

  4. Agrega este espacio de nombres al archivo de manifiesto del paquete:Add this namespace to your package manifest file:

      xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
    
  5. Agrega el prefijo de espacio de nombres al elemento <ignorableNamespaces> de tu archivo de manifiesto del paquete.Add the namespace prefix to the <ignorableNamespaces> element of your package manifest file.

        <IgnorableNamespaces="uap mp rescap">
    

    De esta forma, si la aplicación se ejecuta en una versión del sistema operativo Windows que no sea compatible con las funcionalidades restringidas, Windows ignorará la funcionalidad enterpriseDataPolicy.This way, if your app runs on a version of the Windows operating system that doesn't support restricted capabilities, Windows will ignore the enterpriseDataPolicy capability.

Configurar la depuración remotaSetup remote debugging

Instala Herramientas remotas para Visual Studio en la VM de prueba solo si vas a desarrollar tu aplicación en un equipo que no sea la VM.Install Visual Studio Remote Tools on your test VM only if you are developing your app on a computer other than your VM. A continuación, inicia el depurador remoto en el equipo de desarrollo y comprueba si tu aplicación se ejecuta en la VM de prueba.Then, on your development computer start the remote debugger and see if your app runs on the test VM.

Consulta Instrucciones del equipo remoto.See Remote PC instructions.

Agregar estos espacios de nombres a los archivos de códigoAdd these namespaces to your code files

Agrégalos usando estas instrucciones en la parte superior de los archivos de código (los fragmentos de código utilizados en esta guía):Add these using statements to the top of your code files(The snippets in this guide use them):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Security.EnterpriseData;
using Windows.Web.Http;
using Windows.Storage.Streams;
using Windows.ApplicationModel.DataTransfer;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml;
using Windows.ApplicationModel.Activation;
using Windows.Web.Http.Filters;
using Windows.Storage;
using Windows.Data.Xml.Dom;
using Windows.Foundation.Metadata;
using Windows.Web.Http.Headers;

Determinar si se deben usar las API de WIP en la aplicaciónDetermine whether to use WIP APIs in your app

Asegúrese de que el sistema operativo que ejecuta la aplicación admite WIP y que WIP está habilitado en el dispositivo.Ensure that the operating system that runs your app supports WIP and that WIP is enabled on the device.

bool use_WIP_APIs = false;

if ((ApiInformation.IsApiContractPresent
    ("Windows.Security.EnterpriseData.EnterpriseDataContract", 3)
    && ProtectionPolicyManager.IsProtectionEnabled))
{
    use_WIP_APIs = true;
}
else
{
    use_WIP_APIs = false;
}

No llame a las API de WIP si el sistema operativo no admite WIP o WIP no está habilitado en el dispositivo.Don't call WIP APIs if the operating system doesn't support WIP or WIP is not enabled on the device.

Leer datos de empresaRead enterprise data

Para leer los archivos protegidos, los puntos de conexión de red, los datos del portapapeles y los datos que acepta de un contrato de recursos compartidos, la aplicación tendrá que solicitar acceso.To read protected files, network endpoints, clipboard data and data that you accept from a Share contract, your app will have to request access.

Windows Information Protection proporciona el permiso de la aplicación si la aplicación se encuentra en la lista de permitidos de la Directiva de protección.Windows Information Protection gives your app permission if your app is on the protection policy's allowed list.

Esta sección:In this section:

Leer datos desde un archivoRead data from a file

Paso 1: Obtener el identificador de archivoStep 1: Get the file handle

    Windows.Storage.StorageFolder storageFolder =
        Windows.Storage.ApplicationData.Current.LocalFolder;

    Windows.Storage.StorageFile file =
        await storageFolder.GetFileAsync(fileName);

Paso 2: Determinar si la aplicación puede abrir el archivoStep 2: Determine whether your app can open the file

Llame a FileProtectionManager. GetProtectionInfoAsync para determinar si la aplicación puede abrir el archivo.Call FileProtectionManager.GetProtectionInfoAsync to determine whether your app can open the file.

FileProtectionInfo protectionInfo = await FileProtectionManager.GetProtectionInfoAsync(file);

if ((protectionInfo.Status != FileProtectionStatus.Protected &&
    protectionInfo.Status != FileProtectionStatus.Unprotected))
{
    return false;
}
else if (protectionInfo.Status == FileProtectionStatus.Revoked)
{
    // Code goes here to handle this situation. Perhaps, show UI
    // saying that the user's data has been revoked.
}

Un valor de FileProtectionStatus de Protected significa que el archivo está protegido y la aplicación puede abrirlo porque la aplicación se encuentra en la lista de permitidos de la Directiva.A FileProtectionStatus value of Protected means that the file is protected and your app can open it because your app is on the policy's allowed list.

Un valor de FileProtectionStatus de sin protección significa que el archivo no está protegido y la aplicación puede abrir el archivo, incluso si la aplicación no está en la lista de permitidos de la Directiva.A FileProtectionStatus value of UnProtected means that the file is not protected and your app can open the file even your app is not on the policy's allowed list.

APIAPIs
FileProtectionManager.GetProtectionInfoAsyncFileProtectionManager.GetProtectionInfoAsync
FileProtectionInfoFileProtectionInfo
FileProtectionStatusFileProtectionStatus
ProtectionPolicyManager.IsIdentityManagedProtectionPolicyManager.IsIdentityManaged

Paso 3: Leer el archivo en una secuencia o búferStep 3: Read the file into a stream or buffer

Leer el archivo en una secuenciaRead the file into a stream

var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);

Leer el archivo en un búferRead the file into a buffer

var buffer = await Windows.Storage.FileIO.ReadBufferAsync(file);

Leer los datos desde el punto de conexión de redRead data from a network endpoint

Crea un contexto de subproceso protegido para leer desde un punto de conexión de empresa.Create a protected thread context to read from an enterprise endpoint.

Paso 1: Obtener la identidad del punto de conexión de redStep 1: Get the identity of the network endpoint

Uri resourceURI = new Uri("http://contoso.com/stockData.xml");

Windows.Networking.HostName hostName =
    new Windows.Networking.HostName(resourceURI.Host);

string identity = await ProtectionPolicyManager.
    GetPrimaryManagedIdentityForNetworkEndpointAsync(hostName);

Si el punto de conexión no está administrado por la directiva, obtendrás una cadena vacía.If the endpoint isn't managed by policy, you'll get back an empty string.

APIAPIs
ProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsyncProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsync

Paso 2: Crear un contexto de subproceso protegidoStep 2: Create a protected thread context

Si el punto de conexión está administrado por una directiva, crea un contexto de subproceso protegido.If the endpoint is managed by policy, create a protected thread context. Esto etiqueta todas las conexiones de red que se realizan en el mismo subproceso a dicha identidad.This tags any network connections that you make on the same thread to the identity.

También proporciona acceso a los recursos de red de empresa que administra esa directiva.It also gives you access to enterprise network resources that are managed by that policy.

if (!string.IsNullOrEmpty(identity))
{
    using (ThreadNetworkContext threadNetworkContext =
            ProtectionPolicyManager.CreateCurrentThreadNetworkContext(identity))
    {
        return await GetDataFromNetworkRedirectHelperMethod(resourceURI);
    }
}
else
{
    return await GetDataFromNetworkRedirectHelperMethod(resourceURI);
}

Este ejemplo incluye llamadas de socket en un bloque using.This example encloses socket calls in a using block. Si no haces esto, asegúrate de cerrar el contexto de subproceso tras haber recuperado los recursos.If you don't do this, make sure that you close the thread context after you've retrieved your resource. Consulta ThreadNetworkContext.Close.See ThreadNetworkContext.Close.

No crees ningún archivo personal en ese subproceso protegido porque los archivos se cifrarán automáticamente.Don't create any personal files on that protected thread because those files will be automatically encrypted.

El método ProtectionPolicyManager.CreateCurrentThreadNetworkContext devuelve un objeto ThreadNetworkContext independientemente de si el punto de conexión está administrado por una directiva.The ProtectionPolicyManager.CreateCurrentThreadNetworkContext method returns a ThreadNetworkContext object whether or not the endpoint is being managed by policy. Si la aplicación controla recursos personales y de empresa, llama a ProtectionPolicyManager.CreateCurrentThreadNetworkContext para todas las identidades.If your app handles both personal and enterprise resources, call ProtectionPolicyManager.CreateCurrentThreadNetworkContext for all identities. Una vez obtenido el recurso, eliminar el ThreadNetworkContext para borrar cualquier etiqueta de identidad del subproceso actual.After you get the resource, dispose the ThreadNetworkContext to clear any identity tag from the current thread.

APIAPIs
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity
ProtectionPolicyManager.CreateCurrentThreadNetworkContextProtectionPolicyManager.CreateCurrentThreadNetworkContext

Paso 3: Leer el recurso en un búferStep 3: Read the resource into a buffer

private static async Task<IBuffer> GetDataFromNetworkHelperMethod(Uri resourceURI)
{
    HttpClient client;

    client = new HttpClient();

    try { return await client.GetBufferAsync(resourceURI); }

    catch (Exception) { return null; }
}

Opta Usar un token de encabezado en lugar de crear un contexto de subproceso protegido(Optional) Use a header token instead of creating a protected thread context

public static async Task<IBuffer> GetDataFromNetworkbyUsingHeader(Uri resourceURI)
{
    HttpClient client;

    Windows.Networking.HostName hostName =
        new Windows.Networking.HostName(resourceURI.Host);

    string identity = await ProtectionPolicyManager.
        GetPrimaryManagedIdentityForNetworkEndpointAsync(hostName);

    if (!string.IsNullOrEmpty(identity))
    {
        client = new HttpClient();

        HttpRequestHeaderCollection headerCollection = client.DefaultRequestHeaders;

        headerCollection.Add("X-MS-Windows-HttpClient-EnterpriseId", identity);

        return await GetDataFromNetworkbyUsingHeaderHelperMethod(client, resourceURI);
    }
    else
    {
        client = new HttpClient();
        return await GetDataFromNetworkbyUsingHeaderHelperMethod(client, resourceURI);
    }

}

private static async Task<IBuffer> GetDataFromNetworkbyUsingHeaderHelperMethod(HttpClient client, Uri resourceURI)
{

    try { return await client.GetBufferAsync(resourceURI); }

    catch (Exception) { return null; }
}

Controlar las redirecciones de páginaHandle page redirects

En ocasiones, un servidor web redirigirá el tráfico hacia una versión más actual de un recurso.Sometimes a web server will redirect traffic to a more current version of a resource.

Para controlar esto, realiza solicitudes hasta que el estado de la respuesta de la solicitud tiene el valor Aceptar.To handle this, make requests until the response status of your request has a value of OK.

A continuación, usa el URI de la respuesta para obtener la identidad del punto de conexión.Then use the URI of that response to get the identity of the endpoint. Esta es una forma de hacerlo:Here's one way to do this:

private static async Task<IBuffer> GetDataFromNetworkRedirectHelperMethod(Uri resourceURI)
{
    HttpClient client = null;

    HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
    filter.AllowAutoRedirect = false;

    client = new HttpClient(filter);

    HttpResponseMessage response = null;

        HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Get, resourceURI);
        response = await client.SendRequestAsync(message);

    if (response.StatusCode == HttpStatusCode.MultipleChoices ||
        response.StatusCode == HttpStatusCode.MovedPermanently ||
        response.StatusCode == HttpStatusCode.Found ||
        response.StatusCode == HttpStatusCode.SeeOther ||
        response.StatusCode == HttpStatusCode.NotModified ||
        response.StatusCode == HttpStatusCode.UseProxy ||
        response.StatusCode == HttpStatusCode.TemporaryRedirect ||
        response.StatusCode == HttpStatusCode.PermanentRedirect)
    {
        message = new HttpRequestMessage(HttpMethod.Get, message.RequestUri);
        response = await client.SendRequestAsync(message);

        try { return await response.Content.ReadAsBufferAsync(); }

        catch (Exception) { return null; }
    }
    else
    {
        try { return await response.Content.ReadAsBufferAsync(); }

        catch (Exception) { return null; }
    }
}

APIAPIs
ProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsyncProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsync
ProtectionPolicyManager.CreateCurrentThreadNetworkContextProtectionPolicyManager.CreateCurrentThreadNetworkContext
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity

Leer datos desde el PortapapelesRead data from the clipboard

Obtener permiso para usar los datos del PortapapelesGet permission to use data from the clipboard

Para obtener datos del Portapapeles, tendrás que pedir permiso a Windows.To get data from the clipboard, ask Windows for permission. Usa DataPackageView.RequestAccessAsync para ello.Use DataPackageView.RequestAccessAsync to do that.

public static async Task PasteText(TextBox textBox)
{
    DataPackageView dataPackageView = Clipboard.GetContent();

    if (dataPackageView.Contains(StandardDataFormats.Text))
    {
        ProtectionPolicyEvaluationResult result = await dataPackageView.RequestAccessAsync();

        if (result == ProtectionPolicyEvaluationResult..Allowed)
        {
            string contentsOfClipboard = await dataPackageView.GetTextAsync();
            textBox.Text = contentsOfClipboard;
        }
    }
}

APIAPIs
DataPackageView.RequestAccessAsyncDataPackageView.RequestAccessAsync

Ocultar o deshabilitar las características que usan datos del PortapapelesHide or disable features that use clipboard data

Determinar si la vista actual tiene permiso para obtener los datos que están en el Portapapeles.Determine whether current view has permission to get data that is on the clipboard.

Si no es así, puedes deshabilitar u ocultar los controles que permiten a los usuarios pegar información desde el Portapapeles u obtener una vista previa de su contenido.If it doesn't, you can disable or hide controls that let users paste information from the clipboard or preview its contents.

private bool IsClipboardAllowedAsync()
{
    ProtectionPolicyEvaluationResult protectionPolicyEvaluationResult = ProtectionPolicyEvaluationResult.Blocked;

    DataPackageView dataPackageView = Clipboard.GetContent();

    if (dataPackageView.Contains(StandardDataFormats.Text))

        protectionPolicyEvaluationResult =
            ProtectionPolicyManager.CheckAccess(dataPackageView.Properties.EnterpriseId,
                ProtectionPolicyManager.GetForCurrentView().Identity);

    return (protectionPolicyEvaluationResult == ProtectionPolicyEvaluationResult.Allowed |
        protectionPolicyEvaluationResult == ProtectionPolicyEvaluationResult.ConsentRequired);
}

APIAPIs
ProtectionPolicyEvaluationResultProtectionPolicyEvaluationResult
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity

Impedir a los usuarios que les aparezca un cuadro de diálogo de consentimientoPrevent users from being prompted with a consent dialog box

Un documento nuevo no es personal o de empresa.A new document isn't personal or enterprise. Es simplemente nuevo.It's just new. Si un usuario pega los datos de empresa en él, Windows aplicará la directiva y se le mostrará al usuario un cuadro de diálogo de consentimiento.If a user pastes enterprise data into it, Windows enforces policy and the user is prompted with a consent dialog. Este código impide que eso ocurra.This code prevents that from happening. En esta tarea no se trata de proteger los datos.This task is not about helping to protect data. Es más sobre cómo hacer que los usuarios reciban el cuadro de diálogo de consentimiento en los casos donde la aplicación crea un elemento nuevo.It's more about keeping users from receiving the consent dialog box in cases where your app creates a brand new item.

private async void PasteText(bool isNewEmptyDocument)
{
    DataPackageView dataPackageView = Clipboard.GetContent();

    if (dataPackageView.Contains(StandardDataFormats.Text))
    {
        if (!string.IsNullOrEmpty(dataPackageView.Properties.EnterpriseId))
        {
            if (isNewEmptyDocument)
            {
                ProtectionPolicyManager.TryApplyProcessUIPolicy(dataPackageView.Properties.EnterpriseId);
                string contentsOfClipboard = contentsOfClipboard = await dataPackageView.GetTextAsync();
                // add this string to the new item or document here.          

            }
            else
            {
                ProtectionPolicyEvaluationResult result = await dataPackageView.RequestAccessAsync();

                if (result == ProtectionPolicyEvaluationResult.Allowed)
                {
                    string contentsOfClipboard = contentsOfClipboard = await dataPackageView.GetTextAsync();
                    // add this string to the new item or document here.
                }
            }
        }
    }
}

APIAPIs
DataPackageView.RequestAccessAsyncDataPackageView.RequestAccessAsync
ProtectionPolicyEvaluationResultProtectionPolicyEvaluationResult
ProtectionPolicyManager.TryApplyProcessUIPolicyProtectionPolicyManager.TryApplyProcessUIPolicy

Leer datos desde un contrato para contenido compartidoRead data from a Share contract

Cuando los empleados elijan tu aplicación para compartir su información, tu aplicación abrirá un nuevo elemento con ese contenido.When employees choose your app to share their information, your app will open a new item that contains that content.

Como ya hemos mencionado, un elemento nuevo no es ni personal ni de empresa.As we mentioned earlier, a new item isn't personal or enterprise. Es simplemente nuevo.It's just new. Si tu código agrega contenido de empresa a dicho elemento, Windows aplicará la directiva y se le mostrará al usuario un cuadro de diálogo de consentimiento.If your code adds enterprise content to the item, Windows enforces policy and the user is prompted with a consent dialog. Este código impide que eso ocurra.This code prevents that from happening.

protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args)
{
    bool isNewEmptyDocument = true;
    string identity = "corp.microsoft.com";

    ShareOperation shareOperation = args.ShareOperation;
    if (shareOperation.Data.Contains(StandardDataFormats.Text))
    {
        if (!string.IsNullOrEmpty(shareOperation.Data.Properties.EnterpriseId))
        {
            if (isNewEmptyDocument)
                // If this is a new and empty document, and we're allowed to access
                // the data, then we can avoid popping the consent dialog
                ProtectionPolicyManager.TryApplyProcessUIPolicy(shareOperation.Data.Properties.EnterpriseId);
            else
            {
                // In this case, we can't optimize the workflow, so we just
                // request consent from the user in this case.

                ProtectionPolicyEvaluationResult protectionPolicyEvaluationResult = await shareOperation.Data.RequestAccessAsync();

                if (protectionPolicyEvaluationResult == ProtectionPolicyEvaluationResult.Allowed)
                {
                    string text = await shareOperation.Data.GetTextAsync();

                    // Do something with that text.
                }
            }
        }
        else
        {
            // If the data has no enterprise identity, then we already have access.
            string text = await shareOperation.Data.GetTextAsync();

            // Do something with that text.
        }

    }

}

APIAPIs
ProtectionPolicyManager. RequestAccessAsyncProtectionPolicyManager.RequestAccessAsync
ProtectionPolicyEvaluationResultProtectionPolicyEvaluationResult
ProtectionPolicyManager.TryApplyProcessUIPolicyProtectionPolicyManager.TryApplyProcessUIPolicy

Protección de datos de empresaProtect enterprise data

Protege los datos de empresa que se usan fuera de la aplicación.Protect enterprise data that leaves your app. Los datos se usan fuera de la aplicación cuando se muestran en una página, se guardan en un archivo o punto de conexión de red o a través de un contrato para contenido compartido.Data leaves your app when you show it in a page, save it to a file or network endpoint, or through a share contract.

Esta sección:In this section:

Proteger los datos que aparecen en las páginasProtect data that appears in pages

Al mostrar datos en una página, tendrás que informar a Windows de qué tipo de datos se tratan (personal o de empresa).When you show data in a page, let Windows know what type of data it is (personal or enterprise). Para ello, etiqueta la vista actual de la aplicación o todo su proceso.To do that, tag the current app view or tag the entire app process.

Al etiquetar la vista o el proceso, Windows aplica la directiva.When you tag the view or the process, Windows enforces policy on it. Esto evita que se produzcan fugas de datos como resultado de las acciones que la aplicación no controla.This helps prevent data leaks that result from actions that your app doesn't control. Por ejemplo, en un equipo, un usuario podría usar CTRL+V para copiar la información de empresa desde una vista y, a continuación, pegar esa información en otra aplicación.For example, on a computer, a user could use CTRL-V to copy enterprise information from a view and then paste that information to another app. Windows evita que esto pase.Windows protects against that. Windows también ayuda a aplicar los contratos para contenido compartido.Windows also helps to enforce share contracts.

Etiquetar la vista actual de la aplicaciónTag the current app view

Realiza esta acción si tu aplicación tiene varias vistas y algunas usarán datos de empresa y otra datos personales.Do this if your app has multiple views where some views consume enterprise data and some consume personal data.


// tag as enterprise data. "identity" the string that contains the enterprise ID.
// You'd get that from a file, network endpoint, or clipboard data package.
ProtectionPolicyManager.GetForCurrentView().Identity = identity;

// tag as personal data.
ProtectionPolicyManager.GetForCurrentView().Identity = String.Empty;

APIAPIs
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity

Etiquetar el procesoTag the process

Realiza esta acción si todas las vistas de tu aplicación usan solo un tipo de datos (personales o de empresa).Do this if all views in your app will work with only one type of data (personal or enterprise).

Esto evitará tener que administrar las vistas etiquetadas de forma independiente.This prevents you from having to manage independently tagged views.



// tag as enterprise data. "identity" the string that contains the enterprise ID.
// You'd get that from a file, network endpoint, or clipboard data package.
bool result =
            ProtectionPolicyManager.TryApplyProcessUIPolicy(identity);

// tag as personal data.
ProtectionPolicyManager.ClearProcessUIPolicy();

APIAPIs
ProtectionPolicyManager.TryApplyProcessUIPolicyProtectionPolicyManager.TryApplyProcessUIPolicy

Proteger datos en un archivoProtect data to a file

Crea un archivo protegido y escribe en él.Create a protected file and then write to it.

Paso 1: Determinar si tu aplicación puede crear un archivo de empresaStep 1: Determine if your app can create an enterprise file

Tu aplicación puede crear un archivo de empresa si la cadena de identidad está administrada por la directiva y tu aplicación está en la lista de aplicaciones permitidas por esta.Your app can create an enterprise file if the identity string is managed by policy and your app is on the Allowed list of that policy.

  if (!ProtectionPolicyManager.IsIdentityManaged(identity)) return false;

APIAPIs
ProtectionPolicyManager.IsIdentityManagedProtectionPolicyManager.IsIdentityManaged

Paso 2: Crear un archivo y protegerlo a la identidadStep 2: Create the file and protect it to the identity

StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFile storageFile = await storageFolder.CreateFileAsync("sample.txt",
    CreationCollisionOption.ReplaceExisting);

FileProtectionInfo fileProtectionInfo =
    await FileProtectionManager.ProtectAsync(storageFile, identity);

APIAPIs
FileProtectionManager.ProtectAsyncFileProtectionManager.ProtectAsync

Step 3: Escribir esa secuencia o búfer en el archivoStep 3: Write that stream or buffer to the file

Escribir una secuenciaWrite a stream

    if (fileProtectionInfo.Status == FileProtectionStatus.Protected)
    {
        var stream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);

        using (var outputStream = stream.GetOutputStreamAt(0))
        {
            using (var dataWriter = new DataWriter(outputStream))
            {
                dataWriter.WriteString(enterpriseData);
            }
        }

    }

Escribir un búferWrite a buffer

     if (fileProtectionInfo.Status == FileProtectionStatus.Protected)
     {
         var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(
             enterpriseData, Windows.Security.Cryptography.BinaryStringEncoding.Utf8);

         await FileIO.WriteBufferAsync(storageFile, buffer);

      }

APIAPIs
FileProtectionInfoFileProtectionInfo
FileProtectionStatusFileProtectionStatus

Proteger datos en un archivo como un proceso en segundo planoProtect data to a file as a background process

Este código puede ejecutarse mientras la pantalla del dispositivo está bloqueada.This code can run while the screen of the device is locked. Si el administrador ha configurado una directiva de "protección de datos con la pantalla bloqueada (DPL)", Windows eliminará las claves de cifrado necesarias para acceder a los recursos protegido desde la memoria del dispositivo.If the administrator configured a secure "Data protection under lock" (DPL) policy, Windows removes the encryption keys required to access protected resources from device memory. Esto impide la pérdida de datos en caso de pérdida del dispositivo.This prevents data leaks if the device is lost. La misma función también quita las claves asociadas con los archivos protegidos cuando se cierran sus identificadores.This same feature also removes keys associated with protected files when their handles are closed.

Al crear un archivo, tendrás que usar un enfoque que mantiene el identificador de archivo abierto.You'll have to use an approach that keeps the file handle open when you create a file.

Paso 1: Determinar si puedes crear un archivo de empresaStep 1: Determine if you can create an enterprise file

Puedes crear un archivo de empresa si la cadena de identidad que estás usando está administrada por la directiva y tu aplicación está en la lista de aplicaciones permitidas por esta.You can create an enterprise file if the identity that you're using is managed by policy and your app is on the allowed list of that policy.

if (!ProtectionPolicyManager.IsIdentityManaged(identity)) return false;

APIAPIs
ProtectionPolicyManager.IsIdentityManagedProtectionPolicyManager.IsIdentityManaged

Paso 2: Crear un archivo y protegerlo a la identidadStep 2: Create a file and protect it to the identity

El método FileProtectionManager.CreateProtectedAndOpenAsync crea un archivo protegido y mantiene el identificador de archivo abierto mientras escribes en él.The FileProtectionManager.CreateProtectedAndOpenAsync creates a protected file and keeps the file handle open while you write to it.

StorageFolder storageFolder = ApplicationData.Current.LocalFolder;

ProtectedFileCreateResult protectedFileCreateResult =
    await FileProtectionManager.CreateProtectedAndOpenAsync(storageFolder,
        "sample.txt", identity, CreationCollisionOption.ReplaceExisting);

APIAPIs
FileProtectionManager.CreateProtectedAndOpenAsyncFileProtectionManager.CreateProtectedAndOpenAsync

Step 3: Escribir esa secuencia o búfer en el archivoStep 3: Write a stream or buffer to the file

En este ejemplo se escribe una secuencia en un archivo.This example writes a stream to a file.

if (protectedFileCreateResult.ProtectionInfo.Status == FileProtectionStatus.Protected)
{
    IOutputStream outputStream =
        protectedFileCreateResult.Stream.GetOutputStreamAt(0);

    using (DataWriter writer = new DataWriter(outputStream))
    {
        writer.WriteString(enterpriseData);
        await writer.StoreAsync();
        await writer.FlushAsync();
    }

    outputStream.Dispose();
}
else if (protectedFileCreateResult.ProtectionInfo.Status == FileProtectionStatus.AccessSuspended)
{
    // Perform any special processing for the access suspended case.
}

APIAPIs
ProtectedFileCreateResult.ProtectionInfoProtectedFileCreateResult.ProtectionInfo
FileProtectionStatusFileProtectionStatus
ProtectedFileCreateResult.StreamProtectedFileCreateResult.Stream

Proteger parte de un archivoProtect part of a file

En la mayoría de los casos, es más limpio almacenar los datos personales y de empresa por separado, pero puedes almacenarlos en el mismo archivo si lo deseas.In most cases, it's cleaner to store enterprise and personal data separately but you can store them to the same file if you want. Por ejemplo, Microsoft Outlook puede almacenar correos electrónicos de la empresa junto a correos electrónicos personales en un archivo de almacenamiento único.For example, Microsoft Outlook can store enterprise mails alongside of personal mails in a single archive file.

Cifrar los datos de empresa pero no el archivo completo.Encrypt the enterprise data but not the entire file. De este modo, los usuarios pueden seguir usando ese archivo incluso si se cancela la inscripción a MDM o se revocan sus derechos de acceso a los datos de empresa.That way, users can continue using that file even if they un-enroll from MDM or their enterprise data access rights are revoked. Además, la aplicación deberá llevar un seguimiento de los datos que cifra para que sepa qué datos tiene que proteger cuando el archivo se lee de nuevo en la memoria.Also, your app should keep track of what data it encrypts so that it knows what data to protect when it reads the file back into memory.

Paso 1: Agregar los datos de empresa a una secuencia cifrada o búferStep 1: Add enterprise data to an encrypted stream or buffer

string enterpriseDataString = "<employees><employee><name>Bill</name><social>xxx-xxx-xxxx</social></employee></employees>";

var enterpriseData= Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(
        enterpriseDataString, Windows.Security.Cryptography.BinaryStringEncoding.Utf8);

BufferProtectUnprotectResult result =
   await DataProtectionManager.ProtectAsync(enterpriseData, identity);

enterpriseData= result.Buffer;

APIAPIs
DataProtectionManager.ProtectAsyncDataProtectionManager.ProtectAsync
BufferProtectUnprotectResult.bufferBufferProtectUnprotectResult.buffer

Paso 2: Agregar datos personales a una secuencia o búfer sin cifrarStep 2: Add personal data to an unencrypted stream or buffer

string personalDataString = "<recipies><recipe><name>BillsCupCakes</name><cooktime>30</cooktime></recipe></recipies>";

var personalData = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(
    personalDataString, Windows.Security.Cryptography.BinaryStringEncoding.Utf8);

Paso 3: Escribir secuencias o búferes en un archivoStep 3: Write both streams or buffers to a file

StorageFolder storageFolder = ApplicationData.Current.LocalFolder;

StorageFile storageFile = await storageFolder.CreateFileAsync("data.xml",
    CreationCollisionOption.ReplaceExisting);

 // Write both buffers to the file and save the file.

var stream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);

using (var outputStream = stream.GetOutputStreamAt(0))
{
    using (var dataWriter = new DataWriter(outputStream))
    {
        dataWriter.WriteBuffer(enterpriseData);
        dataWriter.WriteBuffer(personalData);

        await dataWriter.StoreAsync();
        await outputStream.FlushAsync();
    }
}

Paso 4: Realizar un seguimiento de la ubicación de los datos de empresa en un archivoStep 4: Keep track of the location of your enterprise data in the file

Es responsabilidad de la aplicación llevar un seguimiento de los datos del archivo que pertenecen a la empresa.It's the responsibility of your app to keep track of the data in that file that is enterprise owned.

Puedes almacenar dicha información en una propiedad asociada al archivo, en una base de datos o en el texto del encabezado del archivo.You can store that information in a property associated with the file, in a database, or in some header text in the file.

Este ejemplo, guarda esta información en un archivo XML independiente.This example, saves that information to a separate XML file.

StorageFile metaDataFile = await storageFolder.CreateFileAsync("metadata.xml",
   CreationCollisionOption.ReplaceExisting);

await Windows.Storage.FileIO.WriteTextAsync
    (metaDataFile, "<EnterpriseDataMarker start='0' end='" + enterpriseData.Length.ToString() +
    "'></EnterpriseDataMarker>");

Leer la parte protegida de un archivoRead the protected part of a file

Aquí te mostramos cómo podrías leer los datos de empresa de ese archivo.Here's how you'd read the enterprise data out of that file.

Paso 1: Obtener la posición de los datos de empresa en el archivoStep 1: Get the position of your enterprise data in the file

Windows.Storage.StorageFolder storageFolder =
    Windows.Storage.ApplicationData.Current.LocalFolder;

 Windows.Storage.StorageFile metaDataFile =
   await storageFolder.GetFileAsync("metadata.xml");

string metaData = await Windows.Storage.FileIO.ReadTextAsync(metaDataFile);

XmlDocument doc = new XmlDocument();

doc.LoadXml(metaData);

uint startPosition =
    Convert.ToUInt16((doc.FirstChild.Attributes.GetNamedItem("start")).InnerText);

uint endPosition =
    Convert.ToUInt16((doc.FirstChild.Attributes.GetNamedItem("end")).InnerText);

Paso 2: Abre el archivo de datos y asegúrate de que no está protegidoStep 2: Open the data file and make sure that it's not protected

Windows.Storage.StorageFile dataFile =
    await storageFolder.GetFileAsync("data.xml");

FileProtectionInfo protectionInfo =
    await FileProtectionManager.GetProtectionInfoAsync(dataFile);

if (protectionInfo.Status == FileProtectionStatus.Protected)
    return false;

APIAPIs
FileProtectionManager.GetProtectionInfoAsyncFileProtectionManager.GetProtectionInfoAsync
FileProtectionInfoFileProtectionInfo
FileProtectionStatusFileProtectionStatus

Paso 3: Leer los datos de empresa desde el archivoStep 3: Read the enterprise data from the file

var stream = await dataFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);

stream.Seek(startPosition);

Windows.Storage.Streams.Buffer tempBuffer = new Windows.Storage.Streams.Buffer(50000);

IBuffer enterpriseData = await stream.ReadAsync(tempBuffer, endPosition, InputStreamOptions.None);

Paso 4: Descifrar el búfer que contiene los datos de empresaStep 4: Decrypt the buffer that contains enterprise data

DataProtectionInfo dataProtectionInfo =
   await DataProtectionManager.GetProtectionInfoAsync(enterpriseData);

if (dataProtectionInfo.Status == DataProtectionStatus.Protected)
{
    BufferProtectUnprotectResult result = await DataProtectionManager.UnprotectAsync(enterpriseData);
    enterpriseData = result.Buffer;
}
else if (dataProtectionInfo.Status == DataProtectionStatus.Revoked)
{
    // Code goes here to handle this situation. Perhaps, show UI
    // saying that the user's data has been revoked.
}

APIAPIs
DataProtectionInfoDataProtectionInfo
DataProtectionManager.GetProtectionInfoAsyncDataProtectionManager.GetProtectionInfoAsync

Proteger datos en una carpetaProtect data to a folder

Puedes crear una carpeta y protegerla.You can create a folder and protect it. De esta forma cualquier elemento que añadas a la carpeta estará automáticamente protegido.That way any items that you add to that folder are automatically protected.

private async Task<bool> CreateANewFolderAndProtectItAsync(string folderName, string identity)
{
    if (!ProtectionPolicyManager.IsIdentityManaged(identity)) return false;

    StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
    StorageFolder newStorageFolder =
        await storageFolder.CreateFolderAsync(folderName);

    FileProtectionInfo fileProtectionInfo =
        await FileProtectionManager.ProtectAsync(newStorageFolder, identity);

    if (fileProtectionInfo.Status != FileProtectionStatus.Protected)
    {
        // Protection failed.
        return false;
    }
    return true;
}

Asegúrate de que la carpeta esté vacía antes de protegerla.Make sure that the folder is empty before you protect it. No puedes proteger una carpeta que ya contiene elementos.You can't protect a folder that already contains items.

APIAPIs
ProtectionPolicyManager.IsIdentityManagedProtectionPolicyManager.IsIdentityManaged
FileProtectionManager.ProtectAsyncFileProtectionManager.ProtectAsync
FileProtectionInfo.IdentityFileProtectionInfo.Identity
FileProtectionInfo.StatusFileProtectionInfo.Status

Proteger los datos en un punto de conexión de redProtect data to a network end point

Crea un contexto de subproceso protegido para enviar datos a un punto de conexión de empresa.Create a protected thread context to send that data to an enterprise endpoint.

Paso 1: Obtener la identidad del punto de conexión de redStep 1: Get the identity of the network endpoint

Windows.Networking.HostName hostName =
    new Windows.Networking.HostName(resourceURI.Host);

string identity = await ProtectionPolicyManager.
    GetPrimaryManagedIdentityForNetworkEndpointAsync(hostName);

APIAPIs
ProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsyncProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsync

Paso 2: Crear un contexto de subproceso protegido y enviar datos al punto de conexión de redStep 2: Create a protected thread context and send data to the network endpoint

HttpClient client = null;

if (!string.IsNullOrEmpty(m_EnterpriseId))
{
    ProtectionPolicyManager.GetForCurrentView().Identity = identity;

    using (ThreadNetworkContext threadNetworkContext =
            ProtectionPolicyManager.CreateCurrentThreadNetworkContext(identity))
    {
        client = new HttpClient();
        HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Put, resourceURI);
        message.Content = new HttpStreamContent(dataToWrite);

        HttpResponseMessage response = await client.SendRequestAsync(message);

        if (response.StatusCode == HttpStatusCode.Ok)
            return true;
        else
            return false;
    }
}
else
{
    return false;
}

APIAPIs
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity
ProtectionPolicyManager.CreateCurrentThreadNetworkContextProtectionPolicyManager.CreateCurrentThreadNetworkContext

Proteger los datos que tu aplicación comparte a través de un contrato para contenido compartidoProtect data that your app shares through a share contract

Si quieres que los usuarios compartan contenido desde tu aplicación, tendrás que implementar un contrato para contenido compartido y controlar el evento DataTransferManager.DataRequested.If you want users to share content from your app, you'll have to implement a share contract and handle the DataTransferManager.DataRequested event.

En el controlador de eventos, establece el contexto de identidad de la empresa en el paquete de datos.In your event handler, set the enterprise identity context in the data package.

private void OnShareSourceOperation(object sender, RoutedEventArgs e)
{
    // Register the current page as a share source (or you could do this earlier in your app).
    DataTransferManager.GetForCurrentView().DataRequested += OnDataRequested;
    DataTransferManager.ShowShareUI();
}

private void OnDataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
    if (!string.IsNullOrEmpty(this.shareSourceContent))
    {
        var protectionPolicyManager = ProtectionPolicyManager.GetForCurrentView();
        DataPackage requestData = args.Request.Data;
        requestData.Properties.Title = this.shareSourceTitle;
        requestData.Properties.EnterpriseId = protectionPolicyManager.Identity;
        requestData.SetText(this.shareSourceContent);
    }
}

APIAPIs
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity

Proteger los archivos que copies en otra ubicaciónProtect files that you copy to another location

private async void CopyProtectionFromOneFileToAnother
    (StorageFile sourceStorageFile, StorageFile targetStorageFile)
{
    bool copyResult = await
        FileProtectionManager.CopyProtectionAsync(sourceStorageFile, targetStorageFile);

    if (!copyResult)
    {
        // Copying failed. To diagnose, you could check the file's status.
        // (call FileProtectionManager.GetProtectionInfoAsync and
        // check FileProtectionInfo.Status).
    }
}

APIAPIs
FileProtectionManager.CopyProtectionAsyncFileProtectionManager.CopyProtectionAsync

Proteger los datos de empresa cuando la pantalla del dispositivo esté bloqueadaProtect enterprise data when the screen of the device is locked

Elimina todos los datos confidenciales de la memoria si el dispositivo está bloqueado.Remove all sensitive data in memory when the device is locked. Una vez que el usuario desbloquee el dispositivo, la aplicación podrá volver a agregar esos datos de forma segura.When the user unlocks the device, your app can safely add that data back.

Controla el evento ProtectionPolicyManager.ProtectedAccessSuspending para que tu aplicación sepa cuando la pantalla está bloqueada.Handle the ProtectionPolicyManager.ProtectedAccessSuspending event so that your app knows when the screen is locked. Este evento se genera solo si el administrador configura una directiva de protección de datos con la pantalla bloqueada.This event is raised only if the administrator configures a secure data protection under lock policy. Windows elimina temporalmente las claves de protección de datos que se han aprovisionado en el dispositivo.Windows temporarily removes the data protection keys that are provisioned on the device. Windows elimina estas claves para garantizar que no hay ningún acceso no autorizado a los datos cifrados mientras el dispositivo esté bloqueado y posiblemente no esté con su propietario.Windows removes these keys to ensure that there is no unauthorized access to encrypted data while the device is locked and possibly not in possession of its owner.

Controla el evento ProtectionPolicyManager.ProtectedAccessResumed para que tu aplicación sepa cuando la pantalla está desbloqueada.Handle the ProtectionPolicyManager.ProtectedAccessResumed event so that your app knows when the screen is unlocked. Este evento se genera independientemente de si el administrador configura una directiva de protección de datos con la pantalla bloqueada.This event is raised regardless of whether the administrator configures a secure data protection under lock policy.

Eliminar datos confidenciales de la memoria cuando la pantalla esté bloqueadaRemove sensitive data in memory when the screen is locked

Protege la información confidencial y cierra cualquier flujo de archivo que tu aplicación haya abierto en los archivos protegidos para garantizar que el sistema no almacene en caché ningún dato confidencial de la memoria.Protect sensitive data, and close any file streams that your app has opened on protected files to help ensure that the system doesn't cache any sensitive data in memory.

Este ejemplo guarda el contenido de un bloque de texto en un búfer cifrado y elimina el contenido de dicho bloque de texto.This example saves content from a textblock to an encrypted buffer and removes the content from that textblock.

private async void ProtectionPolicyManager_ProtectedAccessSuspending(object sender, ProtectedAccessSuspendingEventArgs e)
{
    Deferral deferral = e.GetDeferral();

    if (ProtectionPolicyManager.GetForCurrentView().Identity != String.Empty)
    {
        IBuffer documentBodyBuffer = CryptographicBuffer.ConvertStringToBinary
           (documentTextBlock.Text, BinaryStringEncoding.Utf8);

        BufferProtectUnprotectResult result = await DataProtectionManager.ProtectAsync
            (documentBodyBuffer, ProtectionPolicyManager.GetForCurrentView().Identity);

        if (result.ProtectionInfo.Status == DataProtectionStatus.Protected)
        {
            this.protectedDocumentBuffer = result.Buffer;
            documentTextBlock.Text = null;
        }
    }

    // Close any open streams that you are actively working with
    // to make sure that we have no unprotected content in memory.

    // Optionally, code goes here to use e.Deadline to determine whether we have more
    // than 15 seconds left before the suspension deadline. If we do then process any
    // messages queued up for sending while we are still able to access them.

    deferral.Complete();
}

APIAPIs
ProtectionPolicyManager.ProtectedAccessSuspendingProtectionPolicyManager.ProtectedAccessSuspending
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity
DataProtectionManager.ProtectAsyncDataProtectionManager.ProtectAsync
BufferProtectUnprotectResult.bufferBufferProtectUnprotectResult.buffer
ProtectedAccessSuspendingEventArgs.GetDeferralProtectedAccessSuspendingEventArgs.GetDeferral
Deferral.CompleteDeferral.Complete

Agregar de nuevo datos confidenciales cuando el dispositivo está desbloqueadoAdd back sensitive data when the device is unlocked

ProtectionPolicyManager.ProtectedAccessResumed se genera una vez que las claves vuelven a estar disponibles en el momento del desbloqueo del dispositivo.ProtectionPolicyManager.ProtectedAccessResumed is raised when the device is unlocked and the keys are available on the device again.

ProtectedAccessResumedEventArgs.Identities es una colección vacía si el administrador no ha configurado una directiva de protección de datos con la pantalla bloqueada.ProtectedAccessResumedEventArgs.Identities is an empty collection if the administrator hasn't configured a secure data protection under lock policy.

En este ejemplo se hace lo contrario que en el ejemplo anterior.This example does the reverse of the previous example. Descifra el búfer, agrega de nuevo información de ese búfer al cuadro de texto y, a continuación, elimina el búfer.It decrypts the buffer, adds information from that buffer back to the textbox and then disposes of the buffer.

private async void ProtectionPolicyManager_ProtectedAccessResumed(object sender, ProtectedAccessResumedEventArgs e)
{
    if (ProtectionPolicyManager.GetForCurrentView().Identity != String.Empty)
    {
        BufferProtectUnprotectResult result = await DataProtectionManager.UnprotectAsync
            (this.protectedDocumentBuffer);

        if (result.ProtectionInfo.Status == DataProtectionStatus.Unprotected)
        {
            // Restore the unprotected version.
            documentTextBlock.Text = CryptographicBuffer.ConvertBinaryToString
                (BinaryStringEncoding.Utf8, result.Buffer);
            this.protectedDocumentBuffer = null;
        }
    }

}

APIAPIs
ProtectionPolicyManager.ProtectedAccessResumedProtectionPolicyManager.ProtectedAccessResumed
ProtectionPolicyManager.GetForCurrentViewProtectionPolicyManager.GetForCurrentView
ProtectionPolicyManager.IdentityProtectionPolicyManager.Identity
DataProtectionManager.UnprotectAsyncDataProtectionManager.UnprotectAsync
BufferProtectUnprotectResult.StatusBufferProtectUnprotectResult.Status

Administrar datos de empresa cuando se revoca el contenido protegidoHandle enterprise data when protected content is revoked

Si quieres que la aplicación reciba notificaciones cuando se haya anulado la inscripción de MDM del dispositivo o cuando el administrador de directivas revoque de manera explícita el acceso a los datos de empresa, controla el evento ProtectionPolicyManager_ProtectedContentRevoked.If you want your app to be notified when the device is un-enrolled from MDM or when the policy administrator explicitly revokes access to enterprise data, handle the ProtectionPolicyManager_ProtectedContentRevoked event.

Este ejemplo determina si se han revocado los datos en el buzón de la empresa para una aplicación de correo electrónico.This example determines if the data in an enterprise mailbox for an email app has been revoked.

private string mailIdentity = "contoso.com";

void MailAppSetup()
{
    ProtectionPolicyManager.ProtectedContentRevoked += ProtectionPolicyManager_ProtectedContentRevoked;
    // Code goes here to set up mailbox for 'mailIdentity'.
}

private void ProtectionPolicyManager_ProtectedContentRevoked(object sender, ProtectedContentRevokedEventArgs e)
{
    if (!new System.Collections.Generic.List<string>(e.Identities).Contains
        (this.mailIdentity))
    {
        // This event is not for our identity.
        return;
    }

    // Code goes here to delete any metadata associated with 'mailIdentity'.
}

APIAPIs
ProtectionPolicyManager_ProtectedContentRevokedProtectionPolicyManager_ProtectedContentRevoked

Muestra de Windows Information Protection (WIP)Windows Information Protection (WIP) sample