Szybki start: ustawianie i uzyskiwanie etykiety poufności (C++)

Artykuł
01/30/2024

W tym przewodniku Szybki start pokazano, jak używać większej liczby zestawów SDK plików MIP. Korzystając z jednej z etykiet poufności wymienionych w poprzednim przewodniku Szybki start, program obsługi plików służy do ustawiania/pobierania etykiety w pliku. Klasa obsługi plików uwidacznia różne operacje ustawiania/pobierania etykiet lub ochrony dla obsługiwanych typów plików.

Wymagania wstępne

Jeśli jeszcze tego nie zrobiono, przed kontynuowaniem upewnij się, że zostały spełnione następujące wymagania wstępne:

Ukończ szybki start: najpierw wyświetl listę etykiet poufności (C++), które tworzy początkowe rozwiązanie programu Visual Studio, aby wyświetlić listę etykiet poufności organizacji. Ten przewodnik Szybki start "Ustawianie i uzyskiwanie etykiety poufności" jest oparty na poprzednim przewodniku Szybki start.
Opcjonalnie: Zapoznaj się z procedurami obsługi plików w pojęciach dotyczących zestawu MIP SDK .

Implementowanie klasy obserwatora w celu monitorowania obiektu programu obsługi plików

Podobnie jak w przypadku zaimplementowanego obserwatora (dla profilu pliku i aparatu) w przewodniku Szybki start inicjowania aplikacji, teraz implementujesz klasę obserwatora dla obiektu programu obsługi plików.

Utwórz podstawową implementację obserwatora programu obsługi plików, rozszerzając klasę zestawu SDK mip::FileHandler::Observer . Obserwator jest tworzone i używane później do monitorowania operacji obsługi plików.

Otwórz rozwiązanie programu Visual Studio, nad którym pracowaliśmy w poprzednim artykule "Szybki start: wyświetlanie listy etykiet poufności (C++)".
Dodaj nową klasę do projektu, która generuje pliki header/.h i implementation/.cpp:
- W Eksplorator rozwiązań ponownie kliknij prawym przyciskiem myszy węzeł projektu, wybierz polecenie Dodaj, a następnie wybierz pozycję Klasa.
- W oknie dialogowym Dodawanie klasy:
  - W polu Nazwa klasy wprowadź "filehandler_observer". Zwróć uwagę, że pola pliku .h i pliku cpp są wypełniane automatycznie na podstawie wprowadzonej nazwy.
  - Po zakończeniu kliknij przycisk OK .

Po wygenerowaniu plików .h i cpp dla klasy oba pliki są otwierane na kartach Grupy edytorów. Teraz zaktualizuj każdy plik, aby zaimplementować nową klasę obserwatora:

Zaktualizuj wartość "filehandler_observer.h", wybierając/usuwając wygenerowaną filehandler_observer klasę. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

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

Zaktualizuj plik "filehandler_observer.cpp", wybierając/usuwając implementację wygenerowanej filehandler_observer klasy. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

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

Opcjonalnie użyj klawisza F6 (Kompiluj rozwiązanie), aby uruchomić kompilowanie/łącze testowe rozwiązania, aby upewnić się, że kompilacja została pomyślnie skompilowana przed kontynuowaniem.

Dodawanie logiki do ustawiania i uzyskiwania etykiety poufności

Dodaj logikę, aby ustawić i uzyskać etykietę poufności w pliku przy użyciu obiektu Aparat plików.

Za pomocą Eksplorator rozwiązań otwórz plik cpp w projekcie zawierający implementację main() metody . Domyślnie ma taką samą nazwę jak projekt zawierający go, który został określony podczas tworzenia projektu.
Dodaj następujące #include dyrektywy i using poniżej odpowiednich istniejących dyrektyw w górnej części pliku:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Na końcu treści poniżej system("pause"); i powyżej return 0; (po lewej stronie w poprzednim przewodniku main() Szybki start) wstaw następujący kod:

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

Pod koniec znajdowania bloku zamykania aplikacji utworzonego w pierwszym przewodniku main() Szybki start i usuń komentarz z wiersza procedury obsługi:

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

Zastąp wartości symboli zastępczych w kodzie źródłowym w następujący sposób, używając stałych ciągów:

Symbol zastępczy	Wartość
<input-file-path>	Pełna ścieżka do pliku wejściowego testu, na przykład: `"c:\\Test\\Test.docx"`.
<identyfikator zawartości>	Czytelny dla człowieka identyfikator zawartości. Na przykład: . w przypadku pliku rozważ ścieżkę\nazwę pliku: `"c:\Test\Test.docx"` w przypadku wiadomości e-mail rozważ temat:sender: `"RE: Audit design:user1@contoso.com"`
<label-id>	Identyfikator etykiety poufności skopiowany z danych wyjściowych konsoli w poprzednim przewodniku Szybki start, na przykład: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	Pełna ścieżka do pliku wyjściowego, który będzie etykietą kopii pliku wejściowego, na przykład: `"c:\\Test\\Test_labeled.docx"`.

Kompilowanie i testowanie aplikacji

Skompiluj i przetestuj aplikację kliencą.

Skompiluj aplikację kliencą przy użyciu klawisza F6 (rozwiązanie kompilacji). Jeśli nie masz błędów kompilacji, użyj klawisza F5 (Rozpocznij debugowanie), aby uruchomić aplikację.

Jeśli projekt kompiluje i uruchamia się pomyślnie, aplikacja monituje o token dostępu, za każdym razem, gdy zestaw SDK wywołuje metodę AcquireOAuth2Token() . Podobnie jak wcześniej w przewodniku Szybki start "Wyświetlanie etykiet poufności listy" uruchom skrypt programu PowerShell, aby uzyskać token za każdym razem, używając wartości podanych dla $authority i $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 . . .

Aplikację etykiety można zweryfikować, otwierając plik wyjściowy i sprawdzając wizualnie ustawienia ochrony informacji dokumentu.

Uwaga

Jeśli oznaczasz dokument pakietu Office, ale nie logujesz się przy użyciu konta z dzierżawy firmy Microsoft Entra, w której uzyskano token dostępu (i skonfigurowano etykiety poufności), może zostać wyświetlony monit o zalogowanie się przed otwarciem dokumentu oznaczonego etykietą.

Udostępnij za pośrednictwem

Szybki start: ustawianie i uzyskiwanie etykiety poufności (C++)

Wymagania wstępne

Implementowanie klasy obserwatora w celu monitorowania obiektu programu obsługi plików

Dodawanie logiki do ustawiania i uzyskiwania etykiety poufności

Kompilowanie i testowanie aplikacji

Opinia

Dodatkowe zasoby