Guide du développeur Windows Information Protection (WIP)Windows Information Protection (WIP) developer guide

Une application compatible fait la distinction entre les données personnelles et d’entreprise et sait lesquelles protéger en fonction des stratégies de Protection des informations Windows définies par l’administrateur.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.

Dans ce guide, nous allons vous montrer comment créer une stratégie de ce type.In this guide, we'll show you how to build one. Une fois cette stratégie créée, les administrateurs de stratégie pourront faire confiance à votre application pour l’utilisation des données de leur organisation.When you're done, policy administrators will be able to trust your app to consume their organization's data. De plus, les employés apprécieront que vous ayez conservé leurs données personnelles intactes sur leur appareil même s’ils se sont désinscrits de la gestion des périphériques mobiles (GPM) de leur organisation ou s’ils ont quitté totalement l’organisation.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.

Remarque Ce guide vous aide à faire une application UWP.Note This guide helps you enlighten a UWP app. Si vous souhaitez vous aider à une application de bureau Windows en C++, consultez le Guide du développeur windows information protection (WIP) (c++).If you want to enlighten a C++ Windows desktop app, see Windows Information Protection (WIP) developer guide (C++).

Pour en savoir plus sur la stratégie de Protection des informations Windows et les applications compatibles, reportez-vous ici : Protection des informations Windows.You can read more about WIP and enlightened apps here: Windows Information Protection (WIP).

Vous trouverez ici un exemple complet.You can find a complete sample here.

Si vous êtes prêt à réaliser toutes les tâches, commençons.If you're ready to go through each task, let's start.

Tout d’abord, rassemblez ce dont vous avez besoin.First, gather what you need

Éléments requis :You'll need these:

  • Un ordinateur virtuel de test qui exécute Windows 10, version 1607 ou ultérieure.A test Virtual Machine (VM) that runs Windows 10, version 1607 or higher. Vous allez déboguer votre application par rapport à cette machine virtuelle de test.You'll debug your app against this test VM.

  • Un ordinateur de développement qui exécute Windows 10, version 1607 ou ultérieure.A development computer that runs Windows 10, version 1607 or higher. Il peut s’agir de votre machine virtuelle si vous y avez installé Visual Studio.This could be your test VM if you have Visual Studio installed on it.

Configurer votre environnement de développementSetup your development environment

Vous allez effectuer les opérations suivantes :You'll do these things:

Installer l’outil WIP Setup Developer Assistant sur votre machine virtuelle de testInstall the WIP Setup Developer Assistant onto your test VM

Utilisez cet outil pour configurer une stratégie de protection des informations Windows (WIP) sur votre machine virtuelle de test.Use this tool to setup a Windows Information Protection policy on your test VM.

Téléchargez l’outil ici : WIP Setup Developer Assistant.Download the tool here: WIP Setup Developer Assistant.

Création d’une stratégie de protectionCreate a protection policy

Définissez votre stratégie en ajoutant des informations dans chaque section de l’outil WIP Setup Developer Assistant.Define your policy by adding information to each section in the WIP setup developer assistant. Cliquez sur l’icône d’aide située en regard d’un paramètre pour en savoir plus sur la manière de l’utiliser.Choose the help icon next to any setting to learn more about how to use it.

Pour obtenir des recommandations plus générales sur la façon d’utiliser cet outil, voir la section relative aux notes de version sur la page de téléchargement de l’application.For more general guidance about how to use this tool, see the Version notes section on the app download page.

