Démarrage rapide : Définir et obtenir une étiquette de sensibilité (C++)

Ce guide de démarrage rapide vous montre comment utiliser davantage de kits SDK de fichiers MIP. À l’aide de l’une des étiquettes de confidentialité que vous avez répertoriées dans le guide de démarrage rapide précédent, vous utilisez un gestionnaire de fichiers pour définir/obtenir l’étiquette sur un fichier. La classe de gestionnaire de fichiers expose différentes opérations pour définir/obtenir des étiquettes ou une protection pour les types de fichiers pris en charge.

Prerequisites

Si ce n’est déjà fait, veillez à remplir les conditions préalables suivantes avant de continuer :

• Commencez d'abord par le guide de démarrage rapide : Listez les étiquettes de sensibilité (C++), qui crée une solution de démarrage Visual Studio, pour répertorier les étiquettes de sensibilité d'une organisation. Ce guide de démarrage rapide « Définir et obtenir une étiquette de confidentialité » s’appuie sur le précédent.
• Si vous le souhaitez , passez en revue les gestionnaires de fichiers dans les concepts du Kit de développement logiciel (SDK) MIP .

Implémenter une classe d’observateur pour surveiller l’objet gestionnaire de fichiers

Comme pour l’observateur que vous avez implémenté (pour le profil de fichier et le moteur) dans le démarrage rapide de l’initialisation de l’application, vous implémentez maintenant une classe d’observateur pour un objet gestionnaire de fichiers.

Créez une implémentation de base pour un observateur de gestionnaires de fichiers, en étendant la classe mip::FileHandler::Observer du kit de développement logiciel (SDK). L’observateur est instancié et utilisé ultérieurement pour surveiller les opérations du gestionnaire de fichiers.

1. Ouvrez la solution Visual Studio sur laquelle vous avez travaillé dans l’article précédent « Démarrage rapide : Répertorier les étiquettes de confidentialité (C++) ».

2. Ajoutez une nouvelle classe à votre projet, qui génère à la fois les fichiers d’en-tête/.h et d’implémentation/.cpp pour vous :

   • Dans l’Explorateur de solutions, cliquez à nouveau avec le bouton droit sur le nœud du projet, sélectionnez Ajouter, puis sélectionnez Classe.
   • Dans la boîte de dialogue Ajouter une classe :
     • Dans le champ Nom de la classe , entrez « filehandler_observer ». Notez que le fichier .h et les champs de fichier .cpp sont automatiquement renseignés en fonction du nom que vous entrez.
     • Lorsque vous avez terminé, cliquez sur le bouton OK .

3. Après avoir généré les fichiers .h et .cpp pour la classe, les deux fichiers sont ouverts dans les onglets groupe d’éditeurs. À présent, mettez à jour chaque fichier pour implémenter votre nouvelle classe d’observateur :

   • Mettez à jour « filehandler_observer.h », en sélectionnant/supprimant la classe générée filehandler_observer . Ne supprimez pas les directives de préprocesseur générées par l’étape précédente (#pragma, #include). Copiez/collez ensuite la source suivante dans le fichier, après toutes les directives de préprocesseur existantes :

     #include <memory>
     #include "mip/file/file_engine.h"
     #include "mip/file/file_handler.h"
     
     class FileHandlerObserver final : public mip::FileHandler::Observer {
     public:
        FileHandlerObserver() { }
        // Observer implementation
        void OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) override;
        void OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
        void OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) override;
        void OnCommitFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;		
     };
     

   • Mettez à jour « filehandler_observer.cpp », en sélectionnant/supprimant l’implémentation de classe générée filehandler_observer . Ne supprimez pas les directives de préprocesseur générées par l’étape précédente (#pragma, #include). Copiez/collez ensuite la source suivante dans le fichier, après toutes les directives de préprocesseur existantes :

     void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
        auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
        promise->set_value(fileHandler);
     }
     
     void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
        auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
        promise->set_exception(error);
     }
     
     void FileHandlerObserver::OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) {
        auto promise = std::static_pointer_cast<std::promise<bool>>(context);
        promise->set_value(committed);
     }
     
     void FileHandlerObserver::OnCommitFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
        auto promise = std::static_pointer_cast<std::promise<bool>>(context);
        promise->set_exception(error);
     }
     

4. Si vous le souhaitez, utilisez F6 (Build Solution) pour exécuter une compilation de test/lien de votre solution pour vous assurer qu’elle est générée correctement avant de continuer.

Ajouter une logique pour définir et obtenir une étiquette de sensibilité

Ajoutez une logique pour définir et obtenir une étiquette de confidentialité sur un fichier, à l’aide de l’objet moteur de fichiers.

1. À l’aide de l’Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la main() méthode. Il a par défaut le même nom que le projet qui le contient, que vous avez spécifié lors de la création du projet.

2. Ajoutez les directives suivantes #include , using sous les directives existantes correspondantes, en haut du fichier :

   #include "filehandler_observer.h" 
   #include "mip/file/file_handler.h" 
   
   using mip::FileHandler;
   

