Freigeben über

Microsoft Information Protection SDK – Protection Handlerkonzepte

  • Artikel

Im MIP Protection SDK stellt mip::ProtectionHandler die Funktionen zum Ver- und Entschlüsseln geschützter Streams und Puffer, zur Durchführung von Zugriffsprüfungen, zum Abrufen der Veröffentlichungslizenz und zum Abrufen von Attributen aus den geschützten Informationen zur Verfügung.

Anforderungen

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

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

Erstellen eines Schutzhandlers

mip::ProtectionHandler-Objekte werden für entweder 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 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. Wenn es erstellt wurde, 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 von handler->GetSerializedPublishingLicense(); abgerufen werden.

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

Erstellen des Verbrauchshandlers

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