Freigeben über

Schnellstart: Verschlüsseln/Entschlüsseln von Text mit 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 aufgeführt haben, verwenden Sie einen Schutzhandler zum Verschlüsseln von Ad-hoc-Text. Die Protection-Handlerklasse macht verschiedene Vorgänge zum Anwenden/Entfernen des Schutzes verfügbar.

Voraussetzungen

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

  • Vervollständige zuerst Quickstart: Listenschutzvorlagen (C++), wodurch eine Starterlösung in Visual Studio erstellt wird, um die verfügbaren Schutzvorlagen eines authentifizierten Benutzers aufzulisten. Diese Schnellstartanleitung "Text verschlüsseln/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 Beobachter, den Sie (für das Schutzprofil und die Engine) in der Schnellstartanleitung zur Anwendungsinitialisierung implementiert haben, implementieren Sie nun eine Beobachterklasse für Protection Handler Objects.

Erstellen Sie eine grundlegende Implementierung für einen Protection-Handlerbeobachter, indem Sie die SDK-Klasse mip::ProtectionHandler::Observer erweitern. Der Beobachter wird instanziiert und später verwendet, um die Operationen des Schutzhandlers 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 Header/.h- als auch die Implementierungs-/.cpp dateien für Sie generiert:

    • Klicken Sie im 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 " "handler_observer" ein. Beachten Sie, dass sowohl die H-Datei als auch .cpp Dateifelder basierend auf dem eingegebenen Namen automatisch ausgefüllt werden.
      • Klicken Sie abschließend auf die Schaltfläche "OK ".

  3. Nach dem Generieren der .h- und .cpp-Dateien für die Klasse werden beide Dateien in Editor-Gruppe-Tabs geöffnet. 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/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle 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 handler_observer Klassenimplementierung auswählen/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle 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/Verknüpfung Ihrer Lösung auszuführen, um sicherzustellen, dass sie erfolgreich erstellt wird, 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 am Anfang der Datei, unter den entsprechenden vorhandenen Direktiven, die folgenden #include- und using-Direktiven hinzu:

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

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

  4. Suchen Sie am Ende von main() den Block zum Herunterfahren der Anwendung, den Sie im ersten Schnellstart erstellt haben, und fügen Sie die folgenden Zeilen hinzu, um Handlerressourcen freizugeben:

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Ersetzen Sie die Platzhalterwerte im Quellcode folgendermaßen durch Zeichenfolgenkonstanten:

    Platzhalter Wert
    <Beispieltext> Beispieltext, den Sie schützen möchten, z. B.: "cipher text".
    <Template-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. Drücken 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 zu erwerben, indem Sie die für $authority und $resourceUrl angegebenen Werte verwenden.

    *** 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 . . .