Configurer un projet Visual StudioSetup a Visual Studio project

  1. Sur votre ordinateur de développement, ouvrez votre projet.On your development computer, open your project.

  2. Ajoutez une référence aux extensions mobiles et de bureau pour la plateforme Windows universelle (UWP).Add a reference to the desktop and mobile extensions for Universal Windows Platform (UWP).

    Ajouter des extensions UWP

  3. Ajoutez cette fonctionnalité à votre fichier manifeste de package :Add this capability to your package manifest file:

       <rescap:Capability Name="enterpriseDataPolicy"/>
    

    Lecture facultative : le préfixe « rescap » signifie fonctionnalité restreinte.Optional Reading: The "rescap" prefix means Restricted Capability. Voir Fonctionnalités spéciales et restreintes.See Special and restricted capabilities.

  4. Ajoutez cet espace de noms à votre fichier manifeste de package :Add this namespace to your package manifest file:

      xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
    
  5. Ajoutez le préfixe d’espace de noms à l’élément <ignorableNamespaces> de votre fichier manifeste de package.Add the namespace prefix to the <ignorableNamespaces> element of your package manifest file.

        <IgnorableNamespaces="uap mp rescap">
    

    Ainsi, si votre application s’exécute sur une version du système d’exploitation Windows qui ne prend pas en charge les fonctionnalités restreintes, Windows ignore la fonctionnalité 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.

Configurer le débogage à distanceSetup remote debugging

Installez Visual Studio Remote Tools sur votre machine virtuelle de test uniquement si vous développez votre application sur un ordinateur autre que votre machine virtuelle.Install Visual Studio Remote Tools on your test VM only if you are developing your app on a computer other than your VM. Ensuite, lancez le débogueur à distance sur votre ordinateur de développement et voyez si votre application s’exécute sur la machine virtuelle de test.Then, on your development computer start the remote debugger and see if your app runs on the test VM.

Voir Instructions pour un PC distant.See Remote PC instructions.

Ajouter ces espaces de noms aux fichiers de codeAdd these namespaces to your code files

Ajoutez-les à l’aide des instructions dans la partie supérieure de vos fichiers de code (les extraits de code de ce guide les utilisent) :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;

Déterminer si les API WIP doivent être utilisées dans votre applicationDetermine whether to use WIP APIs in your app

Assurez-vous que le système d’exploitation qui exécute votre application prend en charge WIP et que WIP est activé sur l’appareil.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;
}

N’appelez pas les API WIP si le système d’exploitation ne prend pas en charge WIP ou WIP n’est pas activé sur l’appareil.Don't call WIP APIs if the operating system doesn't support WIP or WIP is not enabled on the device.

Lire des données d’entrepriseRead enterprise data

Pour lire les fichiers protégés, les points de terminaison réseau, les données du presse-papiers et les données que vous acceptez d’un contrat de partage, votre application doit demander l’accès.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 donne à votre application l’autorisation si votre application se trouve dans la liste autorisée de la stratégie de protection.Windows Information Protection gives your app permission if your app is on the protection policy's allowed list.

Dans cette section :In this section:

Lire les données d’un fichierRead data from a file

Étape 1 : Obtenir le descripteur de fichierStep 1: Get the file handle

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

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

Étape 2 : Déterminer si votre application peut ouvrir le fichierStep 2: Determine whether your app can open the file

Appelez FileProtectionManager. GetProtectionInfoAsync pour déterminer si votre application peut ouvrir le fichier.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.
}

Une valeur FileProtectionStatus de protégé signifie que le fichier est protégé et que votre application peut l’ouvrir parce que votre application se trouve dans la liste autorisée de la stratégie.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.

Une valeur FileProtectionStatus non protégée signifie que le fichier n’est pas protégé et que votre application peut ouvrir le fichier même si votre application ne figure pas dans la liste autorisée de la stratégie.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

Étape 3 : Lire le fichier dans un flux ou une mémoire tamponStep 3: Read the file into a stream or buffer

Lire le fichier dans un fluxRead the file into a stream

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

Lire le fichier dans une mémoire tamponRead the file into a buffer

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

Lire les données à partir d’un point de terminaison réseauRead data from a network endpoint

Créez un contexte de thread protégé pour une lecture à partir d’un point de terminaison d’entreprise.Create a protected thread context to read from an enterprise endpoint.

Étape 1 : Obtenir l’identité du point de terminaison réseauStep 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 le point de terminaison n’est pas géré par la stratégie, vous obtenez une chaîne vide.If the endpoint isn't managed by policy, you'll get back an empty string.

APIAPIs
ProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsyncProtectionPolicyManager.GetPrimaryManagedIdentityForNetworkEndpointAsync

Étape 2 : Créer un contexte de thread protégéStep 2: Create a protected thread context

