Quickstart: Tekst versleutelen/ontsleutelen met MIP SDK (C++)

In deze quickstart ziet u hoe u meer van de MIP Protection 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/verwijderen van beveiliging.

Vereiste voorwaarden

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

Voltooi eerst Quickstart: Lijst beveiligingssjablonen op (C++), waarmee een starter Visual Studio-oplossing wordt gebouwd, om de beveiligingssjablonen op te sommen die beschikbaar zijn voor een geverifieerde gebruiker. Deze snelstartgids 'Tekst versleutelen/ontsleutelen' is gebaseerd op de vorige.
Optioneel: Overweeg de concepten van beveiligingshandlers in de MIP SDK.

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 toepassingsinitialisatie, implementeert u nu een waarnemersklasse voor beveiligingshandlerobjecten.

Maak een eenvoudige implementatie voor een beveiligingshandlerwaarnemer door de klasse van de SDK uit te breiden. De waarnemer wordt geïnstantieerd en later gebruikt om de operaties van de beveiligingsverantwoordelijke te monitoren.

Open de Visual Studio-oplossing waaraan u hebt gewerkt in het vorige artikel 'Quickstart: Lijstbeveiligingssjablonen (C++)'.
Voeg een nieuwe klasse toe aan uw project, waarmee zowel de header/.h- als de implementation/.cpp-bestanden 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 Klassenaam 'handler_observer' in. U ziet dat zowel het .h-bestandals de .cpp bestandsvelden automatisch worden ingevuld op basis van de naam die u invoert.
  - Wanneer u klaar bent, klikt u op de knop OK .

Nadat u de .h- en .cpp-bestanden voor de klasse hebt gegenereerd, worden beide bestanden geopend op de tabbladen 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/verwijderen. Verwijder niet de preprocessorrichtlijnen die zijn gegenereerd door de vorige stap (#pragma, #include). Kopieer/plak vervolgens 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/verwijderen. Verwijder niet de preprocessorrichtlijnen die zijn gegenereerd door de vorige stap (#pragma, #include). Kopieer/plak vervolgens 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);
          };

Gebruik optioneel Ctrl+Shift+B (Build Solution) om een testcompilatie/koppeling van uw oplossing uit te voeren, om ervoor te zorgen dat 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 te ontsleutelen met behulp van het object Protection Engine.

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

Voeg de volgende #include- en using-directives toe, onder de bijbehorende bestaande directives, aan de bovenkant van het bestand:

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

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>();
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;

Aan het einde van het afsluitblok van de toepassing in main(), die in de eerste quickstart is gemaakt, voegt u de onderstaande regels toe om handler-resources vrij te geven:
```
 publishingHandler = nullptr;
 consumptionHandler = nullptr;
```

Vervang de tijdelijke aanduidingen in de broncode met tekenreeksconstanten als volgt:

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.

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.

Als uw project wordt gebouwd en uitgevoerd, vraagt de toepassing om een toegangstoken, telkens wanneer de SDK uw AcquireOAuth2Token() methode aanroept. Zoals u eerder in de quickstart 'Lijstbeveiligingssjablonen' hebt gedaan, 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.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 . . .

Feedback

Is deze pagina nuttig?

Last updated on 2025-04-21