Schnellstart: Verschlüsseln und Entschlüsseln von Text mithilfe des MIP SDK (C++)

In dieser Schnellstartanleitung erfahren Sie, wie Sie mehr der MIP-Schutz-SDKs verwenden. Mithilfe einer der schutzvorlagen, die Sie in der vorherigen Schnellstartanleitung aufgelistet haben, verwenden Sie einen Schutzhandler, um Ad-hoc-Text zu verschlüsseln. Die Protection-Handlerklasse macht verschiedene Vorgänge zum Anwenden und Entfernen des Schutzes verfügbar.

Voraussetzungen

Falls noch nicht geschehen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen, bevor Sie fortfahren:

  • Schließen Sie zunächst Schnellstart: Schutzvorlagen auflisten (C++) ab. Dadurch wird eine Visual-Studio-Startlösung erstellt, mit der die für einen authentifizierten Benutzer verfügbaren Schutzvorlagen aufgelistet werden. Diese Schnellstartanleitung "Text verschlüsseln und entschlüsseln" baut auf dem vorherigen auf.
  • Optional: Sehen Sie sich die Konzepte zu Schutzhandlern im MIP SDK an.

Implementieren einer Beobachterklasse zum Überwachen des Protection-Handlerobjekts

Ähnlich wie den Observer, den Sie für das Protection-Profil und die Engine in der Schnellstartanleitung zur Anwendungsinitialisierung implementiert haben, implementieren Sie nun eine Observer-Klasse für Protection-Handlerobjekte.

Erstellen Sie eine grundlegende Implementierung für einen Protection-Handlerbeobachter, indem Sie die SDK-Klasse mip::ProtectionHandler::Observer erweitern. Das SDK instanziiert den Observer und verwendet ihn später, um Vorgänge des Protection-Handlers zu überwachen.

  1. Öffnen Sie die Visual Studio-Lösung, die Sie im vorherigen Artikel "Schnellstart: Listenschutzvorlagen (C++)" bearbeitet haben.

  2. Fügen Sie Ihrem Projekt eine neue Klasse hinzu, die sowohl die Headerdateien (H) als auch implementierungsdateien (.cpp) für Sie generiert:

    • Klicken Sie in Projektmappen-Explorer erneut mit der rechten Maustaste auf den Projektknoten, wählen Sie "Hinzufügen" und dann "Klasse" aus.
    • Im Dialogfeld "Klasse hinzufügen ":
      • Geben Sie im Feld "Klassenname " die Zeichenfolge handler_observerein. Beachten Sie, dass Visual Studio sowohl die H-Datei als auch .cpp Dateifelder basierend auf dem eingegebenen Namen automatisch auffüllt.
      • Wenn Sie fertig sind, wählen Sie OK aus.

  3. Nach dem Generieren der .h- und .cpp-Dateien für die Klasse öffnet Visual Studio beide Dateien in den Editorgruppentabs. Aktualisieren Sie nun jede Datei, um Ihre neue Beobachterklasse zu implementieren:

    • Aktualisieren Sie handler_observer.h , indem Sie die generierte handler_observer Klasse auswählen und löschen. Entfernen Sie nicht die Präprozessordirektiven, die der vorherige Schritt generiert hat (#pragma, #include). Kopieren Sie dann die folgende Quelle, und fügen Sie sie nach vorhandenen Präprozessordirektiven in die Datei ein:

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

    • Aktualisieren Sie handler_observer.cpp, indem Sie die generierte Implementierung der Klasse handler_observer auswählen und löschen. Entfernen Sie nicht die Präprozessordirektiven, die der vorherige Schritt generiert hat (#pragma, #include). Kopieren Sie dann die folgende Quelle, und fügen Sie sie nach vorhandenen Präprozessordirektiven in die Datei ein:

      #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. Verwenden Sie optional STRG+UMSCHALT+B (Projektmappe erstellen), um eine Testkompilierung und einen Link Ihrer Lösung auszuführen, um sicherzustellen, dass sie erfolgreich erstellt wurde, bevor Sie fortfahren.

Hinzufügen von Logik zum Verschlüsseln und Entschlüsseln von Ad-hoc-Text

Fügen Sie Mithilfe des Protection-Modulobjekts Logik zum Verschlüsseln und Entschlüsseln von Ad-hoc-Text hinzu.

  1. Öffnen Sie im Projektmappen-Explorer die datei .cpp in Ihrem Projekt, die die Implementierung der main() Methode enthält.

  2. Fügen Sie die folgenden #include- und using-Direktiven unter den entsprechenden vorhandenen Direktiven am Anfang der Datei hinzu:

      #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. Fügen Sie am Ende des Main() Textkörpers, auf dem Sie in der vorherigen Schnellstartanleitung aufgehört haben, den folgenden Code ein:

    //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. Suchen Sie am Ende von main() den Block zum Herunterfahren der Anwendung, den Sie in der ersten Schnellstartanleitung erstellt haben, und fügen Sie die folgenden Zeilen hinzu, um Handlerressourcen freizugeben:

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Ersetzen Sie die Platzhalterwerte im Quellcode mithilfe der folgenden Zeichenfolgenkonstanten:

    Platzhalter Wert
    <Beispieltext> Beispieltext, den Sie schützen möchten, z. B.: "cipher text".
    <Vorlagen-ID> Vorlagen-ID, die Sie zum Schutz des Texts verwenden möchten. Beispiel: "bb7ed207-046a-4caf-9826-647cff56b990"

Erstellen und Testen der Anwendung

Erstellen und testen Sie Ihre Clientanwendung.

  1. Verwenden Sie STRG+UMSCHALT+B (Projektmappe erstellen), um Ihre Clientanwendung zu erstellen. Wenn keine Buildfehler auftreten, verwenden Sie F5 (Debuggen starten), um Ihre Anwendung auszuführen.

  2. Wenn Ihr Projekt erfolgreich erstellt und ausgeführt wird, fordert die Anwendung jedes Mal, wenn das SDK Ihre AcquireOAuth2Token() Methode aufruft, ein Zugriffstoken ein. Führen Sie wie zuvor in der Schnellstartanleitung "Listenschutzvorlagen" Ihr PowerShell-Skript aus, um das Token jedes Mal mithilfe der für $authority und $resourceUrl bereitgestellten Werte abzurufen.

    *** 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ächste Schritte

  • Last updated on