Compartir a través de

SDK de Microsoft Information Protection: conceptos del controlador de protección

  • Artículo

En el SDK de protección de MIP, el elemento mip::ProtectionHandler expone las funciones para cifrar y descifrar secuencias y búferes protegidos, realizar comprobaciones de acceso, obtener la licencia de publicación y obtener atributos de la información protegida.

Requisitos

La creación de un ProtectionHandler para trabajar con un archivo específico requiere lo siguiente:

  • Una operación mip::MipContext
  • Una operación mip::ProtectionProfile
  • Agregar un mip::ProtectionEngine a ProtectionProfile
  • Una clase que herede mip::ProtectionHandler::Observer
  • Un mip::ProtectionDescriptor o licencia de publicación

Creación de un controlador de protección

Los objetos mip::ProtectionHandler se crean para operaciones de protección o consumo. El controlador se crea mediante una de cuatro funciones, dependiendo del escenario.

  • mip::ProtectionEngine->CreateProtectionHandlerForConsumptionAsync()
  • mip::ProtectionEngine->CreateProtectionHandlerForConsumption()
  • mip::ProtectionEngine->CreateProtectionHandlerForPublishingAsync()
  • mip::ProtectionEngine->CreateProtectionHandlerForPublishing()

Estas funciones aceptan un objeto mip::ProtectionHandler::PublishingSettings o mip::ProtectionHandler::ConsumptionSettings.

Creación de un controlador de publicación

La creación de un controlador de consumo requiere tres pasos:

  1. Crear un objeto mip::ProtectionDescriptor.
  2. Usar mip::ProtectionDescriptor para crear una instancia de mip::ProtectionHandler::PublishingSettings.
  3. Llamar a mip::ProtectionEngine::CreateProtectionHandlerForPublishingAsync() incorporando el objeto PublishingSettings, el observador y la promesa.

Creación a partir de un descriptor

Si aún no se ha protegido el contenido, o al aplicar una nueva protección al contenido, lo que implica que se ha descifrado, se debe construir un mip::ProtectionDescriptor. Una vez construido, se usa para crear instancias del objeto mip::ProtectionHandler::PublishingSettings(). El resultado se devuelve a través del mip::ProtectionHandler::Observer.

// Create the protection descriptor, passing in a templateId. 
auto descriptorBuilder = mip::ProtectionDescriptorBuilder::CreateFromTemplate(protectionOptions.templateId);
std::shared_ptr<mip::ProtectionDescriptor> descriptor = descriptorBuilder->Build();

// Define the handler promise, future, and observer.
auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto handlerFuture = handlerPromise->get_future();
auto handlerObserver = std::make_shared<ProtectionHandlerObserverImpl>();

// Create the PublishingSettings object using the previously-created descriptor as input.
mip::ProtectionHandler::PublishingSettings publishingSettings = mip::ProtectionHandler::PublishingSettings(descriptor);

// Create/get the publishing handler from the publishing settings, observer, and promise.
mEngine->CreateProtectionHandlerForPublishingAsync(publishingSettings, handlerObserver, handlerPromise);
auto handler = handlerFuture.get();
return handler;

Después de crear correctamente el objeto ProtectionHandler, se podrán realizar operaciones de protección (cifrar o descifrar). La licencia de publicación debe capturarse desde el controlador y almacenarse con el contenido cifrado. La licencia de publicación se puede capturar mediante una llamada a: handler->GetSerializedPublishingLicense();

No se puede descifrar el contenido protegido sin la licencia de publicación correspondiente.

Creación del controlador de consumo

La creación de un controlador de consumo requiere tres pasos:

  1. Extraer una licencia de publicación serializada como std::vector<uint8_t> a partir del contenido protegido.
  2. Usar la licencia de publicación serializada para crear una instancia de mip::ProtectionHandler::ConsumptionSettings.
  3. Llamar a mip::ProtectionEngine::CreateProtectionHandlerForConsumptionAsync() incorporando el objeto ConsumptionSettings, el observador y la promesa.

En este ejemplo se presupone que la licencia de publicación ya se ha leído desde algún origen y se ha almacenado en std::vector<uint8_t> serializedPublishingLicense.

//TODO: Implement GetPublishingLicense()
//Snip implies that function reads PL from source file, database, stream, etc.
std::vector<uint8_t> serializedPublishingLicense = GetPublishingLicense(filePath);

// Define the handler promise, future, and observer.
auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto handlerFuture = handlerPromise->get_future();
shared_ptr<ProtectionHandlerObserverImpl> handlerObserver = std::make_shared<ProtectionHandlerObserverImpl>();

// Create the consumption settings object from the publishing license.
mip::ProtectionHandler::ConsumptionSettings consumptionSettings = mip::ProtectionHandler::ConsumptionSettings(serializedPublishingLicense);

// Create/get the publishing handler from the publishing settings, observer, and promise.
mEngine->CreateProtectionHandlerForConsumptionAsync(consumptionSettings, handlerObserver, handlerPromise);
auto handler = handlerFuture.get();