Quickstart: Tekst versleutelen en ontsleutelen met behulp van MIP SDK (C++)

In deze quickstart ziet u hoe u meer mip-beveiligings-SDK's gebruikt. Met behulp van een van de beveiligingssjablonen die u in de vorige quickstart hebt vermeld, gebruikt u een beveiligingshandler om ad-hoctekst te versleutelen. De klasse Protection handler biedt verschillende bewerkingen voor het toepassen en verwijderen van beveiliging.

Vereiste voorwaarden

Als u dat nog niet hebt gedaan, moet u de volgende vereisten voltooien voordat u doorgaat:

Een waarnemersklasse implementeren om het object Protection-handler te bewaken

Net als de waarnemer die u hebt geïmplementeerd voor het beveiligingsprofiel en de engine in de quickstart voor initialisatie van toepassingen, implementeert u nu een waarnemersklasse voor beveiligingshandlerobjecten.

Maak een basisimplementatie van een observer voor een Protection-handler door de mip::ProtectionHandler::Observer-klasse van de SDK uit te breiden. De SDK instantieert de observer en gebruikt deze later om bewerkingen van de Protection-handler te monitoren.

  1. Open de Visual Studio-oplossing waaraan u hebt gewerkt in het vorige artikel 'Quickstart: Lijstbeveiligingssjablonen (C++)'.

  2. Voeg een nieuwe klasse toe aan uw project, waarmee zowel de headerbestanden (.h) als de implementatiebestanden (.cpp) voor u worden gegenereerd:

    • Klik in Solution Explorer opnieuw met de rechtermuisknop op het projectknooppunt, selecteer Toevoegen en selecteer vervolgens Klasse.
    • In het dialoogvenster Klasse toevoegen :
      • Voer in het veld Klassenaamhandler_observer in. U ziet dat Visual Studio automatisch zowel het .h-bestandals .cpp bestandsvelden vult op basis van de naam die u invoert.
      • Wanneer u klaar bent, selecteert u OK.

  3. Nadat u de .h- en .cpp-bestanden voor de klasse hebt gegenereerd, opent Visual Studio beide bestanden op tabbladen van de editorgroep. Werk nu elk bestand bij om uw nieuwe waarnemersklasse te implementeren:

    • Werk handler_observer.h bij door de gegenereerde handler_observer klasse te selecteren en te verwijderen. Verwijder de preprocessorrichtlijnen die door de vorige stap zijn gegenereerd (#pragma, #include) niet. Kopieer en plak de volgende bron in het bestand na eventuele bestaande preprocessorrichtlijnen:

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

    • Werk handler_observer.cpp bij door de gegenereerde handler_observer klasse-implementatie te selecteren en te verwijderen. Verwijder de preprocessorrichtlijnen die door de vorige stap zijn gegenereerd (#pragma, #include) niet. Kopieer en plak de volgende bron in het bestand na eventuele bestaande preprocessorrichtlijnen:

      #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. U kunt eventueel Ctrl+Shift+B (build solution) gebruiken om een testcompilatie en koppeling van uw oplossing uit te voeren om te controleren of deze correct wordt gebouwd voordat u doorgaat.

Logica toevoegen om ad-hoctekst te versleutelen en ontsleutelen

Voeg logica toe om ad-hoctekst te versleutelen en ontsleutelen met behulp van het object Protection Engine.

  1. Open met Solution Explorer het .cpp-bestand in uw project dat de implementatie van de main() methode bevat.

  2. Voeg de volgende #include- en using-instructies toe onder de overeenkomstige bestaande instructies bovenaan het bestand:

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

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

  3. Voeg aan het einde van de Main() hoofdtekst, waar u was gebleven in de vorige quickstart, de volgende code in:

    //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>();
auto pHandlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto pHandlerFuture = pHandlerPromise->get_future();
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 license, 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 serialized publishing license.
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. Aan het einde van main() vindt u het blok voor het afsluiten van de toepassing dat in de eerste quickstart is gemaakt, en voegt u de volgende regels toe om resources van de handler vrij te geven:

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Vervang de tijdelijke aanduidingen in de broncode door de volgende tekenreeksconstanten te gebruiken:

    Plaatsvervanger Waarde
    <voorbeeldtekst> Voorbeeldtekst die u wilt beveiligen, bijvoorbeeld: "cipher text".
    <Sjabloon-id> Sjabloon-id die u wilt gebruiken om de tekst te beveiligen. Bijvoorbeeld: "bb7ed207-046a-4caf-9826-647cff56b990"

De toepassing bouwen en testen

Bouw en test uw cliëntapplicatie.

  1. Gebruik Ctrl+Shift+B (build solution) om uw clienttoepassing te bouwen. Als u geen buildfouten hebt, gebruikt u F5 (Foutopsporing starten) om uw toepassing uit te voeren.

  2. Als uw project met succes wordt gebouwd en uitgevoerd, vraagt de toepassing om een toegangstoken telkens wanneer de SDK uw AcquireOAuth2Token() methode aanroept. Zoals u eerder hebt gedaan in de quickstart 'Lijstbeveiligingssjablonen', voert u uw PowerShell-script uit om het token elke keer te verkrijgen met behulp van de waarden die zijn opgegeven voor $authority en $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.microsoftonline.com/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.microsoftonline.com/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 . . .

Volgende stappen 

  • Last updated on