Microsoft Information Protection SDK – Schutzhandlerkonzepte

Im MIP Protection SDK werden die mip::ProtectionHandler Funktionen zum Verschlüsseln und Entschlüsseln geschützter Datenströme und Puffer, zum Durchführen von Zugriffsprüfungen, zum Abrufen der Veröffentlichungslizenz und zum Abrufen von Attributen aus den geschützten Informationen verfügbar gemacht.

Anforderungen

Zum Erstellen einer ProtectionHandler Datei für die Arbeit mit einer bestimmten Datei ist Folgendes erforderlich:

• Einen mip::MipContext
• Einen mip::ProtectionProfile
• Ein mip::ProtectionEngine wurde dem ProtectionProfile hinzugefügt
• Eine Klasse, die von mip::ProtectionHandler::Observer erbt.
• Ein mip::ProtectionDescriptor oder eine Veröffentlichungslizenz

Erstellen eines Schutzhandlers

mip::ProtectionHandler Objekte werden für Schutz - oder Verbrauchsvorgänge erstellt. Der Handler wird je nach Szenario mit einer von vier Funktionen erstellt.

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

Diese Funktionen akzeptieren entweder ein mip::ProtectionHandler::PublishingSettings oder ein mip::ProtectionHandler::ConsumptionSettings Objekt.

Erstellen eines Veröffentlichungshandlers

Zum Erstellen eines Veröffentlichungshandlers sind drei Schritte erforderlich:

1. Erstellen eines mip::ProtectionDescriptor-Objekts
2. Verwenden Sie die mip::ProtectionDescriptor, um mip::ProtectionHandler::PublishingSettings zu instanziieren.
3. Rufen Sie mip::ProtectionEngine::CreateProtectionHandlerForPublishingAsync() auf, welches im PublishingSettings-Objekt, Beobachter und der Zusage weitergegeben wird.

Aus Deskriptor erstellen

Beim Schützen von Inhalten, die noch nicht geschützt wurden, oder beim Anwenden eines neuen Schutzes auf Inhalte, was bedeutet, dass er entschlüsselt wurde, muss ein mip::ProtectionDescriptor erstellt werden. Nach der Konstruktion wird es verwendet, um das mip::ProtectionHandler::PublishingSettings() Objekt zu instanziieren. Das Ergebnis wird durch mip::ProtectionHandler::Observer zurückgegeben.

// 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;

Nachdem Sie das ProtectionHandler Objekt erfolgreich erstellt haben, können Schutzvorgänge (Verschlüsseln/Entschlüsseln) ausgeführt werden. Die Veröffentlichungslizenz muss vom Handler abgerufen und mit dem verschlüsselten Inhalt gespeichert werden. Die Veröffentlichungslizenz kann durch Aufrufen abgerufen werden: handler->GetSerializedPublishingLicense();

Geschützte Inhalte ohne die entsprechende Veröffentlichungslizenz können nicht entschlüsselt werden.

Erstellen Sie den Verbrauchshandler

Zum Erstellen eines Veröffentlichungshandlers sind drei Schritte erforderlich:

1. Extrahieren Sie eine serialisierte Veröffentlichungslizenz als std::vector<uint8_t> aus dem geschützten Inhalt.
2. Verwenden Sie die serialisierte Veröffentlichungslizenz zum Instanziieren von mip::ProtectionHandler::ConsumptionSettings.
3. Rufen Sie mip::ProtectionEngine::CreateProtectionHandlerForConsumptionAsync() auf, welches im ConsumptionSettings-Objekt, Beobachter und der Zusage weitergegeben wird.

In diesem Beispiel wird davon ausgegangen, dass die Veröffentlichungslizenz bereits aus einer Quelle gelesen und in std::vector<uint8_t> serializedPublishingLicensegespeichert wurde.

//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();