Inicio rápido: establecer y obtener una etiqueta de confidencialidad (C++)

Artículo
11/27/2021
Tiempo de lectura: 7 minutos

En este inicio rápido se muestra cómo usar más de los SDK de archivo de MIP. Al utilizar una de las etiquetas de confidencialidad que aparece en la guía de inicio rápido anterior, utilice un controlador de archivo para establecer y obtener la etiqueta en un archivo. La clase del controlador de archivos expone varias operaciones de configuración/obtención de etiquetas, o de protección, para los tipos de archivo admitidos.

Requisitos previos

Si aún no lo ha hecho, asegúrese de completar los siguientes requisitos previos antes de continuar:

Complete primero la Quickstart: List sensitivity labels (C++) [Guía de inicio rápido: mostrar etiquetas de confidencialidad (C++)], en la que se compila una solución inicial de Visual Studio, con el fin de mostrar las etiquetas de confidencialidad de una organización. Esta guía de inicio rápido "Establecer y obtener una etiqueta de confidencialidad" se basa en la anterior.
Si lo desea: revise los conceptos sobre controladores de archivos en el SDK de MIP.

Implemente una clase de observador para supervisar el objeto de controlador de archivos

De forma similar al observador que ha implementado (para el motor y perfil del archivo) en la guía de inicio rápido de inicialización de la aplicación, implemente ahora una clase de observador para un objeto del controlador de archivos.

Extienda la clase mip::FileHandler::Observer del SDK para crear una implementación básica de una clase de observador Controlador de archivo. Se crea una instancia del observador, que se usa más adelante para supervisar las operaciones del controlador de archivos.

Abra la solución de Visual Studio con la que ha trabajado en el artículo anterior "Quickstart: List sensitivity labels (C++)" [Guía de inicio rápido: mostrar etiquetas de confidencialidad (C++)].
Agregue una nueva clase al proyecto, que genera automáticamente los archivos de encabezado/.h e implementación/.cpp:
- En el Explorador de soluciones, vuelva a hacer clic con el botón derecho en el nodo del proyecto, seleccione Agregar y después Clase.
- En el cuadro de diálogo Agregar clase:
  - En el campo Nombre de clase, escriba "filehandler_observer". Tenga en cuenta que tanto el campo Archivo .h como el campo Archivo .cpp se rellenan automáticamente, según el nombre especificado.
  - Cuando haya terminado, haga clic en el botón Aceptar.

Después de generar los archivos .h y .cpp para la clase, ambos archivos se abren en pestañas del Grupo de editores. Ahora, actualice cada archivo para implementar la nueva clase de observador:

Actualice "filehandler_observer.h" al seleccionar o eliminar la clase filehandler_observer generada. No quite las directivas de preprocesador generadas en el paso anterior (#pragma, #include). Después, copie y pegue el siguiente código fuente en el archivo, después de las directivas de preprocesador existentes:

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

Actualice "filehandler_observer.cpp" al seleccionar o eliminar la implementación de clase filehandler_observer generada. No quite las directivas de preprocesador generadas en el paso anterior (#pragma, #include). Después, copie y pegue el siguiente código fuente en el archivo, después de las directivas de preprocesador existentes:

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

También puede presionar F6 (Compilar solución) para ejecutar una compilación o vínculo de prueba de la solución y asegurarse de que se compila correctamente antes de continuar.

Agregar lógica para establecer y obtener una etiqueta de confidencialidad

Agregue lógica para establecer y obtener una etiqueta de confidencialidad en un archivo mediante el objeto del motor de archivo.

Mediante el Explorador de soluciones, abra el archivo .cpp en el proyecto que contiene la implementación del método . El valor predeterminado es el mismo nombre que el proyecto que lo contiene, el cual ha especificado al crear el proyecto.
Agregue las siguientes directivas #include y using, debajo de las directivas existentes correspondientes, en la parte superior del archivo:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Hacia el final del cuerpo de main(), debajo de system("pause"); y encima de return 0; (donde se quedó en la guía de inicio rápido anterior), inserte el código siguiente:

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

Hacia el final de main(), busque el bloque de cierre de la aplicación creado en el primer inicio rápido y quite la marca de comentario de la línea del controlador:

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

Reemplace los valores de marcador de posición en el código fuente por constantes de cadena:

Marcador	Valor
<input-file-path>	La ruta de acceso completa a un archivo de entrada de prueba, por ejemplo: `"c:\\Test\\Test.docx"`.
<content-identifier>	Identificador en lenguaje natural del contenido. Por ejemplo: para un archivo, ruta\nombre_archivo: `"c:\Test\Test.docx"` para un correo electrónico, asunto:remitente: `"RE: Audit design:user1@contoso.com"`
<label-id>	Un identificador de etiqueta de confidencialidad, que se copia desde la salida de la consola en la guía de inicio rápido anterior, por ejemplo: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	La ruta de acceso completa al archivo de salida, que será una copia con la etiqueta del archivo de entrada, por ejemplo: `"c:\\Test\\Test_labeled.docx"`.

Compilar y probar la aplicación

Compile y pruebe la aplicación cliente.

Presione F6 (Compilar solución) para compilar la aplicación cliente. Si no aparece ningún error de compilación, presione F5 (Iniciar depuración) para ejecutar la aplicación.

Si el proyecto se compila y se ejecuta correctamente, la aplicación solicita un token de acceso cada vez que el SDK llama al método AcquireOAuth2Token(). Como ha hecho anteriormente en la guía de inicio rápido "Mostrar etiquetas de confidencialidad", ejecute el script de PowerShell para adquirir el token cada vez, utilizando los valores proporcionados para $authority y $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 . . .

Para comprobar la aplicación de la etiqueta, abra el archivo de salida e inspeccione visualmente la configuración de protección de información del documento.

Nota

Si está etiquetando un documento de Office, pero no ha iniciado sesión con una cuenta del inquilino de Azure Active Directory (AD) en la que se ha obtenido el token de acceso (y se configuran las etiquetas de confidencialidad), puede que se le pida que inicie sesión para poder abrir el documento etiquetado.

Inicio rápido: establecer y obtener una etiqueta de confidencialidad (C++)

Valore su experiencia

Requisitos previos

Implemente una clase de observador para supervisar el objeto de controlador de archivos

Agregar lógica para establecer y obtener una etiqueta de confidencialidad

Compilar y probar la aplicación