Schnellstart: Festlegen und Abrufen einer Vertraulichkeitsbezeichnung (C++)

  • Artikel

In diesem Schnellstart erfahren Sie, wie Sie weitere MIP File SDKs nutzen. Wenn Sie eine der Vertraulichkeitsbezeichnungen verwenden, die Sie im vorherigen Schnellstart aufgelistet haben, verwenden Sie einen Dateihandler zum Festlegen/Abrufen der Bezeichnung einer Datei. Die Dateihandlerklasse macht verschiedene Vorgänge für das Festlegen/Abrufen von Bezeichnungen oder für den Schutz von unterstützten Dateitypen verfügbar.

Voraussetzungen

Stellen Sie vor dem Fortfahren sicher, dass die folgenden Voraussetzungen erfüllt sind:

  • Schließen Sie zuerst den Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++) ab, in dem eine Visual Studio-Startprojektmappe zum Auflisten der Vertraulichkeitsbezeichnungen einer Organisation erstellt wird. Dieser Schnellstart „Festlegen und Abrufen von Vertraulichkeitsbezeichnungen“ baut auf dem vorherigen auf.
  • Lesen Sie optional die Konzepte zu Dateihandlern im MIP SDK.

Implementieren einer Observer-Klasse zum Überwachen des Dateihandlerobjekts

Ähnlich wie bei dem Observer, den Sie (für File-Profil und -Engine) im Schnellstart zur Anwendungsinitialisierung implementiert haben, implementieren Sie jetzt eine Observer-Klasse für ein Dateihandlerobjekt.

Erstellen Sie eine grundlegende Implementierung der Observer-Klasse für einen Dateihandler, indem Sie die mip::FileHandler::Observer-Klasse des SDK erweitern. Der Observer wird instanziiert und später zum Überwachen von Dateihandlervorgängen verwendet.

  1. Öffnen Sie die Visual Studio-Projektmappe, die Sie im vorherigen Artikel „Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++)“ bearbeitet haben.

  2. Fügen Sie Ihrem Projekt eine neue Klasse hinzu, durch die die Dateien „header/.h“ und „implementation/.cpp“ für Sie generiert werden:

    • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste erneut auf den Projektknoten, und wählen Sie Hinzufügen und dann Klasse aus.
    • Gehen Sie im Dialogfeld Klasse hinzufügen folgendermaßen vor:
      • Geben Sie im Feld Klassenname „filehandler_observer“ ein. Die Felder H-Datei und CPP-Datei werden anhand des eingegebenen Namens automatisch ausgefüllt.
      • Wenn Sie fertig sind, klicken Sie auf die Schaltfläche OK.

  3. Nach dem Generieren der H- und der CPP-Dateien für die Klasse werden beide Dateien auf Registerkarten in „Editor-Gruppe“ geöffnet. Aktualisieren Sie jetzt jede Datei, um Ihre neue Observer-Klasse zu implementieren:

    • Aktualisieren Sie „filehandler_observer.h“, indem Sie die generierte filehandler_observer-Klasse auswählen/löschen. Entfernen Sie nicht die im vorherigen Schritt generierten Präprozessoranweisungen (#pragma, #include). Kopieren Sie dann die folgende Quelle, und fügen Sie sie in der Datei nach den vorhandenen Präprozessoranweisungen ein:

      #include <memory>
#include "mip/file/file_engine.h"
#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
   FileHandlerObserver() { }
   // Observer implementation
   void OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) override;
   void OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
   void OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) override;
   void OnCommitFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;		
};

    • Aktualisieren Sie „filehandler_observer.cpp“, indem Sie die generierte filehandler_observer-Klassenimplementierung auswählen/löschen. Entfernen Sie nicht die im vorherigen Schritt generierten Präprozessoranweisungen (#pragma, #include). Kopieren Sie dann die folgende Quelle, und fügen Sie sie in der Datei nach den vorhandenen Präprozessoranweisungen ein:

      void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_exception(error);
}

void FileHandlerObserver::OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_value(committed);
}

void FileHandlerObserver::OnCommitFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_exception(error);
}

  4. Verwenden Sie optional F6 (Projektmappe erstellen), um eine Testkompilierung/-verknüpfung Ihrer Projektmappe auszuführen und vor dem Fortfahren sicherzustellen, dass sie erfolgreich erstellt wird.

Hinzufügen von Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung

Fügen Sie Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung für eine Datei hinzu, indem Sie das File-Engine-Objekt verwenden.

  1. Öffnen Sie im Projektmappen-Explorer die CPP-Datei im Projekt, die die Implementierung der main()-Methode enthält. Standardmäßig weist sie denselben Namen wie das Projekt auf, in dem sie enthalten ist. Diesen Namen haben Sie bei der Projekterstellung angegeben.

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

    #include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;

  3. Fügen Sie am Ende des Methodenkörpers von main(), zwischen system("pause"); und return 0; (an der Stelle, an der Sie im vorherigen Schnellstart aufgehört haben) den folgenden Code ein:

    // Set up async FileHandler for input file operations
