Partager via

Démarrage rapide : Chiffrer/Déchiffrer du texte à l’aide du Kit de développement logiciel (SDK) MIP (C++)

Ce guide de démarrage rapide vous montre comment utiliser davantage de kits SDK de protection MIP. À l’aide de l’un des modèles de protection que vous avez répertoriés dans le guide de démarrage rapide précédent, vous utilisez un gestionnaire protection pour chiffrer du texte ad hoc. La classe de gestionnaire Protection expose différentes opérations pour appliquer/supprimer la protection.

Conditions préalables

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

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

Comme pour l’observateur que vous avez implémenté (pour le profil et le moteur de protection) dans le guide de démarrage rapide de l’initialisation de l’application, vous implémentez maintenant une classe d’observateur pour les objets de gestion du système de protection.

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

  1. Ouvrez la solution Visual Studio sur laquelle vous avez travaillé dans l’article précédent « Démarrage rapide : Répertorier les modèles de protection (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 « handler_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 « handler_observer.h », en sélectionnant/supprimant la classe générée handler_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/protection/protection_engine.h"
using std::shared_ptr;
using std::exception_ptr;

class ProtectionHandlerObserver final : public mip::ProtectionHandler::Observer {
     public:
     ProtectionHandlerObserver() { }
     void OnCreateProtectionHandlerSuccess(const shared_ptr<mip::ProtectionHandler>& protectionHandler, const shared_ptr<void>& context) override;
     void OnCreateProtectionHandlerFailure(const exception_ptr& Failure, const shared_ptr<void>& context) override;
     };

    • Mettez à jour « handler_observer.cpp », en sélectionnant/supprimant l’implémentation de classe générée handler_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 "handler_observer.h"
using std::shared_ptr;
using std::promise;
using std::exception_ptr;

void ProtectionHandlerObserver::OnCreateProtectionHandlerSuccess(
     const shared_ptr<mip::ProtectionHandler>& protectionHandler,const shared_ptr<void>& context) {
          auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
          createProtectionHandlerPromise->set_value(protectionHandler);
          };

void ProtectionHandlerObserver::OnCreateProtectionHandlerFailure(
     const exception_ptr& Failure, const shared_ptr<void>& context) {
          auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get())
          createProtectionHandlerPromise->set_exception(Failure);
          };

  4. Si vous le souhaitez, utilisez Ctrl+Maj+B (Solution de génération) pour exécuter une compilation de test/lien de votre solution, pour vous assurer qu’elle s’exécute correctement avant de continuer.

Ajouter une logique pour chiffrer et déchiffrer du texte ad hoc

Ajoutez une logique pour chiffrer et déchiffrer du texte ad hoc à l’aide de l’objet moteur de protection.

  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.

  2. Ajoutez les #include et directives d’utilisation suivantes, sous les directives existantes correspondantes, en haut du fichier :

      #include "mip/protection/protection_descriptor_builder.h"
  #include "mip/protection_descriptor.h"
  #include "handler_observer.h"

  using mip::ProtectionDescriptor;
  using mip::ProtectionDescriptorBuilder;
  using mip::ProtectionHandler;

  3. Vers la fin de la section Main(), à l'emplacement où vous vous êtes arrêté dans le Quickstart précédent, insérez le code suivant :

    //Encrypt/Decrypt text:
string templateId = "<Template-ID>";//Template ID from previous QuickStart e.g. "bb7ed207-046a-4caf-9826-647cff56b990"
string inputText = "<Sample-Text>";//Sample Text

//Refer to ProtectionDescriptor docs for details on creating the descriptor
auto descriptorBuilder = mip::ProtectionDescriptorBuilder::CreateFromTemplate(templateId);
const std::shared_ptr<mip::ProtectionDescriptor>& descriptor = descriptorBuilder->Build();

//Create Publishing settings using a descriptor
mip::ProtectionHandler::PublishingSettings publishingSettings = mip::ProtectionHandler::PublishingSettings(descriptor);

//Create a publishing protection handler using Protection Descriptor
auto handlerObserver = std::make_shared<ProtectionHandlerObserver>();
engine->CreateProtectionHandlerForPublishingAsync(publishingSettings, handlerObserver, pHandlerPromise);
auto publishingHandler = pHandlerFuture.get();

std::vector<uint8_t> inputBuffer(inputText.begin(), inputText.end());

//Show action plan
cout << "Applying Template ID " + templateId + " to: " << endl << inputText << endl;

