MutexSecurity Classe

Définition

public ref class MutexSecurity sealed : System::Security::AccessControl::NativeObjectSecurity

public sealed class MutexSecurity : System.Security.AccessControl.NativeObjectSecurity

[System.Security.SecurityCritical]
public sealed class MutexSecurity : System.Security.AccessControl.NativeObjectSecurity

type MutexSecurity = class
    inherit NativeObjectSecurity

[<System.Security.SecurityCritical>]
type MutexSecurity = class
    inherit NativeObjectSecurity

Public NotInheritable Class MutexSecurity
Inherits NativeObjectSecurity

Héritage

Object

ObjectSecurity

CommonObjectSecurity

NativeObjectSecurity

MutexSecurity

Attributs

SecurityCriticalAttribute

Exemples

L’exemple de code suivant illustre la séparation entre Allow les règles et Deny les règles, et montre la combinaison de droits dans des règles compatibles. L’exemple crée un MutexSecurity objet, ajoute des règles qui autorisent et refusent divers droits pour l’utilisateur actuel et affichent la paire de règles résultante. L’exemple autorise ensuite de nouveaux droits pour l’utilisateur actuel et affiche le résultat, montrant que les nouveaux droits sont fusionnés avec la règle existante Allow .

using System;
using System.Threading;
using System.Security.AccessControl;
using System.Security.Principal;

public class Example
{
    public static void Main()
    {
        // Create a string representing the current user.
        string user = Environment.UserDomainName + "\\" + 
            Environment.UserName;

        // Create a security object that grants no access.
        MutexSecurity mSec = new MutexSecurity();

        // Add a rule that grants the current user the 
        // right to enter or release the mutex.
        MutexAccessRule rule = new MutexAccessRule(user, 
            MutexRights.Synchronize | MutexRights.Modify, 
            AccessControlType.Allow);
        mSec.AddAccessRule(rule);

        // Add a rule that denies the current user the 
        // right to change permissions on the mutex.
        rule = new MutexAccessRule(user, 
            MutexRights.ChangePermissions, 
            AccessControlType.Deny);
        mSec.AddAccessRule(rule);

        // Display the rules in the security object.
        ShowSecurity(mSec);

        // Add a rule that allows the current user the 
        // right to read permissions on the mutex. This rule
        // is merged with the existing Allow rule.
        rule = new MutexAccessRule(user, 
            MutexRights.ReadPermissions, 
            AccessControlType.Allow);
        mSec.AddAccessRule(rule);

        ShowSecurity(mSec);
    }

    private static void ShowSecurity(MutexSecurity security)
    {
        Console.WriteLine("\r\nCurrent access rules:\r\n");

        foreach(MutexAccessRule ar in 
            security.GetAccessRules(true, true, typeof(NTAccount)))
        {
            Console.WriteLine("        User: {0}", ar.IdentityReference);
            Console.WriteLine("        Type: {0}", ar.AccessControlType);
            Console.WriteLine("      Rights: {0}", ar.MutexRights);
            Console.WriteLine();
        }
    }
}

/*This code example produces output similar to following:

Current access rules:

        User: TestDomain\TestUser
        Type: Deny
      Rights: ChangePermissions

        User: TestDomain\TestUser
        Type: Allow
      Rights: Modify, Synchronize


Current access rules:

        User: TestDomain\TestUser
        Type: Deny
      Rights: ChangePermissions

        User: TestDomain\TestUser
        Type: Allow
      Rights: Modify, ReadPermissions, Synchronize
 */

Imports System.Threading
Imports System.Security.AccessControl
Imports System.Security.Principal

