Snabbstart: Kryptera och dekryptera text med hjälp av MIP SDK (C++)

Den här snabbstarten visar hur du använder fler MIP Protection SDK:er. Genom att använda en av de skyddsmallar som du angav i föregående snabbstart använder du en skyddshanterare för att kryptera ad hoc-text. Klassen Skyddshanterare exponerar olika åtgärder för att tillämpa och ta bort skydd.

Förutsättningar

Om du inte redan har gjort det måste du slutföra följande krav innan du fortsätter:

Slutför snabbstart: Lista skyddsmallar (C++) först, som skapar en startlösning Visual Studio för att lista de skyddsmallar som är tillgängliga för en autentiserad användare. Snabbstarten "Kryptera och dekryptera text" bygger på den föregående.
Alternativt: Granska koncepten för skyddshanterare i MIP SDK.

Implementera en observatörsklass för att övervaka skyddshanterarobjektet

På samma sätt som den övervakare som du implementerade för skyddsprofilen och motorn i snabbstarten för programinitiering implementerar du nu en observatörsklass för skyddshanterarobjekt.

Skapa en grundläggande implementering för en skyddshanterarobservatör genom att utöka SDK:ts mip::ProtectionHandler::Observer klass. SDK:n instansierar och använder observatören senare för att övervaka skyddshanteraråtgärder.

Öppna den Visual Studio lösning som du arbetade med i föregående artikel "Snabbstart: Lista skyddsmallar (C++)."
Lägg till en ny klass i projektet, som genererar både huvudfilerna (.h) och implementeringen (.cpp) åt dig:
- I Prieskumník riešení högerklickar du på projektnoden igen, väljer Lägg till och väljer sedan Klass.
- På dialogrutan Lägg till klass:
  - I fältet Klassnamn anger du handler_observer. Observera att Visual Studio automatiskt fyller i både H-filen och .cpp filfälten baserat på det namn du anger.
  - När du är klar väljer du OK.

När du har genererat .h- och .cpp-filerna för klassen Visual Studio öppnar båda filerna på flikarna Redigerargrupp. Uppdatera nu varje fil för att implementera din nya observatörsklass:

Uppdatera handler_observer.h genom att välja och ta bort den genererade handler_observer klassen. Ta inte bort de förprocessordirektiv som föregående steg genererade (#pragma, #include). Kopiera och klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Uppdatera handler_observer.cpp genom att välja och ta bort den genererade handler_observer klassimplementeringen. Ta inte bort de förprocessordirektiv som föregående steg genererade (#pragma, #include). Kopiera och klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Du kan även använda Ctrl+Shift+B (Skapa lösning) för att köra en testkompilering och länkning av lösningen och kontrollera att den kan skapas utan fel innan du fortsätter.

Lägga till logik för att kryptera och dekryptera ad hoc-text

Lägg till logik för att kryptera och dekryptera ad hoc-text med hjälp av objektet Skyddsmotor.

Använd Prieskumník riešení och öppna filen .cpp i projektet som innehåller implementeringen av main() metoden.

Lägg till följande #include- och using-direktiv nedanför de motsvarande befintliga direktiven överst i filen:

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

Mot slutet av brödtexten Main() , där du slutade i föregående snabbstart, infogar du följande kod:

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

I slutet av main()hittar du det block för programavstängning som den första snabbstarten skapade och lägger till följande rader i versionshanterarresurser:
```
 publishingHandler = nullptr;
 consumptionHandler = nullptr;
```

Ersätt platshållarvärdena i källkoden med hjälp av följande strängkonstanter:

Placeholder	Värde
<exempel-text>	Exempeltext som du vill skydda, till exempel: `"cipher text"`.
<Mall-ID>	Mall-ID som du vill använda för att skydda texten. Till exempel: `"bb7ed207-046a-4caf-9826-647cff56b990"`

Skapa och testa programmet

Skapa och testa klientprogrammet.

Använd Ctrl+Skift+B (bygglösning) för att skapa klientprogrammet. Om du inte har byggfel använder du F5 (Starta felsökning) för att köra programmet.

Om projektet byggs och körs utan problem uppmanar applikationen dig att ange en åtkomsttoken varje gång SDK:t anropar din AcquireOAuth2Token()-metod. Precis som du gjorde tidigare i snabbstarten "Listskyddsmallar" kör du PowerShell-skriptet för att hämta token varje gång med hjälp av värdena för $authority och $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 . . .

Nästa steg

Utforska MIP Protection SDK C++-exemplet på GitHub.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-09-21