Microsoft Information Protection SDK - Concepten van beveiligingshandler

In de MIP Protection SDK mip::ProtectionHandler worden de functies weergegeven voor het versleutelen en ontsleutelen van beveiligde streams en buffers, het uitvoeren van toegangscontroles, het verkrijgen van de publicatielicentie en het ophalen van kenmerken van de beveiligde informatie.

Vereisten

Voor het maken van een ProtectionHandler bestand om te kunnen werken met een specifiek bestand is het volgende vereist:

• A mip::MipContext
• A mip::ProtectionProfile
• Een mip::ProtectionEngine toegevoegd aan de ProtectionProfile
• Een klasse die over neemt mip::ProtectionHandler::Observer.
• Een mip::ProtectionDescriptor of publicatielicentie

Een beveiligingshandler maken

mip::ProtectionHandlerobjecten worden samengesteld voor beveiligings- of verbruiksbewerkingen. De handler wordt gemaakt met behulp van een van de vier functies, afhankelijk van het scenario.

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

Deze functies accepteren een mip::ProtectionHandler::PublishingSettings of mip::ProtectionHandler::ConsumptionSettings object.

Een publicatiehandler maken

Voor het maken van een publicatie-handler zijn drie stappen vereist:

1. Maak een mip::ProtectionDescriptor object.
2. Gebruik de mip::ProtectionDescriptor functie om te instantiëren mip::ProtectionHandler::PublishingSettings.
3. Roep mip::ProtectionEngine::CreateProtectionHandlerForPublishingAsync() het doorgeven van het PublishingSettings object, de waarnemer en de belofte aan.

Maken op basis van descriptor

Als u inhoud beveiligt die nog niet is beveiligd of bij het toepassen van nieuwe beveiliging op inhoud, wat impliceert dat deze is ontsleuteld, moet er een mip::ProtectionDescriptor worden samengesteld. Zodra het is gemaakt, wordt het gebruikt om het mip::ProtectionHandler::PublishingSettings() object te instantiëren. Het resultaat wordt geretourneerd via de 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;

Nadat u het ProtectionHandler object hebt gemaakt, kunnen beveiligingsbewerkingen (versleutelen/ontsleutelen) worden uitgevoerd. De publicatielicentie moet worden opgehaald uit de handler en worden opgeslagen met de versleutelde inhoud. De publicatielicentie kan worden opgehaald door het volgende aan te roepen: handler->GetSerializedPublishingLicense();

Beveiligde inhoud zonder de bijbehorende publicatielicentie kan niet worden ontsleuteld.

De verbruikshandler maken

Voor het maken van een publicatie-handler zijn drie stappen vereist:

1. Extraheer een geserialiseerde publicatielicentie op basis std::vector<uint8_t> van de beveiligde inhoud.
2. Gebruik de geserialiseerde publicatielicentie om een instantie te maken mip::ProtectionHandler::ConsumptionSettings.
3. Roep mip::ProtectionEngine::CreateProtectionHandlerForConsumptionAsync() het doorgeven van het ConsumptionSettings object, de waarnemer en de belofte aan.

In dit voorbeeld wordt ervan uitgegaan dat de publicatielicentie al is gelezen uit een bepaalde bron en is opgeslagen in 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();