Inicio rápido: Cifrado y descifrado de texto mediante el SDK de MIP (C++)

En este inicio rápido se muestra cómo usar más de los SDK de MIP Protection. Mediante una de las plantillas de protección que aparecen en el inicio rápido anterior, se usa un controlador de protección para cifrar texto ad hoc. La clase de controlador de protección expone varias operaciones para aplicar y quitar la protección.

Prerrequisitos

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

Implementación de una clase de observador para supervisar el objeto de controlador de protección

De forma similar al observador que implementó para el perfil de protección y el motor en el inicio rápido de inicialización de la aplicación, ahora se implementa una clase de observador para objetos de controlador de protección.

Cree una implementación básica para un observador del controlador de protección ampliando la clase mip::ProtectionHandler::Observer del SDK. El SDK crea instancias y usa el observador más adelante para supervisar las operaciones del controlador de protección.

  1. Abra la solución de Visual Studio en la que ha trabajado en el artículo anterior "Inicio rápido: Enumerar plantillas de protección (C++)".

  2. Agregue una nueva clase al proyecto, que genera los archivos de encabezado (.h) e implementación (.cpp) automáticamente:

    • En Explorador de soluciones, vuelva a hacer clic con el botón derecho en el nodo del proyecto, seleccione Agregar y, a continuación, seleccione Clase.
    • En el cuadro de diálogo Agregar clase:
      • En el campo Nombre de clase , escriba handler_observer. Tenga en cuenta que Visual Studio rellena automáticamente los campos de archivo .h y .cpp en función del nombre que escriba.
      • Cuando haya terminado, seleccione Aceptar.

  3. Después de generar los archivos .h y .cpp para la clase , Visual Studio abre ambos archivos en las pestañas Grupo de editores. Ahora actualice cada archivo para implementar la nueva clase de observador:

    • Actualice handler_observer.h seleccionando y eliminando la clase generada handler_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo, después de las directivas de preprocesador existentes:

      #include <memory>
#include "mip/protection/protection_engine.h"
using std::shared_ptr;
using std::exception_ptr;