string inputFilePath = "<input-file-path>";
string actualFilePath = "<content-identifier>";
std::shared_ptr<FileHandler> handler;
try
{
     auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
     auto handlerFuture = handlerPromise->get_future();
     engine->CreateFileHandlerAsync(
          inputFilePath,
          actualFilePath,                       
          true, 
          std::make_shared<FileHandlerObserver>(), 
          handlerPromise);
     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid input file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Set a label on input file
try
{
     string labelId = "<label-id>";
     cout << "\nApplying Label ID " << labelId << " to " << filePathIn << endl;
     mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
     handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, new ProtectionSettings());
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1; 
}

// Commit changes, save as a different/output file
string filePathOut = "<output-file-path>";
try
{
 	cout << "Committing changes" << endl;
     auto commitPromise = std::make_shared<std::promise<bool>>();
     auto commitFuture = commitPromise->get_future();
     handler->CommitAsync(filePathOut, commitPromise);
 	if (commitFuture.get()) {
 		cout << "\nLabel committed to file: " << filePathOut << endl;
 	}
 	else {
 		cout << "Failed to label: " + filePathOut << endl;
 		return 1;
 	}
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid commit file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

// Set up async FileHandler for output file operations
actualFilePath = "<content-identifier>";
try
{
     auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
     auto handlerFuture = handlerPromise->get_future();
     engine->CreateFileHandlerAsync(
          filePathOut,
          actualFilePath,
          true,
          std::make_shared<FileHandlerObserver>(),
          handlerPromise);

     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid output file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Get the label from output file
try
{
     cout << "\nGetting the label committed to file: " << filePathOut << endl;
     auto label = handler->GetLabel();
     cout << "Name: " + label->GetLabel()->GetName() << endl;
     cout << "Id: " + label->GetLabel()->GetId() << endl;
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

  4. Suchen Sie am Ende von main() den Block zum Herunterfahren der Anwendung, den Sie im ersten Schnellstart erstellt haben, und heben Sie die Auskommentierung der Zeile für den Handler auf:

    // Application shutdown. Null out profile and engine, call ReleaseAllResources();
// Application may crash at shutdown if resources aren't properly released.
profile = nullptr;
engine = nullptr;
handler = nullptr;
mipContext = nullptr;

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

    Platzhalter Wert
    <input-file-path> Der vollständige Pfad zu einer Testeingabedatei, z. B. "c:\\Test\\Test.docx"
    <content-identifier> Ein lesbarer Inhaltsbezeichner. Beispiel:
    • Verwenden Sie für eine Datei das Format Pfad\Dateiname: "c:\Test\Test.docx".
    • Verwenden Sie für eine E-Mail das Format Betreff:Absender: "RE: Audit design:user1@contoso.com".
    <label-id> Eine Vertraulichkeitsbezeichnungs-ID, die aus der Konsolenausgabe im vorherigen Schnellstart kopiert wird, z. B. "f42a3342-8706-4288-bd31-ebb85995028z"
    <output-file-path> Der vollständige Pfad zur Ausgabedatei, die eine bezeichnete Kopie der Eingabedatei ist, z. B. "c:\\Test\\Test_labeled.docx"

Erstellen und Testen der Anwendung

Erstellen und testen Sie die Clientanwendung.

  1. Verwenden Sie F6 (Projektmappe erstellen) zum Erstellen der Clientanwendung. Wenn keine Buildfehler auftreten, verwenden Sie F5 (Debuggen starten), um die Anwendung auszuführen.

  2. Wenn das Projekt erfolgreich erstellt und ausgeführt wird, fragt die Anwendung jedes Mal nach einem Zugriffstoken, wenn das SDK Ihre AcquireOAuth2Token()-Methode aufruft. Führen Sie das PowerShell-Skript wie zuvor im Schnellstart „Auflisten von Vertraulichkeitsbezeichnungen“ aus, um jedes Mal das Token anhand der angegebenen Werte für $authority und $resourceUrl abzurufen.

    Run the PowerShell script to generate an access token using the following values, then copy/paste it below:

Sensitivity labels for your organization:
Non-Business : 87ba5c36-17cf-14793-bbc2-bd5b3a9f95cz
Public : 83867195-f2b8-2ac2-b0b6-6bb73cb33afz
General : f42a3342-8706-4288-bd31-ebb85995028z
Confidential : 074e457c-5848-4542-9a6f-34a182080e7z
Highly Confidential : f55c2dea-db0f-47cd-8520-a52e1590fb6z
Press any key to continue . . .

Applying Label ID 074e457c-5848-4542-9a6f-34a182080e7z to c:\Test\Test.docx
Committing changes

Label committed to file: c:\Test\Test_labeled.docx
Press any key to continue . . .

Getting the label committed to file: c:\Test\Test_labeled.docx
Name: Confidential
Id: 074e457c-5848-4542-9a6f-34a182080e7z
Press any key to continue . . .

Sie können die Anwendung der Bezeichnung überprüfen, indem Sie die Ausgabedatei öffnen und die Information Protection-Einstellungen des Dokuments visuell überprüfen.

Notiz

Wenn Sie ein Office-Dokument mit einer Bezeichnung versehen, sich aber nicht mit einem Konto des Azure Active Directory-Mandanten angemeldet haben, von dem das Zugriffstoken abgerufen wurde, werden Sie (sofern Vertraulichkeitsbezeichnungen konfiguriert sind) möglicherweise aufgefordert, sich anzumelden, bevor Sie das bezeichnete Dokument öffnen können.