Quickstart: Encriptar e desencriptar texto usando MIP SDK (C++)

Este guia de início rápido mostra-lhe como utilizar mais recursos dos SDKs de Proteção MIP. Ao usar um dos modelos de proteção que mencionaste no quickstart anterior, utilizas um gestor de Proteção para encriptar texto ad hoc. A classe de manipulador de proteção expõe várias operações para aplicar e remover proteção.

Pré-requisitos

Se ainda não o fez, certifique-se de que preenche os seguintes pré-requisitos antes de continuar:

Implementar uma classe de observador para monitorar o objeto do manipulador de proteção

Semelhante ao observador que implementaste para o perfil e motor Protection no quickstart de inicialização da aplicação, agora implementas uma classe observer para os objetos do handler Protection.

Crie uma implementação básica para um observador de processador de proteção, ao estender a classe mip::ProtectionHandler::Observer do SDK. O SDK instancia e utiliza o observador mais tarde para monitorizar as operações do manipulador de Proteção.

  1. Abra a solução do Visual Studio em que você trabalhou no artigo anterior "Guia de início rápido: modelos de proteção de lista (C++)".

  2. Adicione uma nova classe ao seu projeto, que gera tanto o cabeçalho (.h) como os ficheiros de implementação (.cpp) para si:

    • No Explorador de Soluções, clique com o botão direito no nó do projeto novamente, selecione Adicionar e depois selecione Classe.
    • Na caixa de diálogo Adicionar classe :
      • No campo Nome da Classe , introduza handler_observer. Repare que Visual Studio preenche automaticamente tanto os campos do ficheiro .h como .cpp com base no nome que inserir.
      • Quando terminar, seleccione OK.

  3. Depois de gerar os ficheiros .h e .cpp para a classe, Visual Studio abre ambos os ficheiros nos separadores do Grupo de Editores. Agora atualize cada arquivo para implementar sua nova classe de observador:

    • Atualize handler_observer.h selecionando e eliminando a classe gerada handler_observer . Não remova as diretivas do pré-processador que o passo anterior gerou (#pragma, #include). Depois, copie e cole a seguinte fonte no ficheiro após quaisquer diretivas do pré-processador 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;
     };

    • Atualize handler_observer.cpp selecionando e eliminando a implementação da classe gerada handler_observer . Não remova as diretivas do pré-processador que o passo anterior gerou (#pragma, #include). Depois, copie e cole a seguinte fonte no ficheiro após quaisquer diretivas do pré-processador existentes:

      #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. Opcionalmente, use Ctrl+Shift+B (Build Solution) para executar uma compilação e ligação de teste da solução, para verificar se é compilada com êxito antes de continuar.

Adicionar lógica para criptografar e descriptografar texto ad hoc

Adicione lógica para encriptar e desencriptar texto ad hoc usando o objeto Protection engine.

  1. Usando o Gerenciador de Soluções, abra o arquivo de .cpp em seu projeto que contém a main() implementação do método.

  2. Adicione as seguintes diretivas #include e diretivas using abaixo das diretivas correspondentes existentes na parte superior do ficheiro:

      #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. No final do Main() corpo, onde parou no quickstart anterior, insira o seguinte código:

    //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. Perto do final de main(), encontre o bloco de encerramento da aplicação criado pelo primeiro quickstart e adicione as seguintes linhas para libertar recursos do handler:

     publishingHandler = nullptr;
 consumptionHandler = nullptr;

  5. Substitua os valores provisórios no código-fonte usando as seguintes constantes de cadeia:

    Marcador de posição Valor
    <texto-exemplo> Exemplo de texto que você gostaria de proteger, por exemplo: "cipher text".
    <Template-ID> ID modelo que gostaria de usar para proteger o texto. Por exemplo: "bb7ed207-046a-4caf-9826-647cff56b990"

Crie e teste o aplicativo

Crie e teste seu aplicativo cliente.

  1. Use Ctrl+Shift+B (Build Solution) para construir a sua aplicação cliente. Se não tiveres erros de compilação, usa F5 (Start debug) para correr a tua aplicação.

  2. Se o seu projeto for construído e executado com sucesso, a aplicação solicita um token de acesso sempre que o SDK chama o seu AcquireOAuth2Token() método. Como fizeste anteriormente no quickstart "Templates de proteção de lista", executa o teu script PowerShell para adquirir o token cada vez, usando os valores fornecidos para $authority e $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 . . .

Passos seguintes

  • Última atualização a