Quickstart: Een vertrouwelijkheidslabel instellen en ophalen (C++)

In deze quickstart ziet u hoe u meer mogelijkheden van de MIP File SDK's kunt gebruiken. Door een van de vertrouwelijkheidslabels te gebruiken die u in de vorige quickstart hebt vermeld, gebruikt u een bestandshandler om het label op een bestand in te stellen en op te halen. De bestandshandlerklasse biedt verschillende bewerkingen voor het instellen en verkrijgen van labels, of beveiliging, voor ondersteunde bestandstypen.

Vereiste voorwaarden

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

  • Quickstart: Vertrouwelijkheidslabels (C++) vermelden. Voltooi deze quickstart eerst. Er wordt een starter-Visual Studio-oplossing gebouwd waarin de vertrouwelijkheidslabels van een organisatie worden vermeld. Deze quickstart 'Een vertrouwelijkheidslabel instellen en ophalen' bouwt voort op de vorige quickstart.
  • Optioneel: Controleer de concepten van bestandshandlers in de MIP SDK.

Een waarnemersklasse implementeren om het bestandshandlerobject te bewaken

Net als bij de observer die u hebt geïmplementeerd voor het bestandsprofiel en de engine in de quickstart voor het initialiseren van de toepassing, implementeert u nu een observerklasse voor een bestandverwerkingsobject.

Maak een eenvoudige implementatie van een observer voor een bestandshandler door de klasse mip::FileHandler::Observer van de SDK uit te breiden. De toepassing instantieert de waarnemer en gebruikt deze later om bestandshandlerbewerkingen te bewaken.

  1. Open de Visual Studio-oplossing waaraan u hebt gewerkt in het vorige artikel 'Quickstart: Vertrouwelijkheidslabels (C++)' vermelden.

  2. Voeg een nieuwe klasse toe aan uw project. Visual Studio genereert zowel de header/.h- als de implementation/.cpp-bestanden voor u:

    • 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 'filehandler_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, selecteert u OK.

  3. Nadat Visual Studio de .h- en .cpp-bestanden voor de klasse heeft gegenereerd, worden beide bestanden geopend op editortabbladen. Werk elk bestand bij om uw nieuwe waarnemersklasse te implementeren:

    • Werk 'filehandler_observer.h' bij door de gegenereerde filehandler_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/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;		
};

    • Werk filehandler_observer.cpp bij door de gegenereerde filehandler_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:

      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. U kunt eventueel F6 (Build Solution) gebruiken om een testcompilatie/koppeling van uw oplossing uit te voeren en te bevestigen dat deze correct wordt gebouwd voordat u doorgaat.

Logica toevoegen om een vertrouwelijkheidslabel in te stellen en op te halen

Gebruik het object File Engine om logica toe te voegen waarmee een vertrouwelijkheidslabel voor een bestand wordt ingesteld en opgehaald.

  1. Open in Solution Explorer het bestand .cpp in uw project dat de implementatie van de main() methode bevat. Deze wordt standaard ingesteld op dezelfde naam als het project dat het bevat, die u hebt opgegeven tijdens het maken van het project.

  2. Voeg de volgende #include en using instructies toe na de bijbehorende bestaande instructies bovenaan het bestand:

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

using mip::FileHandler;

  3. Voeg tegen het einde van de main() body, na system("pause"); en vóór return 0;, waar u in de vorige quickstart was gebleven, de volgende code in:

    // 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 " << inputFilePath << endl;
     mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
     handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, mip::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. Zoek aan het einde van main() het blok voor het afsluiten van de toepassing dat in de eerste quickstart is gemaakt en haal de commentaarmarkering bij de handlerregel weg:

    // 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. Vervang de tijdelijke aanduidingen in de broncode als volgt door tekenreeksconstanten te gebruiken:

    Tijdelijke aanduiding Waarde
    <input-file-path> Het volledige pad naar een testinvoerbestand, bijvoorbeeld: "c:\\Test\\Test.docx".
    <inhoudsidentificatie> Een door mensen leesbare id voor de inhoud. Bijvoorbeeld:
    • Gebruik pad\bestandsnaam voor een bestand: "c:\Test\Test.docx"
    • Gebruik voor een e-mailbericht onderwerp: afzender: "RE: Audit design:user1@contoso.com"
    <label-id> Een vertrouwelijkheidslabel-id, gekopieerd uit de console-uitvoer in de vorige quickstart, bijvoorbeeld: "f42a3342-8706-4288-bd31-ebb85995028z".
    <uitvoer-bestand-pad> Het volledige pad naar het uitvoerbestand, een gelabelde kopie van het invoerbestand, bijvoorbeeld: "c:\\Test\\Test_labeled.docx"

De toepassing bouwen en testen

Bouw en test uw clienttoepassing.

  1. Gebruik F6 (Build Solution) om uw clienttoepassing te bouwen. Als de build geen fouten bevat, gebruikt u F5 (Foutopsporing starten) om uw toepassing uit te voeren.

  2. Als uw project met succes wordt gebouwd en uitgevoerd, vraagt de toepassing om een toegangstoken telkens wanneer de SDK uw AcquireOAuth2Token() methode aanroept. Zoals u eerder hebt gedaan in de quickstart 'Gevoeligheidslabels weergeven', voert u uw PowerShell-script uit om telkens het token op te halen met de waarden die zijn opgegeven voor $authority en $resourceUrl.

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

Controleer de labeltoepassing door het uitvoerbestand te openen en de instellingen voor gegevensbeveiliging van het document visueel te controleren.

Opmerking

Als u een Office-document labelt, maar niet bent aangemeld met een account van de Microsoft Entra tenant die het toegangstoken heeft uitgegeven (en vertrouwelijkheidslabels zijn geconfigureerd), wordt u mogelijk gevraagd u aan te melden voordat u het gelabelde document kunt openen.

Volgende stappen 

  • Last updated on