3. Vers la fin du main() corps, en dessous de system("pause"); et au-dessus de return 0; (où vous vous êtes arrêté dans le Quickstart précédent), insérez le code suivant :

   // Set up async FileHandler for input file operations
   string inputFilePath = "<input-file-path>";
   string actualFilePath = "<content-identifier>";
   std::shared_ptr<FileHandler> handler;
   try
   {
        auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
        auto handlerFuture = handlerPromise->get_future();
        engine->CreateFileHandlerAsync(
             inputFilePath,
             actualFilePath,                       
             true, 
             std::make_shared<FileHandlerObserver>(), 
             handlerPromise);
        handler = handlerFuture.get();
   }
   catch (const std::exception& e)
   {
        cout << "An exception occurred... did you specify a valid input file path?\n\n" << e.what() << "'\n";
        system("pause");
        return 1;
   }
   
   // Set a label on input file
   try
   {
        string labelId = "<label-id>";
        cout << "\nApplying Label ID " << labelId << " to " << filePathIn << endl;
        mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
        handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, new ProtectionSettings());
   }
   catch (const std::exception& e)
   {
        cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
        system("pause");
        return 1; 
   }
   
   // Commit changes, save as a different/output file
   string filePathOut = "<output-file-path>";
   try
   {
    	cout << "Committing changes" << endl;
        auto commitPromise = std::make_shared<std::promise<bool>>();
        auto commitFuture = commitPromise->get_future();
        handler->CommitAsync(filePathOut, commitPromise);
    	if (commitFuture.get()) {
    		cout << "\nLabel committed to file: " << filePathOut << endl;
    	}
    	else {
    		cout << "Failed to label: " + filePathOut << endl;
    		return 1;
    	}
   }
   catch (const std::exception& e)
   {
        cout << "An exception occurred... did you specify a valid commit file path?\n\n" << e.what() << "'\n";
        system("pause");
        return 1;
   }
   system("pause");
   
   // Set up async FileHandler for output file operations
   actualFilePath = "<content-identifier>";
   try
   {
        auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
        auto handlerFuture = handlerPromise->get_future();
        engine->CreateFileHandlerAsync(
             filePathOut,
             actualFilePath,
             true,
             std::make_shared<FileHandlerObserver>(),
             handlerPromise);
   
        handler = handlerFuture.get();
   }
   catch (const std::exception& e)
   {
        cout << "An exception occurred... did you specify a valid output file path?\n\n" << e.what() << "'\n";
        system("pause");
        return 1;
   }
   
   // Get the label from output file
   try
   {
        cout << "\nGetting the label committed to file: " << filePathOut << endl;
        auto label = handler->GetLabel();
        cout << "Name: " + label->GetLabel()->GetName() << endl;
        cout << "Id: " + label->GetLabel()->GetId() << endl;
   }
   catch (const std::exception& e)
   {
        cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
        system("pause");
        return 1;
   }
   system("pause");
   

4. Vers la fin de main(), trouvez le bloc d'arrêt de l'application créé dans le premier démarrage rapide et supprimez les marques de commentaire de la ligne du gestionnaire :

   // Application shutdown. Null out profile and engine, call ReleaseAllResources();
   // Application may crash at shutdown if resources aren't properly released.
   profile = nullptr;
   engine = nullptr;
   handler = nullptr;
   mipContext = nullptr;
   

5. Remplacez les valeurs d’espace réservé dans le code source que vous suivez, à l’aide de constantes de chaîne :

   Espace réservé	Valeur
   <chemin du fichier d'entrée>	Chemin complet d’un fichier d’entrée de test, par exemple : "c:\\Test\\Test.docx".
   <identifiant de contenu>	Identificateur lisible par l’utilisateur pour le contenu. Par exemple: pour un fichier, considérez le chemin/nom_fichier : "c:\Test\Test.docx" pour un e-mail, envisagez l’objet : expéditeur : "RE: Audit design:user1@contoso.com"
   <label-id>	ID d'étiquette de sensibilité, copié depuis la sortie de la console dans le Quickstart précédent, par exemple : "f42a3342-8706-4288-bd31-ebb85995028z".
   <output-file-path>	Chemin complet du fichier de sortie, qui sera une copie étiquetée du fichier d’entrée, par exemple : "c:\\Test\\Test_labeled.docx".

Concevoir et tester l’application

Générez et testez votre application cliente.

1. Utilisez F6 (Build Solution) pour générer votre application cliente. Si vous n’avez aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

2. Si votre projet génère et s’exécute correctement, l’application demande un jeton d’accès, chaque fois que le SDK appelle votre AcquireOAuth2Token() méthode. Comme vous l’avez fait précédemment dans le guide de démarrage rapide « Répertorier les étiquettes de confidentialité », exécutez votre script PowerShell pour acquérir le jeton chaque fois, en utilisant les valeurs fournies pour $authority et $resourceUrl.

   Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
   
   Sensitivity labels for your organization:
   Non-Business : 87ba5c36-17cf-14793-bbc2-bd5b3a9f95cz
   Public : 83867195-f2b8-2ac2-b0b6-6bb73cb33afz
   General : f42a3342-8706-4288-bd31-ebb85995028z
   Confidential : 074e457c-5848-4542-9a6f-34a182080e7z
   Highly Confidential : f55c2dea-db0f-47cd-8520-a52e1590fb6z
   Press any key to continue . . .
   
   Applying Label ID 074e457c-5848-4542-9a6f-34a182080e7z to c:\Test\Test.docx
   Committing changes
   
   Label committed to file: c:\Test\Test_labeled.docx
   Press any key to continue . . .
   
   Getting the label committed to file: c:\Test\Test_labeled.docx
   Name: Confidential
   Id: 074e457c-5848-4542-9a6f-34a182080e7z
   Press any key to continue . . .
   

Vous pouvez vérifier l’application de l’étiquette en ouvrant le fichier de sortie et en inspectant visuellement les paramètres de protection des informations du document.