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

Um Inhalte zu schützen, die noch nicht geschützt sind, oder um neuen Schutz auf entschlüsselte Inhalte anzuwenden, erstellen Sie eine mip::ProtectionDescriptor. Verwenden Sie es, um das mip::ProtectionHandler::PublishingSettings() Objekt zu instanziieren. Das SDK liefert das Ergebnis über mip::ProtectionHandler::Observer zurück.

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

Nachdem Sie das ProtectionHandler Objekt erfolgreich erstellt haben, können Sie Schutzvorgänge für Verschlüsselung und Entschlüsselung ausführen. Rufen Sie die Veröffentlichungslizenz vom Handler ab, und speichern Sie sie mit dem verschlüsselten Inhalt. Rufen Sie zum Abrufen der Veröffentlichungslizenz auf handler->GetSerializedPublishingLicense();.

Ohne die entsprechende Veröffentlichungslizenz können Sie geschützte Inhalte nicht entschlüsseln .

Erstellen Sie den Verbrauchshandler

Das Erstellen eines Verbrauchshandlers erfordert drei Schritte:

  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<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ächste Schritte

  • Last updated on