Si le point de terminaison est géré par la stratégie, créez un contexte de thread protégé.If the endpoint is managed by policy, create a protected thread context. Cela associe les connexions réseau que vous effectuez sur le même thread à l’identité.This tags any network connections that you make on the same thread to the identity.

Cela vous donne également accès aux ressources réseau d’entreprise qui sont gérées par cette stratégie.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);
}

Cet exemple joint les appels de socket dans un bloc using.This example encloses socket calls in a using block. Si vous ne procédez pas ainsi, veillez à fermer le contexte de thread une fois votre ressource récupérée.If you don't do this, make sure that you close the thread context after you've retrieved your resource. Voir ThreadNetworkContext.Close.See ThreadNetworkContext.Close.

Ne créez pas de fichiers personnels sur ce thread protégé dans la mesure où ces fichiers sont automatiquement chiffrés.Don't create any personal files on that protected thread because those files will be automatically encrypted.

La méthode ProtectionPolicyManager. CreateCurrentThreadNetworkContext retourne un objet ThreadNetworkContext , que le point de terminaison soit géré ou non par la stratégie.The ProtectionPolicyManager.CreateCurrentThreadNetworkContext method returns a ThreadNetworkContext object whether or not the endpoint is being managed by policy. Si votre application gère à la fois les ressources personnelles et les ressources d’entreprise, appelez ProtectionPolicyManager. CreateCurrentThreadNetworkContext pour toutes les identités.If your app handles both personal and enterprise resources, call ProtectionPolicyManager.CreateCurrentThreadNetworkContext for all identities. Après avoir récupéré la ressource, supprimez ThreadNetworkContext afin d’effacer tout marquage d’identité sur le thread actuel.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

Étape 3 : Lire la ressource dans une mémoire tamponStep 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; }
}

Facultatif Utiliser un jeton d’en-tête au lieu de créer un contexte de thread protégé(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; }
}

Gérer les redirections de pageHandle page redirects

Parfois, un serveur web redirige le trafic vers une version plus récente d’une ressource.Sometimes a web server will redirect traffic to a more current version of a resource.

Pour gérer cette situation, effectuez des requêtes jusqu’à ce que l’état de la réponse à votre requête ait la valeur OK.To handle this, make requests until the response status of your request has a value of OK.

Utilisez ensuite l’URI de cette réponse pour obtenir l’identité du point de terminaison.Then use the URI of that response to get the identity of the endpoint. Voici une façon d’effectuer cette opération :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

Lire des données à partir du Presse-papiersRead data from the clipboard

Obtenir l’autorisation d’utiliser des données à partir du Presse-papiersGet permission to use data from the clipboard

Pour obtenir des données à partir du Presse-papiers, demandez l’autorisation à Windows.To get data from the clipboard, ask Windows for permission. Pour ce faire, utilisez DataPackageView. RequestAccessAsync .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

Masquer ou désactiver des fonctionnalités qui utilisent des données du Presse-papiersHide or disable features that use clipboard data

Déterminez si l’affichage en cours a l’autorisation d’obtenir des données du Presse-papiers.Determine whether current view has permission to get data that is on the clipboard.

Si tel n’est pas le cas, vous pouvez désactiver ou masquer les contrôles qui permettent aux utilisateurs de coller des informations à partir du Presse-papiers ou d’afficher un aperçu de son contenu.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

Empêcher les utilisateurs d’être invités via une boîte de dialogue de consentementPrevent users from being prompted with a consent dialog box

Un nouveau document n’est pas personnel ou d’entreprise.A new document isn't personal or enterprise. Il est tout simplement nouveau.It's just new. Si un utilisateur colle des données d’entreprise dans celui-ci, Windows applique la stratégie et l’utilisateur est invité via une boîte de dialogue de consentement.If a user pastes enterprise data into it, Windows enforces policy and the user is prompted with a consent dialog. Ce code évite que cela ne se produise.This code prevents that from happening. Cette opération ne vise pas à protéger les données.This task is not about helping to protect data. Mais davantage à éviter aux utilisateurs de recevoir des boîtes de dialogue de consentement lorsque l’application crée un tout nouvel élément.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

