Kit de développement logiciel (SDK) Microsoft Information Protection - Concepts du gestionnaire de protection

Dans le kit de développement logiciel (SDK) MIP Protection, le mip::ProtectionHandler expose les fonctions de chiffrement et de déchiffrement des flux protégés et des mémoires tampons, en effectuant des vérifications d’accès , en obtenant la licence de publication ainsi que des attributs à partir des informations protégées.

Spécifications

La création d’un ProtectionHandler pour travailler avec un fichier spécifique nécessite :

• Un mip::MipContext
• Un mip::ProtectionProfile
• Un mip::ProtectionEngine ajouté à l’élément ProtectionProfile
• Classe qui hérite mip::ProtectionHandler::Observer.
• Un mip::ProtectionDescriptor ou une licence de publication

Créer un gestionnaire de protection

Les objets mip::ProtectionHandler sont construits pour les opérations de protection ou de consommation. Le gestionnaire est créé à l’aide de l’une des quatre fonctions, selon le scénario.

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

Ces fonctions acceptent un objet mip::ProtectionHandler::PublishingSettings ou mip::ProtectionHandler::ConsumptionSettings.

Créer un gestionnaire de publication

La création d’un gestionnaire de publication nécessite trois étapes :

1. Créez un objet mip::ProtectionDescriptor.
2. Utilisez le mip::ProtectionDescriptor pour instancier mip::ProtectionHandler::PublishingSettings.
3. Appelez le passage mip::ProtectionEngine::CreateProtectionHandlerForPublishingAsync() de l’objet, de l’observateur et de la promesse PublishingSettings.

Créer à partir du descripteur

Si vous protégez le contenu qui n’a pas encore été protégé ou que vous appliquez une nouvelle protection au contenu, ce qui implique qu’il a été déchiffré, un mip::ProtectionDescriptor doit être construit. Une fois construit, il est utilisé pour instancier l’objet mip::ProtectionHandler::PublishingSettings(). Le résultat est retourné sous la forme d’un 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;

Une fois que vous avez créé l’objet ProtectionHandler, les opérations de protection (chiffrement/déchiffrement) peuvent être effectuées. La licence de publication doit être extraite du gestionnaire et stockée avec le contenu chiffré. La licence de publication peut être récupérée en appelant : handler->GetSerializedPublishingLicense();

Le contenu protégé sans la licence de publication correspondante ne peut pas être déchiffré.

Créer le gestionnaire de consommation

La création d’un gestionnaire de publication nécessite trois étapes :

1. Extrayez une licence de publication sérialisée en tant que std::vector<uint8_t> à partir du contenu protégé.
2. Utilisez la licence de publication sérialisée pour instancier mip::ProtectionHandler::ConsumptionSettings.
3. Appelez le passage mip::ProtectionEngine::CreateProtectionHandlerForConsumptionAsync() de l’objet, de l’observateur et de la promesse ConsumptionSettings.

Cet exemple suppose que la licence de publication a déjà été lue à partir d’une source et stockée dans 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();