Microsoft Information Protection SDK – Begrepp för skyddshanterare

I MIP Protection SDK mip::ProtectionHandler exponerar funktionerna för kryptering och dekryptering av skyddade strömmar och buffertar, utför åtkomstkontroller, hämtar publiceringslicensen och hämtar attribut från den skyddade informationen.

Krav

För att skapa en ProtectionHandler för att arbeta med en specifik fil krävs följande:

  • En mip::MipContext
  • En mip::ProtectionProfile
  • Ett mip::ProtectionEngine som har lagts till till ProtectionProfile
  • En klass som ärver mip::ProtectionHandler::Observer
  • En mip::ProtectionDescriptor-licens eller publiceringslicens

Skapa en skyddshanterare

mip::ProtectionHandler objekt skapas för antingen skydds- eller förbrukningsåtgärder . Hanteraren skapas med någon av fyra funktioner, beroende på scenariot.

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

Dessa funktioner accepterar antingen ett mip::ProtectionHandler::PublishingSettings objekt eller ett mip::ProtectionHandler::ConsumptionSettings objekt.

Skapa en publiceringshanterare

Det krävs tre steg för att skapa en publiceringshanterare:

  1. Skapa ett mip::ProtectionDescriptor objekt.
  2. mip::ProtectionDescriptor Använd för att instansiera mip::ProtectionHandler::PublishingSettings.
  3. Anropa mip::ProtectionEngine::CreateProtectionHandlerForPublishingAsync() med objektet PublishingSettings, observatören och löftet.

Skapa från beskrivning

Om du vill skydda innehåll som inte är skyddat ännu, eller om du vill använda nytt skydd för dekrypterat innehåll, skapar du en mip::ProtectionDescriptor. Använd den för att instansiera mip::ProtectionHandler::PublishingSettings() objektet. SDK returnerar resultatet via 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<mip::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;

När du har skapat ProtectionHandler objektet kan du utföra skyddsåtgärder för kryptering och dekryptering. Hämta publiceringslicensen från hanteraren och lagra den med det krypterade innehållet. Om du vill hämta publiceringslicensen anropar du handler->GetSerializedPublishingLicense();.

Utan motsvarande publiceringslicens kan du inte dekryptera skyddat innehåll.

Skapa förbrukningshanteraren

Att skapa en förbrukningshanterare kräver tre steg:

  1. Extrahera en serialiserad publiceringslicens std::vector<uint8_t> från det skyddade innehållet.
  2. Använd den serialiserade publiceringslicensen för att instansiera mip::ProtectionHandler::ConsumptionSettings.
  3. Anropa mip::ProtectionEngine::CreateProtectionHandlerForConsumptionAsync() med objektet ConsumptionSettings, observatören och löftet.

Det här exemplet förutsätter att publiceringslicensen redan har lästs från någon källa och lagrats i 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<mip::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();

Nästa steg

  • Last updated on