Szybki start: Szyfrowanie/odszyfrowywanie tekstu przy użyciu zestawu SDK MIP (C++)

Artykuł
11/28/2021
Czas czytania: 5 min

W tym przewodniku Szybki start pokazano, jak korzystać z większej liczby zestawów SDK ochrony przed miP. Korzystając z jednego z szablonów ochrony wymienionych w poprzednim przewodniku Szybki start, możesz użyć programu obsługi ochrony w celu szyfrowania tekstu ad hoc. Klasa programu obsługi ochrony udostępnia różne operacje na celu zastosowanie/usunięcie ochrony.

Wymagania wstępne

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

Ukończ szybki start: Najpierw szablony ochrony listy (C++), które tworzy rozwiązanie startowe Visual Studio, aby wyświetlić listę szablonów ochrony dostępnych dla uwierzytelnionego użytkownika. Ten przewodnik Szybki start "Szyfrowanie/odszyfrowywanie tekstu" opiera się na poprzedniej.
Opcjonalnie: Programy obsługi przeglądów funkcji Ochrona w pojęciach zestawu SDK MIP.

Implementowanie klasy inspektorów w celu monitorowania obiektu obsługi ochrony

Podobnie jak w przypadku inspektora zaimplementowanego (dla profilu ochrony i aparatu) w przewodniku Szybki start inicjowania aplikacji, teraz implementuje się klasę ochrony obiektów obsługi ochrony.

Utwórz podstawową implementację programu obsługi ochrony, rozszerzając klasę zestawu mip::ProtectionHandler::Observer SDK. Obserwator jest wystąpienia i używany później do monitorowania operacji obsługi ochrony.

Otwórz Visual Studio rozwiązania, nad którym pracowaliśmy w poprzednim artykule "Szybki start: szablony ochrony listy (C++)".
Dodaj do projektu nową klasę, która wygeneruje dla Ciebie zarówno pliki nagłówka/.h, jak i implementacji/.cpp:
- W Eksploratorze rozwiązańkliknij ponownie prawym przyciskiem myszy węzeł projektu, wybierz pozycję Dodaj, a następnie wybierz pozycję Klasa.
- W oknie dialogowym Dodawanie zajęć:
  - W polu Nazwa zajęć wprowadź "handler_observer". Zwróć uwagę, że zarówno pola pliku h, jak i pola pliku cpp są automatycznie wypełniane na podstawie wprowadzeniu nazwy.
  - Po zakończeniu kliknij przycisk OK.

Po wygenerowaniu plików h i cpp dla zajęć oba pliki są otwierane na kartach Grupy Redaktora. Teraz zaktualizuj każdy plik, aby wdrożyć swoją nową klasę obserwatorów:

Zaktualizuj "handler_observer.h", zaznaczając/usuwając wygenerowaną handler_observer klasę. Nie usuwaj użytkowników przedprocesowych wygenerowanych w poprzednim kroku (na przykład #pragma, #include). Następnie skopiuj/wklej do pliku następujące źródło po jakiejkolwiek istniejącej zaraz przedprocesorowi.

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

Zaktualizuj "handler_observer.cpp", wybierając/usuwając wygenerowaną handler_observer implementację klasy. Nie usuwaj użytkowników przedprocesowych wygenerowanych w poprzednim kroku (na przykład #pragma, #include). Następnie skopiuj/wklej do pliku następujące źródło po jakiejkolwiek istniejącej zaraz przedprocesorowi.

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

Opcjonalnie użyj klawiszy Ctrl+Shift+B(kompilacjarozwiązania), aby uruchomić testowe zestawienie/link do rozwiązania, aby upewnić się, że przed kontynuowaniem będzie ono pomyślnie tworzyć.

Dodawanie logiki w celu szyfrowania i odszyfrowywania tekstu ad hoc

Dodaj logikę w celu szyfrowania i odszyfrowywania tekstu ad hoc przy użyciu obiektu aparatu ochrony.

Za pomocą Eksploratorarozwiązań otwórz plik cpp w projekcie zawierającym implementację metody.

Dodaj następujące #include i zgodnie z odpowiednimi wytycznymi u góry pliku:

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

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

Na końcu treści, w miejscu, w którym wcześniej był wyłączany poprzedni szybki Main() start, wstaw następujący kod:

//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>();
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 licence, 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 serialised publishing licence.
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;

Pod koniec znajdź blok zamykania aplikacji utworzony w pierwszym przewodniku Szybki start i dodaj poniżej wiersze, aby zwolnić zasoby main() obsługi programu obsługi:
```
 publishingHandler = nullptr;
 consumptionHandler = nullptr;
```

Zamień wartości zastępcze w kodzie źródłowym na następujące wartości, używając stałych ciągów:

Symbol zastępczy	Wartość
<przykładowy tekst>	Przykładowy tekst, który chcesz chronić, na przykład: `"cipher text"` .
<Template-Id>	Identyfikator szablonu, którego chcesz użyć w celu ochrony tekstu. Na przykład: `"bb7ed207-046a-4caf-9826-647cff56b990"`

Tworzenie i testowanie aplikacji

Skompilowanie i testowanie aplikacji klienckiej.

Do tworzenia aplikacji klienckiejużyj klawiszy Ctrl+Shift+B (kompilacja rozwiązania). Jeśli nie występują błędy kompilacji, użyj klawisza F5(Rozpocznijdebugowanie), aby uruchomić aplikację.

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

Szybki start: Szyfrowanie/odszyfrowywanie tekstu przy użyciu zestawu SDK MIP (C++)

Oceń swoje doświadczenia

Wymagania wstępne

Implementowanie klasy inspektorów w celu monitorowania obiektu obsługi ochrony

Dodawanie logiki w celu szyfrowania i odszyfrowywania tekstu ad hoc

Tworzenie i testowanie aplikacji