Kit de développement logiciel (SDK) Microsoft Information Protection - Concepts du moteur du kit de développement logiciel (SDK) Policy

mip::PolicyEngine implémente toutes les opérations que le kit de développement logiciel (SDK) Policy peut effectuer, à l’exception du chargement du profil.

Implémentation : Ajouter un moteur Policy

Implémentation : Créer les paramètres du moteur Policy

Comme pour un profil, le moteur nécessite également un objet de paramètres, mip::PolicyEngine::Settings. Cet objet stocke l’identificateur de moteur unique, un objet de votre implémentation de mip::AuthDelegate, des données client personnalisables qui peuvent être utilisées pour le débogage ou la télémétrie, et, éventuellement, la locale.

Ici, nous créons un objet FileEngine::Settings appelé engineSettings à l’aide de l’identité de l’utilisateur de l’application :

PolicyEngine::Settings engineSettings(
  mip::Identity(mUsername), // mip::Identity.  
  authDelegateImpl,         // Auth delegate object
  "",                       // Client data. Customizable by developer, stored with engine.
  "en-US",                  // Locale.
  false);                   // Load sensitive information types for driving classification.

Lors de la création des engineSettings de cette façon, il est important de définir explicitement un engineId unique via :

engineSettings.SetEngineId(engineId);

L’utilisation du nom d’utilisateur ou de l’e-mail permet de s’assurer que le même moteur est chargé chaque fois que l’utilisateur utilise le service ou l’application.

Il est également possible de fournir un ID de moteur personnalisé :

PolicyEngine::Settings engineSettings(
  "myEngineId",     // String
  authDelegateImpl, // Auth delegate object
  "",               // Client data in string format. Customizable by developer, stored with engine.
  "en-US",          // Locale. Default is en-US
  false);           // Load sensitive information types for driving classification. Default is false.

En guise de meilleure pratique, le premier paramètre, id, doit être quelque chose qui permet au moteur d’être facilement connecté à l’utilisateur associé, de préférence le nom d’utilisateur principal.

Implémentation : Ajouter le moteur Policy

Pour ajouter le moteur, nous allons revenir au modèle avenir/promesse utilisé pour charger le profil. Au lieu de créer la promesse pour mip::Profile, nous allons utiliser mip::PolicyEngine.

  // Auto profile will be std::shared_ptr<mip::Profile>.
  auto profile = profileFuture.get();

  // Create the delegate
  auto authDelegateImpl = std::make_shared<sample::auth::AuthDelegateImpl>(appInfo, userName, password);


  // Create the PolicyEngine::Settings object.
  PolicyEngine::Settings engineSettings("UniqueID", authDelegateImpl, "");

  // Create a promise for std::shared_ptr<mip::PolicyEngine>.
  auto enginePromise = std::make_shared<std::promise<std::shared_ptr<mip::PolicyEngine>>>();

  // Instantiate the future from the promise.
  auto engineFuture = enginePromise->get_future();

  // Add the engine using AddEngineAsync, passing in the engine settings and the promise.
  profile->AddEngineAsync(engineSettings, enginePromise);

  // Get the future value and store in std::shared_ptr<mip::PolicyEngine>.
  auto engine = engineFuture.get();

Le résultat final du code ci-dessus est que nous avons correctement ajouté un moteur pour l’utilisateur authentifié au profil.

Implémentation : Lister les étiquettes de confidentialité

À l’aide du moteur ajouté, il est désormais possible de répertorier toutes les étiquettes de confidentialité disponibles pour l’utilisateur authentifié en appelant engine->ListSensitivityLabels().

ListSensitivityLabels() récupère la liste des étiquettes et des attributs de ces étiquettes pour un utilisateur spécifique du service. Le résultat est stocké dans un vecteur de std::shared_ptr<mip::Label>.

Implémentation : ListSensitivityLabels()

std::vector<shared_ptr<mip::Label>> labels = engine->ListSensitivityLabels();

Implémentation : Imprimer les étiquettes

//Iterate through all labels in the vector
for (const auto& label : labels) {
  //print the label name
  cout << label->GetName() << endl;
  //Iterate through all child labels
  for (const auto& child : label->GetChildren()) {
    //Print the label with some formatting
    cout << "->  " << child->GetName() << endl;
  }
}

L’impression des noms est un moyen simple de montrer que nous avons bien récupéré la stratégie depuis le service et que nous avons pu obtenir les étiquettes. L’identificateur d’étiquette est requis pour appliquer l’étiquette. La modification de l’extrait ci-dessus pour renvoyer l’ID d’étiquette entraîne les résultats suivants :

for (const auto& label : labels) {
  //Print label name and GUID
  cout << label->GetName() << " : " << label->GetId() << endl;

  //Print child label name and GUID
  for (const auto& child : label->GetChildren()) {
    cout << "->  " << child->GetName() <<  " : " << child->GetId() << endl;
  }
}

La collection de mip::Label renvoyée par ListSensitivityLabels() peut être utilisée pour afficher toutes les étiquettes disponibles pour l’utilisateur, puis, quand elle est sélectionnée, utilisez l’ID pour appliquer des étiquettes à un fichier.