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

Artikel
01/30/2024

In deze quickstart ziet u hoe u meer VAN de MIP-bestands-SDK's gebruikt. Met behulp van een van de vertrouwelijkheidslabels die u in de vorige quickstart hebt vermeld, gebruikt u een bestandshandler om het label op een bestand in te stellen/op te halen. De klasse Bestandshandler bevat verschillende bewerkingen voor het instellen/verkrijgen van labels of beveiliging voor ondersteunde bestandstypen.

Vereisten

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

Volledige quickstart: Maak eerst een lijst met vertrouwelijkheidslabels (C++) die een eenvoudige Visual Studio-oplossing bouwt om de vertrouwelijkheidslabels van een organisatie weer te geven. Deze quickstart 'Een vertrouwelijkheidslabel instellen en ophalen' bouwt voort op de vorige.
Optioneel: Controleer bestandshandlers in de MIP SDK-concepten .

Een waarnemersklasse implementeren om het bestandshandlerobject te bewaken

Net als bij de waarnemer die u hebt geïmplementeerd (voor het bestandsprofiel en de engine) in de quickstart voor toepassingsinitialisatie, implementeert u nu een waarnemersklasse voor een file-handlerobject.

Maak een eenvoudige implementatie voor een waarnemer van een bestandshandler door de klasse van de SDK uit te mip::FileHandler::Observer breiden. De waarnemer wordt geïnstantieerd en later gebruikt om bestandshandlerbewerkingen te bewaken.

Open de Visual Studio-oplossing waaraan u hebt gewerkt in het vorige artikel 'Quickstart: Vertrouwelijkheidslabels (C++)' vermelden.
Voeg een nieuwe klasse toe aan uw project, waarmee zowel de header/.h- als de implementation/.cpp-bestanden voor u worden gegenereerd:
- 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 de .h-bestandsvelden als de .cpp-bestandsvelden automatisch worden ingevuld op basis van de naam die u invoert.
  - Wanneer u klaar bent, klikt u op de knop OK .

Nadat u de .h- en CPP-bestanden voor de klasse hebt gegenereerd, worden beide bestanden geopend op tabbladen editorgroep. Werk nu elk bestand bij om uw nieuwe waarnemersklasse te implementeren:

Werk 'filehandler_observer.h' bij door de gegenereerde filehandler_observer klasse te selecteren/verwijderen. Verwijder de preprocessorrichtlijnen die door de vorige stap zijn gegenereerd (#pragma, #include) niet . 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 de preprocessorrichtlijnen die door de vorige stap zijn gegenereerd (#pragma, #include) niet . 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);
}

Gebruik eventueel F6 (Build Solution) om een testcompilatie/koppeling van uw oplossing uit te voeren om ervoor te zorgen dat deze correct wordt gebouwd voordat u doorgaat.

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

Voeg logica toe om een vertrouwelijkheidslabel in een bestand in te stellen en op te halen met behulp van het object File Engine.

Open met Solution Explorer het CPP-bestand 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.
Voeg de volgende #include en using richtlijnen toe, onder de bijbehorende bestaande instructies, boven aan het bestand:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Voeg aan het einde van de main() hoofdtekst, onder system("pause"); en boven return 0; (waar u was gebleven in de vorige quickstart), 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 " << 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");

Aan het einde van het zoeken naar het afsluitblok van main() de toepassing dat is gemaakt in de eerste quickstart, en verwijder de opmerkingen bij de handlerregel:

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

Vervang de tijdelijke aanduidingen in de broncode die u als volgt gebruikt met tekenreeksconstanten:

Tijdelijke aanduiding	Waarde
<input-file-path>	Het volledige pad naar een testinvoerbestand, bijvoorbeeld: `"c:\\Test\\Test.docx"`.
<inhouds-id>	Een door mensen leesbare id voor de inhoud. Bijvoorbeeld: voor een bestand kunt u pad\bestandsnaam overwegen: `"c:\Test\Test.docx"` voor een e-mailbericht kunt u het volgende overwegen: 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"`.
<output-file-path>	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.

Gebruik F6 (Build Solution) om uw clienttoepassing te bouwen. Als u geen buildfouten hebt, gebruikt u F5 (Foutopsporing starten) om uw toepassing uit te voeren.

Als uw project wordt gebouwd en uitgevoerd, vraagt de toepassing om een toegangstoken, telkens wanneer de SDK uw AcquireOAuth2Token() methode aanroept. Zoals u eerder in de quickstart 'Vertrouwelijkheidslabels vermelden' hebt gedaan, voert u uw PowerShell-script uit om het token elke keer te verkrijgen met behulp van 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 . . .

U kunt de toepassing van het label controleren door het uitvoerbestand te openen en de instellingen voor gegevensbeveiliging van het document visueel te controleren.

Notitie

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