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

Article
01/30/2024

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

Prérequis

Si ce n’est déjà fait, veillez à satisfaire les prérequis suivants avant de poursuivre :

Suivez d’abord le Démarrage rapide : Lister les modèles de protection (C++), qui créent une solution Visual Studio de démarrage, pour lister les modèles de protection disponibles pour un utilisateur authentifié. Ce démarrage rapide « Chiffrer/déchiffrer » est une build du précédent.
Facultatif : passez en revue les Gestionnaires de protection dans les concepts du SDK MIP.

Implémenter une classe d’observateur pour surveiller les objets de gestionnaire Protection

Comme pour l’observateur que vous avez implémenté (pour le profil et le moteur Protection) dans le démarrage rapide de l’initialisation de l’application, vous devez maintenant implémenter une classe d’observateur pour des objets de gestionnaire Protection.

Créez une implémentation de base pour un observateur de gestionnaire de profil Protection, en étendant la classe mip::ProtectionHandler::Observer du SDK. L’observateur est instancié et utilisé ultérieurement pour surveiller les opérations du gestionnaire Protection.

Ouvrez la solution Visual Studio sur laquelle vous avez travaillé dans l’article précédent « Démarrage rapide : Lister les modèles de protection (C++) ».
Ajoutez une nouvelle classe à votre projet, ce qui génère pour vous les fichiers header/.h et implementation/.cpp :
- Dans l’Explorateur de solutions, cliquez avec le bouton de droite sur le nœud du projet une nouvelle fois, puis sélectionnez Ajouter et Classe.
- Dans la boîte de dialogue Ajouter une classe :
  - Dans le champ Nom de la classe, entrez « handler_observer ». Notez que les deux champs Fichier .h et Fichier .cpp sont automatiquement renseignés en fonction du nom que vous entrez.
  - Lorsque vous avez terminé, cliquez sur le bouton OK.

Après la génération des fichiers .h et .cpp pour la classe, les deux fichiers sont ouverts sous les onglets du groupe d’éditeurs. Maintenant, mettez à jour chaque fichier pour implémenter votre nouvelle classe d’observateur :

Mettez à jour « handler_observer.h » en sélectionnant/supprimant la classe handler_observer générée. Ne supprimez pas les directives de préprocesseur générées à l’étape précédente (#pragma, #include). Ensuite, copiez/collez la source suivante dans le fichier, après 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 la classe handler_observer générée. Ne supprimez pas les directives de préprocesseur générées à l’étape précédente (#pragma, #include). Ensuite, copiez/collez la source suivante dans le fichier, après 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);
          };

Utilisez éventuellement CTRL+MAJ+B (Générer la solution) pour exécuter une compilation/liaison de test de votre solution afin de vous assurer qu’elle est correctement générée 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 Protection.

À l’aide de l’Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la méthode main().

Ajoutez les instructions #include et, à l’aide des directives ci-dessous, en haut du fichier, sous les directives existantes correspondantes :

  #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;

Vers la fin du corps Main() (là où vous vous êtes arrêté dans le précédent Démarrage rapide), 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;

Vers la fin de main(), recherchez le bloc d’arrêt d’application créé dans le premier démarrage rapide et ajoutez les lignes pour publier les ressources du gestionnaire :
```
 publishingHandler = nullptr;
 consumptionHandler = nullptr;
```

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

Paramètre substituable	Valeur
<sample-text>	Exemple de texte que vous souhaitez protéger, par exemple : `"cipher text"`.
<Template-Id>	ID de modèle que vous voulez 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.

Utilisez Ctrl+Maj+B (Créer une solution) pour créer votre application cliente. Si vous n’avez aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Si votre projet est généré et exécuté correctement, l’application demande un jeton d’accès chaque fois que le kit de développement logiciel (SDK) appelle votre méthode AcquireOAuth2Token(). Comme vous l’avez fait précédemment dans le démarrage rapide « Lister les modèles de protection », exécutez votre script PowerShell pour obtenir 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 . . .

Partager via

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

Prérequis

Implémenter une classe d’observateur pour surveiller les objets de gestionnaire Protection

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

Concevoir et tester l’application

Commentaires

Ressources supplémentaires