Public Class Example

    Public Shared Sub Main()

        ' Create a string representing the current user.
        Dim user As String = Environment.UserDomainName _ 
            & "\" & Environment.UserName

        ' Create a security object that grants no access.
        Dim mSec As New MutexSecurity()

        ' Add a rule that grants the current user the 
        ' right to enter or release the mutex.
        Dim rule As New MutexAccessRule(user, _
            MutexRights.Synchronize _
            Or MutexRights.Modify, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ' Add a rule that denies the current user the 
        ' right to change permissions on the mutex.
        rule = New MutexAccessRule(user, _
            MutexRights.ChangePermissions, _
            AccessControlType.Deny)
        mSec.AddAccessRule(rule)

        ' Display the rules in the security object.
        ShowSecurity(mSec)

        ' Add a rule that allows the current user the 
        ' right to read permissions on the mutex. This rule
        ' is merged with the existing Allow rule.
        rule = New MutexAccessRule(user, _
            MutexRights.ReadPermissions, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ShowSecurity(mSec)

    End Sub 

    Private Shared Sub ShowSecurity(ByVal security As MutexSecurity)
        Console.WriteLine(vbCrLf & "Current access rules:" & vbCrLf)

        For Each ar As MutexAccessRule In _
            security.GetAccessRules(True, True, GetType(NTAccount))

            Console.WriteLine("        User: {0}", ar.IdentityReference)
            Console.WriteLine("        Type: {0}", ar.AccessControlType)
            Console.WriteLine("      Rights: {0}", ar.MutexRights)
            Console.WriteLine()
        Next

    End Sub
End Class 

'This code example produces output similar to following:
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Deny
'      Rights: ChangePermissions
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: Modify, Synchronize
'
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Deny
'      Rights: ChangePermissions
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: Modify, ReadPermissions, Synchronize

Remarques

Un MutexSecurity objet spécifie les droits d’accès pour un mutex système nommé et spécifie également la façon dont les tentatives d’accès sont auditées. Les droits d’accès au mutex sont exprimés en tant que règles, avec chaque règle d’accès représentée par un MutexAccessRule objet. Chaque règle d’audit est représentée par un MutexAuditRule objet.

Cela reflète le système de sécurité Windows sous-jacent, dans lequel chaque objet sécurisable possède au plus une liste de contrôle d’accès discrétionnaire (DACL) qui contrôle l’accès à l’objet sécurisé, et au plus une liste de contrôle d’accès système (SACL) qui spécifie les tentatives d’accès auditées. Les listes DACL et SACL sont classées des listes d’entrées de contrôle d’accès (ACE) qui spécifient l’accès et l’audit pour les utilisateurs et les groupes. Un MutexAccessRule ou MutexAuditRule objet peut représenter plusieurs ACE.

Les MutexSecurityclasses et MutexAuditRule les MutexAccessRulelistes de contrôle d’accès masquent les détails de l’implémentation des listes de contrôle d’accès et des ACL. Ils vous permettent d’ignorer les dix-sept types ACE différents et la complexité de maintenir correctement l’héritage et la propagation des droits d’accès. Ces objets sont également conçus pour empêcher les erreurs de contrôle d’accès courantes suivantes :

• Création d’un descripteur de sécurité avec un DACL null. Une référence Null à une liste de contrôle d’accès permet à tout utilisateur d’ajouter des règles d’accès à un objet, ce qui peut créer une attaque par déni de service. Un nouvel MutexSecurity objet commence toujours par un DACL vide, qui refuse tout accès pour tous les utilisateurs.

• Violation de l’ordre canonique des ACEs. Si la liste ACE dans la liste DACL n’est pas conservée dans l’ordre canonique, les utilisateurs peuvent avoir accès par inadvertance à l’objet sécurisé. Par exemple, les droits d’accès refusés doivent toujours apparaître avant les droits d’accès autorisés. MutexSecurity les objets conservent l’ordre approprié en interne.

• Manipulation des indicateurs de descripteur de sécurité, qui doivent être sous contrôle Resource Manager uniquement.

• Création de combinaisons non valides d’indicateurs ACE.

• Manipulation des AE héritées. L’héritage et la propagation sont gérés par le gestionnaire de ressources, en réponse aux modifications apportées aux règles d’accès et d’audit.

• Insertion d’ACL sans signification dans les listes de contrôle d’accès.

Les seules fonctionnalités non prises en charge par les objets de sécurité .NET sont des activités dangereuses qui doivent être évitées par la majorité des développeurs d’applications, telles que les suivantes :

• Les tâches de bas niveau qui sont normalement effectuées par le gestionnaire de ressources.

• Ajout ou suppression d’entrées de contrôle d’accès de manière à ne pas conserver l’ordre canonique.

Pour modifier Windows sécurité du contrôle d’accès pour un mutex nommé, utilisez la Mutex.GetAccessControl méthode pour obtenir l’objetMutexSecurity. Modifiez l’objet de sécurité en ajoutant et supprimant des règles, puis utilisez la Mutex.SetAccessControl méthode pour le détacher.

Pour copier la sécurité du contrôle d’accès d’un mutex vers un autre, utilisez la Mutex.GetAccessControl méthode pour obtenir un MutexSecurity objet représentant les règles d’accès et d’audit pour le premier mutex, puis utilisez la Mutex.SetAccessControl méthode, ou un constructeur qui accepte un MutexSecurity objet, pour affecter ces règles au deuxième mutex.

Les utilisateurs ayant un investissement dans le langage de définition de descripteur de sécurité (SDDL) peuvent utiliser la SetSecurityDescriptorSddlForm méthode pour définir des règles d’accès pour un mutex nommé et la GetSecurityDescriptorSddlForm méthode pour obtenir une chaîne qui représente les règles d’accès au format SDDL. Cela n’est pas recommandé pour le nouveau développement.

Constructeurs

Propriétés

Méthodes

S’applique à

Voir aussi

• MutexAccessRule
• MutexAuditRule
• MutexRights
• GetAccessControl()
• SetAccessControl(MutexSecurity)