Lire des données à partir d’un contrat de partageRead data from a Share contract

Lorsque les employés choisissent votre application pour partager leurs informations, votre application ouvre un nouvel élément qui contient ce contenu.When employees choose your app to share their information, your app will open a new item that contains that content.

Comme nous l’avons mentionné précédemment, un nouvel élément n’est pas personnel ou d’entreprise.As we mentioned earlier, a new item isn't personal or enterprise. Il est tout simplement nouveau.It's just new. Si votre code ajoute un contenu d’entreprise à l’élément, Windows applique la stratégie et l’utilisateur est invité via une boîte de dialogue de consentement.If your code adds enterprise content to the item, Windows enforces policy and the user is prompted with a consent dialog. Ce code évite que cela ne se produise.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

Protéger les données d’entrepriseProtect enterprise data

Protégez les données d’entreprise qui quittent votre application.Protect enterprise data that leaves your app. Les données quittent votre application quand vous les affichez dans une page, les enregistrez dans un fichier ou un point de terminaison réseau ou via un contrat de partage.Data leaves your app when you show it in a page, save it to a file or network endpoint, or through a share contract.

Dans cette section :In this section:

Protéger les données qui s’affichent dans les pagesProtect data that appears in pages

Lorsque vous affichez des données dans une page, signalez à Windows de quel type de données il s’agit (personnel ou entreprise).When you show data in a page, let Windows know what type of data it is (personal or enterprise). Pour ce faire, marquez la vue actuelle de l’application ou le processus d’application tout entier.To do that, tag the current app view or tag the entire app process.

Lorsque vous marquez la vue ou le processus, Windows applique la stratégie sur celui ou celle-ci.When you tag the view or the process, Windows enforces policy on it. Cela permet d’empêcher toute fuite de données résultant d’actions que votre application ne contrôle pas.This helps prevent data leaks that result from actions that your app doesn't control. Par exemple, sur un ordinateur, un utilisateur pourrait utiliser CTRL + V pour copier les informations d’entreprise à partir d’une vue, puis les coller dans une autre application.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 offre une protection contre ce type d’action.Windows protects against that. Windows vous permet également d’appliquer des contrats de partage.Windows also helps to enforce share contracts.

Marquer la vue de l’application actuelleTag the current app view

Procédez ainsi si votre application comporte plusieurs vues utilisant pour certaines des données d’entreprise et pour d’autres des données personnelles.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

Marquer le processusTag the process

Procédez ainsi si toutes les vues de votre application fonctionnent avec un seul type de données (personnelles ou d’entreprise).Do this if all views in your app will work with only one type of data (personal or enterprise).

Cela vous empêche d’avoir à gérer des vues marquées de manière indépendante.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

Protéger les données dans un fichierProtect data to a file

Créez un fichier protégé, puis écrivez dans celui-ci.Create a protected file and then write to it.

Étape 1 : Déterminer si votre application peut créer un fichier d’entrepriseStep 1: Determine if your app can create an enterprise file

Votre application peut créer un fichier d’entreprise si la chaîne d’identité est gérée par la stratégie et si votre application se trouve sur la liste des éléments autorisés de cette stratégie.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

Étape 2 : Créer le fichier et le protéger sur l’identitéStep 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

Étape 3 : Écrire ce flux ou cette mémoire tampon dans le fichierStep 3: Write that stream or buffer to the file

Écrire un fluxWrite 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);
            }
        }

    }

Écrire une mémoire tamponWrite 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

Protéger les données dans un fichier sous forme de processus d’arrière-planProtect data to a file as a background process

Ce code peut s’exécuter lorsque l’écran de l’appareil est verrouillé.This code can run while the screen of the device is locked. Si l’administrateur a configuré une stratégie sécurisée de protection des données d’entreprise verrouillées, Windows supprime les clés de chiffrement nécessaires pour accéder aux ressources protégées à partir de la mémoire de l’appareil.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. Cela empêche toute fuite de données si l’appareil est perdu.This prevents data leaks if the device is lost. Cette même fonctionnalité supprime également les clés associées aux fichiers protégés lorsque leurs descripteurs sont fermés.This same feature also removes keys associated with protected files when their handles are closed.