//Encrypt buffer using Publishing Handler
std::vector<uint8_t> encryptedBuffer;
encryptedBuffer.resize(static_cast<size_t>(publishingHandler->GetProtectedContentLength(inputText.size(), true)));

publishingHandler->EncryptBuffer(0,
                      &inputBuffer[0],
                      static_cast<int64_t>(inputBuffer.size()),
                      &encryptedBuffer[0],
                      static_cast<int64_t>(encryptedBuffer.size()),
                      true);

std::string encryptedText(encryptedBuffer.begin(), encryptedBuffer.end());
cout << "Encrypted Text :" + encryptedText;

//Show action plan
cout << endl << "Decrypting string: " << endl << endl;

//Generate publishing licence, so it can be used later to decrypt text.
auto serializedPublishingLicense = publishingHandler->GetSerializedPublishingLicense();

//Use same PL to decrypt the encryptedText.
auto cHandlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto cHandlerFuture = cHandlerPromise->get_future();
shared_ptr<ProtectionHandlerObserver> cHandlerObserver = std::make_shared<ProtectionHandlerObserver>();

//Create consumption settings using serialised publishing licence.
mip::ProtectionHandler::ConsumptionSettings consumptionSettings = mip::ProtectionHandler::ConsumptionSettings(serializedPublishingLicense);
engine->CreateProtectionHandlerForConsumptionAsync(consumptionSettings, cHandlerObserver, cHandlerPromise);

auto consumptionHandler = cHandlerFuture.get();

//Use consumption handler to decrypt the text.
std::vector<uint8_t> decryptedBuffer(static_cast<size_t>(encryptedText.size()));

int64_t decryptedSize = consumptionHandler->DecryptBuffer(
     0,
     &encryptedBuffer[0],
     static_cast<int64_t>(encryptedBuffer.size()),
     &decryptedBuffer[0],
     static_cast<int64_t>(decryptedBuffer.size()),
     true);

decryptedBuffer.resize(static_cast<size_t>(decryptedSize));

std::string decryptedText(decryptedBuffer.begin(), decryptedBuffer.end());

// Output decrypted content. Should match original input text.
cout << "Decrypted Text :" + decryptedText << endl;

  4. Vers la fin de main(), trouvez le bloc d'arrêt de l'application créé dans le premier démarrage rapide et ajoutez les lignes ci-dessous pour libérer les ressources du gestionnaire :

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Remplacez les valeurs d’espace réservé du code source que vous venez de coller comme suit, en utilisant des constantes de chaîne :

    Espace réservé Valeur
    <exemple de texte> Exemple de texte que vous souhaitez protéger, par exemple : "cipher text".
    <Template-Id> ID de modèle que vous souhaitez utiliser pour protéger le texte. Par exemple : "bb7ed207-046a-4caf-9826-647cff56b990"

Concevoir et tester l’application

Générez et testez votre application cliente.

  1. Utilisez Ctrl+Maj+B (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 modèles de protection », exécutez votre script PowerShell pour acquérir le jeton chaque fois, en utilisant les valeurs fournies pour $authority et $resourceUrl.

    *** Template List:
Name: Confidential \ All Employees : a74f5027-f3e3-4c55-abcd-74c2ee41b607
Name: Highly Confidential \ All Employees : bb7ed207-046a-4caf-9826-647cff56b990
Name: Confidential : 174bc02a-6e22-4cf2-9309-cb3d47142b05
Name: Contoso Employees Only : 667466bf-a01b-4b0a-8bbf-a79a3d96f720
Applying Template ID bb7ed207-046a-4caf-9826-647cff56b990 to:
<Sample-Text>
Encrypted Text :y¬╩$Ops7Γ╢╖¢t
Decrypting string:

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
Set $authority to: https://login.windows.net/common/oauth2/authorize
Set $resourceUrl to: https://aadrm.com
Sign in with user account: user1@tenant.onmicrosoft.com
Enter access token: <paste-access-token-here>
Press any key to continue . . .

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
Set $authority to: https://login.windows.net/94f69844-8d34-4794-bde4-3ac89ad2b664/oauth2/authorize
Set $resourceUrl to: https://aadrm.com
Sign in with user account: user1@tenant.onmicrosoft.com
Enter access token: <paste-access-token-here>
Press any key to continue . . .

Decrypted Text :<Sample-Text>
C:\MIP Sample Apps\ProtectionQS\Debug\ProtectionQS.exe (process 8252) exited with code 0.
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
Press any key to close this window . . .
  • Last updated on