Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Le kit de développement logiciel (SDK) Microsoft Information Protection prend en charge deux types principaux d’autorisations basées sur des étiquettes : basées sur des modèles et définies par l’utilisateur.
Autorisations basées sur des modèles : ces droits sont définis par l’administrateur d’étiquettes dans le Centre de sécurité et de conformité. Ces étiquettes sont gérées de manière centralisée et les modifications apportées à la configuration ont un impact sur les utilisateurs qui ont déjà des copies des fichiers. Par exemple, si l’administrateur supprime un utilisateur de la liste des utilisateurs autorisés, cet utilisateur n’aura plus accès aux données protégées la prochaine fois qu’il tentera d’extraire une licence.
Autorisations définies par l’utilisateur : ces droits sont définis au moment de l’étiquetage par l’utilisateur final ou l’application. Les autorisations sont transmises au SDK MIP sous la forme d’une collection de mappages utilisateur-à-rôles ou utilisateurs-à-droits. Ces droits sont écrits dans la licence de publication pour le document protégé et, contrairement aux autorisations basées sur des modèles, ils ne peuvent pas être gérés ou modifiés de manière centralisée après le partage sans accès direct et modification du document.
Utilisateurs, droits et rôles
Étant donné qu’il est prévu que les droits soient définis par l’utilisateur au moment de l’étiquetage, votre application doit fournir une interface pour permettre à l’utilisateur ou au service de fournir une entrée sur les adresses e-mail et les droits ou rôles que l’utilisateur aura. Cette configuration est effectuée en transmettant une collection d’objets UserRoles ou UserRights qui définissent spécifiquement qui doit avoir le niveau d’accès aux documents.
// Create a List<string> of the first set of permissions.
List<string> users = new List<string>()
{
"alice@contoso.com",
"bob@contoso.com"
};
// Create a List<string> of the Rights the above users should have.
List<string> rights = new List<string>()
{
Rights.View,
Rights.Edit
};
// Create a UserRights object containing the defined users and rights.
UserRights userRights = new UserRights(users, rights);
// Add them to a new List<UserRights>
List<UserRights> userRightsList = new List<UserRights>()
{
userRights
};
Le résultat est que vous aurez une collection List<UserRights> spécifiant que Alice et Bob ont les droits VIEW et EDIT sur le fichier protégé. Pour ajouter d’autres utilisateurs avec un ensemble d’autorisations différent, répétez le processus pour créer un deuxième objet UserRights, en passant les nouveaux utilisateurs et autorisations, puis en ajoutant à la collection List<UserRights> en appelant userRightsList.Add(userRights2).
Ce modèle est également vrai pour UserRoles et peut être implémenté simplement en remplaçant les droits par des rôles et en créant une collection List<UserRoles>.
Protection d’un domaine
L’application d’autorisations définies par l’utilisateur pour un domaine nécessite l’utilisation d’un préfixe de messagerie connu et du domaine cible comme adresse e-mail. Cette adresse ressemble à : AllStaff-7184AB3F-CCD1-46F3-8233-3E09E9CF0E66@contoso.com.
Dans votre application, les utilisateurs doivent être en mesure de spécifier un domaine, comme contoso.com ou fabrikam.com. Lorsque l’application crée le descripteur de protection, elle doit ajouter AllStaff-7184AB3F-CCD1-46F3-8233-3E09E9CF0E66@ devant le suffixe de domaine.
Dans l’exemple ci-dessous, nous partons du principe que l’utilisateur a spécifié alice@contoso.com et tous les Fabrikam.com en tant que destinataires valides.
// Create a List<string> of the first set of permissions.
List<string> users = new List<string>()
{
"alice@contoso.com",
"AllStaff-7184AB3F-CCD1-46F3-8233-3E09E9CF0E66@fabrikam.com"
};
// Create a List<string> of the Rights the above users should have.
List<string> rights = new List<string>()
{
Rights.View,
Rights.Edit
};
// Create a UserRights object containing the defined users and rights.
UserRights userRights = new UserRights(users, rights);
// Add them to a new List<UserRights>
List<UserRights> userRightsList = new List<UserRights>()
{
userRights
};
Mettre en place la protection
La définition de la protection peut être obtenue en créant un ProtectionDescriptor à partir de l’objet List<UserRights> ou List<UserRoles>, puis en passant cela à FileHandler.SetProtection(). Enfin, commitez la modification apportée au fichier pour écrire un nouveau fichier.
Quand appliquer la protection aux fichiers
Lorsque vous définissez une étiquette via FileHandler.SetLabel(), le kit de développement logiciel (SDK) MIP doit prendre des mesures et appliquer n’importe quelle protection. Lorsque l’étiquette est configurée pour les autorisations définies par l’utilisateur (UDP), votre application n’a aucun moyen de savoir à l’avance que l’étiquette est une étiquette UDP. Le kit de développement logiciel (SDK) MIP expose ces informations en levant une exception du type Microsoft.InformationProtection.Exceptions.AdhocProtectionRequiredException. Votre code FileHandler doit intercepter cette exception, puis déclencher votre interface utilisateur ou service pour définir les autorisations personnalisées. Une fois cette procédure terminée, vous serez en mesure de définir la protection. L’exemple suivant montre le modèle de bout en bout, mais suppose que vous avez déjà implémenté une fonction pour générer l’objet List<UserRights>.
try
{
// Attempt to set the label. If it's a UDP label, this will throw.
handler.SetLabel(engine.GetLabelById(options.LabelId), labelingOptions, new ProtectionSettings());
}
catch (Microsoft.InformationProtection.Exceptions.AdhocProtectionRequiredException)
{
// Assumes you've create a function that returns the List<UserRights> as previously detailed.
List<UserRights> userRightsList = GetUserRights();
// Create a ProtectionDescriptor using the set of UserRights.
ProtectionDescriptor protectionDescriptor = new ProtectionDescriptor(userRightsList);
// Apply protection to the file using the new ProtectionDescriptor.
handler.SetProtection(protectionDescriptor, new ProtectionSettings());
// Set the label. This will now succeed as protection has been defined.
handler.SetLabel(engine.GetLabelById(options.LabelId), labelingOptions, new ProtectionSettings());
// Commit the change.
var result = Task.Run(async () => await handler.CommitAsync("myFileOutput.xlsx")).Result;
}
Protection personnalisée
Ce processus peut également être utilisé pour définir uniquement la protection en définissant la protection et en ignorant l’étape SetLabel(). Si votre application n’a pas besoin d’appliquer une étiquette, le gestionnaire d’exceptions n’est pas requis et la protection peut être définie en suivant le modèle ProtectionDescriptor ->SetProtection() ->CommitAsync().