class ProtectionHandlerObserver final : public mip::ProtectionHandler::Observer {
     public:
     ProtectionHandlerObserver() { }
     void OnCreateProtectionHandlerSuccess(const shared_ptr<mip::ProtectionHandler>& protectionHandler, const shared_ptr<void>& context) override;
     void OnCreateProtectionHandlerFailure(const exception_ptr& Failure, const shared_ptr<void>& context) override;
     };

    • Actualice handler_observer.cpp seleccionando y eliminando la implementación de clase generada handler_observer . No quite las directivas de preprocesador que generó el paso anterior (#pragma, #include). A continuación, copie y pegue el siguiente código fuente en el archivo después de las directivas de preprocesador existentes, si las hubiera:

      #include "handler_observer.h"
using std::shared_ptr;
using std::promise;
using std::exception_ptr;

void ProtectionHandlerObserver::OnCreateProtectionHandlerSuccess(
     const shared_ptr<mip::ProtectionHandler>& protectionHandler,const shared_ptr<void>& context) {
          auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
          createProtectionHandlerPromise->set_value(protectionHandler);
          };

void ProtectionHandlerObserver::OnCreateProtectionHandlerFailure(
     const exception_ptr& Failure, const shared_ptr<void>& context) {
          auto createProtectionHandlerPromise = static_cast<promise<shared_ptr<mip::ProtectionHandler>>*>(context.get());
          createProtectionHandlerPromise->set_exception(Failure);
          };

  4. Si lo desea, puede usar Ctrl+Mayús+B (Compilar la solución) para ejecutar una compilación y un enlazado de prueba de la solución, y comprobar que se genera correctamente antes de continuar.

Adición de lógica para cifrar y descifrar texto ad hoc

Agregue lógica para cifrar y descifrar texto ad hoc mediante el objeto del motor de protección.

  1. Con el Explorador de soluciones, abra el archivo .cpp en el proyecto que contiene la implementación del main() método .

  2. Agregue las siguientes directivas #include y using debajo de las directivas correspondientes ya existentes en la parte superior del archivo:

      #include "mip/protection_descriptor_builder.h"
  #include "mip/protection_descriptor.h"
  #include "handler_observer.h"

  using mip::ProtectionDescriptor;
  using mip::ProtectionDescriptorBuilder;
  using mip::ProtectionHandler;

  3. Hacia el final del Main() cuerpo, donde dejó en el inicio rápido anterior, inserte el código siguiente:

    //Encrypt/Decrypt text:
string templateId = "<Template-ID>";//Template ID from previous QuickStart e.g. "bb7ed207-046a-4caf-9826-647cff56b990"
string inputText = "<Sample-Text>";//Sample Text

//Refer to ProtectionDescriptor docs for details on creating the descriptor
auto descriptorBuilder = mip::ProtectionDescriptorBuilder::CreateFromTemplate(templateId);
const std::shared_ptr<mip::ProtectionDescriptor>& descriptor = descriptorBuilder->Build();

//Create Publishing settings using a descriptor
mip::ProtectionHandler::PublishingSettings publishingSettings = mip::ProtectionHandler::PublishingSettings(descriptor);

//Create a publishing protection handler using Protection Descriptor
auto handlerObserver = std::make_shared<ProtectionHandlerObserver>();
auto pHandlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto pHandlerFuture = pHandlerPromise->get_future();
engine->CreateProtectionHandlerForPublishingAsync(publishingSettings, handlerObserver, pHandlerPromise);
auto publishingHandler = pHandlerFuture.get();

std::vector<uint8_t> inputBuffer(inputText.begin(), inputText.end());

//Show action plan
cout << "Applying Template ID " + templateId + " to: " << endl << inputText << endl;

//Encrypt buffer using Publishing Handler
std::vector<uint8_t> encryptedBuffer;
encryptedBuffer.resize(static_cast<size_t>(publishingHandler->GetProtectedContentLength(inputText.size(), true)));

publishingHandler->EncryptBuffer(0,
                      &inputBuffer[0],
                      static_cast<int64_t>(inputBuffer.size()),
                      &encryptedBuffer[0],
                      static_cast<int64_t>(encryptedBuffer.size()),
                      true);

std::string encryptedText(encryptedBuffer.begin(), encryptedBuffer.end());
cout << "Encrypted Text :" + encryptedText;

//Show action plan
cout << endl << "Decrypting string: " << endl << endl;

//Generate publishing license, so it can be used later to decrypt text.
auto serializedPublishingLicense = publishingHandler->GetSerializedPublishingLicense();

//Use same PL to decrypt the encryptedText.
auto cHandlerPromise = std::make_shared<std::promise<std::shared_ptr<ProtectionHandler>>>();
auto cHandlerFuture = cHandlerPromise->get_future();
shared_ptr<ProtectionHandlerObserver> cHandlerObserver = std::make_shared<ProtectionHandlerObserver>();

//Create consumption settings using serialized publishing license.
mip::ProtectionHandler::ConsumptionSettings consumptionSettings = mip::ProtectionHandler::ConsumptionSettings(serializedPublishingLicense);
engine->CreateProtectionHandlerForConsumptionAsync(consumptionSettings, cHandlerObserver, cHandlerPromise);

auto consumptionHandler = cHandlerFuture.get();

//Use consumption handler to decrypt the text.
std::vector<uint8_t> decryptedBuffer(static_cast<size_t>(encryptedText.size()));

int64_t decryptedSize = consumptionHandler->DecryptBuffer(
     0,
     &encryptedBuffer[0],
     static_cast<int64_t>(encryptedBuffer.size()),
     &decryptedBuffer[0],
     static_cast<int64_t>(decryptedBuffer.size()),
     true);

decryptedBuffer.resize(static_cast<size_t>(decryptedSize));

std::string decryptedText(decryptedBuffer.begin(), decryptedBuffer.end());

// Output decrypted content. Should match original input text.
cout << "Decrypted Text :" + decryptedText << endl;

  4. Hacia el final de main(), busque el bloque de cierre de la aplicación que creó la primera guía de inicio rápido y agregue las siguientes líneas para liberar los recursos del manejador:

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Reemplace los valores de marcador de posición en el código fuente mediante las siguientes constantes de cadena:

    Marcador de posición Valor
    <texto de muestra> Texto de ejemplo que desea proteger, por ejemplo: "cipher text".
    <Identificador de plantilla> Identificador de plantilla que desea usar para proteger el texto. Por ejemplo: "bb7ed207-046a-4caf-9826-647cff56b990"

Crear y probar la aplicación

Compile y pruebe la aplicación cliente.

  1. Utilice Ctrl+Mayús+B (Compilar solución) para compilar su aplicación cliente. Si no tiene errores de compilación, use F5 (Iniciar depuración) para ejecutar la aplicación.

  2. Si el proyecto se compila y se ejecuta correctamente, la aplicación solicita un token de acceso cada vez que el SDK llama al AcquireOAuth2Token() método . Como hizo anteriormente en el inicio rápido "Enumerar plantillas de protección", ejecute el script de PowerShell para adquirir el token cada vez mediante los valores proporcionados para $authority y $resourceUrl.

    *** Template List:
Name: Confidential \ All Employees : a74f5027-f3e3-4c55-abcd-74c2ee41b607
Name: Highly Confidential \ All Employees : bb7ed207-046a-4caf-9826-647cff56b990
Name: Confidential : 174bc02a-6e22-4cf2-9309-cb3d47142b05
Name: Contoso Employees Only : 667466bf-a01b-4b0a-8bbf-a79a3d96f720
Applying Template ID bb7ed207-046a-4caf-9826-647cff56b990 to:
<Sample-Text>
Encrypted Text :y¬╩$Ops7Γ╢╖¢t
Decrypting string:

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
Set $authority to: https://login.microsoftonline.com/common/oauth2/authorize
Set $resourceUrl to: https://aadrm.com
Sign in with user account: user1@tenant.onmicrosoft.com
Enter access token: <paste-access-token-here>
Press any key to continue . . .

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
Set $authority to: https://login.microsoftonline.com/94f69844-8d34-4794-bde4-3ac89ad2b664/oauth2/authorize
Set $resourceUrl to: https://aadrm.com
Sign in with user account: user1@tenant.onmicrosoft.com
Enter access token: <paste-access-token-here>
Press any key to continue . . .

Decrypted Text :<Sample-Text>
C:\MIP Sample Apps\ProtectionQS\Debug\ProtectionQS.exe (process 8252) exited with code 0.
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
Press any key to close this window . . .

Pasos siguientes

  • Last updated on