Vous devez utiliser une approche qui maintient le descripteur de fichier ouvert lorsque vous créez un fichier.You'll have to use an approach that keeps the file handle open when you create a file.

Étape 1 : Déterminer si vous pouvez créer un fichier d’entrepriseStep 1: Determine if you can create an enterprise file

Vous pouvez créer un fichier d’entreprise si l’identité utilisée est gérée par la stratégie et si votre application se trouve sur la liste des éléments autorisés de cette stratégie.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

Étape 2 : Créer un fichier et le protéger sur l’identitéStep 2: Create a file and protect it to the identity

FileProtectionManager.CreateProtectedAndOpenAsync crée un fichier protégé et garde le descripteur de fichier ouvert lorsque vous écrivez dans celui-ci.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

Étape 3 : Écrire un flux ou une mémoire tampon dans le fichierStep 3: Write a stream or buffer to the file

Cet exemple écrit un flux de données dans un fichier.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

Protéger une partie de fichierProtect part of a file

Dans la plupart des cas, il est préférable de stocker séparément vos données personnelles et d’entreprise. Toutefois, vous pouvez les stocker dans le même fichier si vous le souhaitez.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. Par exemple, Microsoft Outlook peut stocker des messages d’entreprise avec des messages personnels dans un fichier d’archive unique.For example, Microsoft Outlook can store enterprise mails alongside of personal mails in a single archive file.

Chiffrez les données d’entreprise, mais pas la totalité du fichier.Encrypt the enterprise data but not the entire file. De cette façon, les utilisateurs peuvent continuer d’utiliser ce fichier, même s’ils se désinscrivent de la GPM ou si leurs droits d’accès aux données de l’entreprise sont révoqués.That way, users can continue using that file even if they un-enroll from MDM or their enterprise data access rights are revoked. En outre, votre application doit suivre les données qu’elle chiffre afin de savoir quelles données protéger lorsqu’elle relit de nouveau le fichier en mémoire.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.

Étape 1 : Ajouter des données d’entreprise à un flux ou à une mémoire tampon chiffréeStep 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

Étape 2 : Ajouter des données personnelles à un flux ou à une mémoire tampon chiffréeStep 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);

Étape 3 : Écrire les flux ou les mémoires tampons dans un fichierStep 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();
    }
}

Étape 4 : Garder une trace de l’emplacement de vos données d’entreprise dans le fichierStep 4: Keep track of the location of your enterprise data in the file

Il incombe à votre application de suivre les données de ce fichier dont l’entreprise est propriétaire.It's the responsibility of your app to keep track of the data in that file that is enterprise owned.

Vous pouvez stocker ces informations dans une propriété associée au fichier, dans une base de données ou dans le texte d’en-tête du fichier.You can store that information in a property associated with the file, in a database, or in some header text in the file.

Cet exemple enregistre ces informations dans un fichier XML distinct.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>");

Lire la partie protégée d’un fichierRead the protected part of a file

Voici comment vous liriez les données d’entreprise issues de ce fichier.Here's how you'd read the enterprise data out of that file.

Étape 1 : Obtenir la position de vos données d’entreprise dans le fichierStep 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);

Étape 2 : Ouvrir le fichier de données et s’assurer qu’il n’est pas protégéStep 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

Étape 3 : Lire des données de l’entreprise issues du fichierStep 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);

Étape 4 : Déchiffrer la mémoire tampon qui contient les données d’entrepriseStep 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

Protéger les données dans un fichierProtect data to a folder

Vous pouvez créer un dossier et le protéger.You can create a folder and protect it. De cette façon tous les éléments que vous ajoutez à ce dossier sont automatiquement protégés.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;
}

Assurez-vous que le dossier est vide avant de le protéger.Make sure that the folder is empty before you protect it. Vous ne pouvez pas protéger un dossier contenant déjà des éléments.You can't protect a folder that already contains items.

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

Protéger les données sur un point de terminaison réseauProtect data to a network end point

Créez un contexte de thread protégé pour envoyer ces données vers un point de terminaison d’entreprise.Create a protected thread context to send that data to an enterprise endpoint.

Étape 1 : Obtenir l’identité du point de terminaison réseauStep 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

Étape 2 : Créer un contexte de thread protégé et envoyer des données au point de terminaison réseauStep 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

Protéger les données que votre application partage via un contrat de partageProtect data that your app shares through a share contract

Si vous voulez que les utilisateurs partagent le contenu à partir de votre application, vous devez implémenter un contrat de partage et gérer l’événement 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.

Dans votre gestionnaire d’événements, définissez le contexte de l’identité d’entreprise dans le package de données.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

Protéger les fichiers que vous copiez vers un autre emplacementProtect 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

Protéger les données d’entreprise lorsque l’écran de l’appareil est verrouilléProtect enterprise data when the screen of the device is locked

Supprimez toutes les données sensibles de la mémoire quand l’appareil est verrouillé.Remove all sensitive data in memory when the device is locked. Lorsque l’utilisateur déverrouille l’appareil, votre application peut rajouter en toute sécurité ces données.When the user unlocks the device, your app can safely add that data back.

Gérez l’événement ProtectionPolicyManager. ProtectedAccessSuspending afin que votre application sache quand l’écran est verrouillé.Handle the ProtectionPolicyManager.ProtectedAccessSuspending event so that your app knows when the screen is locked. Cet événement est déclenché uniquement si l’administrateur configure une stratégie sécurisée de protection des données d’entreprise verrouillées.This event is raised only if the administrator configures a secure data protection under lock policy. Windows supprime temporairement les clés de protection des données approvisionnées sur l’appareil.Windows temporarily removes the data protection keys that are provisioned on the device. Windows supprime ces clés pour s’assurer qu’il n’y a aucun accès non autorisé à des données chiffrées, tandis que l’appareil est verrouillé et éventuellement pas en possession de son propriétaire.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.

Gérez l’événement ProtectionPolicyManager.ProtectedAccessResumed de sorte que votre application sache que l’écran est déverrouillé.Handle the ProtectionPolicyManager.ProtectedAccessResumed event so that your app knows when the screen is unlocked. Cet événement est déclenché que l’administrateur ait configuré ou non une stratégie sécurisée de protection des données d’entreprise verrouillées.This event is raised regardless of whether the administrator configures a secure data protection under lock policy.

Supprimer les données sensibles dans la mémoire quand l’écran est verrouilléRemove sensitive data in memory when the screen is locked

Protégez les données sensibles et fermez les flux de fichiers ouverts par votre application sur les fichiers protégés pour s’assurer que le système ne met pas en cache de données sensibles.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.

Cet exemple enregistre le contenu d’un élément textblock dans une mémoire tampon chiffrée et supprime le contenu de cet élément.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

Ajouter des données sensibles revenir lorsque l’appareil est déverrouilléAdd back sensitive data when the device is unlocked

ProtectionPolicyManager. ProtectedAccessResumed est déclenché lorsque l’appareil est déverrouillé et que les clés sont à nouveau disponibles sur l’appareil.ProtectionPolicyManager.ProtectedAccessResumed is raised when the device is unlocked and the keys are available on the device again.

ProtectedAccessResumedEventArgs. Identities est un regroupement vide si l’administrateur n’a pas configuré une protection sécurisée des données sous la stratégie de verrouillage.ProtectedAccessResumedEventArgs.Identities is an empty collection if the administrator hasn't configured a secure data protection under lock policy.

Cet exemple effectue l’opération inverse de l’exemple précédent.This example does the reverse of the previous example. Il déchiffre la mémoire tampon, rajoute des informations à partir de celle-ci dans l’élément textbox, puis supprime la mémoire tampon.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

Gérer les données d’entreprise lorsque du contenu protégé est révoquéHandle enterprise data when protected content is revoked

Si vous voulez que votre application soit avertie lorsque l’appareil est désinscrit de la GPM ou lorsque l’administrateur de la stratégie révoque explicitement l’accès aux données d’entreprise, gérez l’événement 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.

Cet exemple détermine si les données d’une boîte aux lettres d’entreprise pour une application de messagerie ont été révoquées.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

Exemple de Protection des informations WindowsWindows Information Protection (WIP) sample