EventWaitHandleSecurity Clase

Definición

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

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

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

type EventWaitHandleSecurity = class
    inherit NativeObjectSecurity

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

Public NotInheritable Class EventWaitHandleSecurity
Inherits NativeObjectSecurity

Herencia

Object

ObjectSecurity

CommonObjectSecurity

NativeObjectSecurity

EventWaitHandleSecurity

Atributos

SecurityCriticalAttribute

Ejemplos

En el ejemplo de código siguiente se muestra la separación entre Allow reglas y Deny reglas y se muestra la combinación de derechos en reglas compatibles. En el ejemplo se crea un EventWaitHandleSecurity objeto , se agregan reglas que permiten y deniegan varios derechos para el usuario actual y se muestra el par resultante de reglas. A continuación, el ejemplo permite nuevos derechos para el usuario actual y muestra el resultado, lo que muestra que los nuevos derechos se combinan con la regla existente 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.
        EventWaitHandleSecurity mSec = new EventWaitHandleSecurity();

        // Add a rule that grants the current user the 
        // right to wait on or signal the event.
        EventWaitHandleAccessRule rule = new EventWaitHandleAccessRule(user, 
            EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify, 
            AccessControlType.Allow);
        mSec.AddAccessRule(rule);

        // Add a rule that denies the current user the 
        // right to change permissions on the event.
        rule = new EventWaitHandleAccessRule(user, 
            EventWaitHandleRights.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 event. This rule
        // is merged with the existing Allow rule.
        rule = new EventWaitHandleAccessRule(user, 
            EventWaitHandleRights.ReadPermissions, 
            AccessControlType.Allow);
        mSec.AddAccessRule(rule);

        ShowSecurity(mSec);
    }

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

        foreach(EventWaitHandleAccessRule 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.EventWaitHandleRights);
            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 EventWaitHandleSecurity()

        ' Add a rule that grants the current user the 
        ' right to wait on or signal the event.
        Dim rule As New EventWaitHandleAccessRule(user, _
            EventWaitHandleRights.Synchronize _
            Or EventWaitHandleRights.Modify, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ' Add a rule that denies the current user the 
        ' right to change permissions on the event.
        rule = New EventWaitHandleAccessRule(user, _
            EventWaitHandleRights.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 event. This rule
        ' is merged with the existing Allow rule.
        rule = New EventWaitHandleAccessRule(user, _
            EventWaitHandleRights.ReadPermissions, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ShowSecurity(mSec)

    End Sub 

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

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

            Console.WriteLine("        User: {0}", ar.IdentityReference)
            Console.WriteLine("        Type: {0}", ar.AccessControlType)
            Console.WriteLine("      Rights: {0}", ar.EventWaitHandleRights)
            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

Comentarios

Un EventWaitHandleSecurity objeto especifica los derechos de acceso de un identificador de espera del sistema con nombre y también especifica la forma en que se auditan los intentos de acceso. Los derechos de acceso al identificador de espera se expresan como reglas, con cada regla de acceso representada por un EventWaitHandleAccessRule objeto . Cada regla de auditoría se representa mediante un EventWaitHandleAuditRule objeto .

Esto refleja el sistema de seguridad subyacente de Windows, en el que cada objeto protegible tiene como máximo una lista de control de acceso discrecional (DACL) que controla el acceso al objeto protegido y, como máximo, una lista de control de acceso del sistema (SACL) que especifica qué intentos de acceso se auditan. DaCL y SACL son listas ordenadas de entradas de control de acceso (ACE) que especifican el acceso y la auditoría para usuarios y grupos. Un EventWaitHandleAccessRule objeto o EventWaitHandleAuditRule puede representar más de una ACE.

Las EventWaitHandleSecurityclases , EventWaitHandleAccessRuley EventWaitHandleAuditRule ocultan los detalles de implementación de ACL y ACL. Permiten omitir los diecisiete tipos ace diferentes y la complejidad de mantener correctamente la herencia y propagación de los derechos de acceso. Estos objetos también están diseñados para evitar los siguientes errores comunes de control de acceso:

• Creación de un descriptor de seguridad con una DACL nula. Una referencia nula a una DACL permite a cualquier usuario agregar reglas de acceso a un objeto, lo que podría crear un ataque por denegación de servicio. Un nuevo EventWaitHandleSecurity objeto siempre comienza con una DACL vacía, que deniega todo el acceso a todos los usuarios.

• Infringiendo la ordenación canónica de los ACE. Si la lista ACE de la DACL no se mantiene en el orden canónico, es posible que a los usuarios se les dé acceso accidentalmente al objeto protegido. Por ejemplo, los derechos de acceso denegados siempre deben aparecer antes de los derechos de acceso permitidos. EventWaitHandleSecurity los objetos mantienen el orden correcto internamente.

• Manipular marcas de descriptor de seguridad, que solo deben estar bajo control de Resource Manager.

• Crear combinaciones no válidas de marcas ACE.

• Manipular ACE heredadas. El administrador de recursos controla la herencia y la propagación, en respuesta a los cambios realizados en las reglas de acceso y auditoría.

• Inserción de ACL sin significado en ACL.

Las únicas funcionalidades no admitidas por los objetos de seguridad de .NET son actividades peligrosas que deben evitar la mayoría de los desarrolladores de aplicaciones, como las siguientes:

• Tareas de bajo nivel que normalmente realizan el administrador de recursos.

• Agregar o quitar entradas de control de acceso de maneras que no mantienen el orden canónico.

Para modificar la seguridad del control de acceso de Windows para un identificador de espera con nombre, use el EventWaitHandle.GetAccessControl método para obtener el EventWaitHandleSecurity objeto . Modifique el objeto de seguridad agregando y quitando reglas y, a continuación, use el EventWaitHandle.SetAccessControl método para volver a adjuntarlo.

Para copiar la seguridad de control de acceso de un identificador de espera a otro, use el EventWaitHandle.GetAccessControl método para obtener un EventWaitHandleSecurity objeto que represente las reglas de acceso y auditoría para el primer identificador de espera y, a continuación, use el EventWaitHandle.SetAccessControl método , o un constructor que acepte un EventWaitHandleSecurity objeto, para asignar esas reglas al segundo identificador de espera.

Los usuarios con una inversión en el lenguaje de definición de descriptor de seguridad (SDDL) pueden usar el SetSecurityDescriptorSddlForm método para establecer reglas de acceso para un identificador de espera con nombre y el GetSecurityDescriptorSddlForm método para obtener una cadena que represente las reglas de acceso en formato SDDL. Esto no se recomienda para el nuevo desarrollo.

Constructores

Propiedades

Métodos

Se aplica a

Consulte también

• EventWaitHandleAccessRule
• EventWaitHandleAuditRule
• EventWaitHandleRights
• GetAccessControl()
• SetAccessControl(EventWaitHandleSecurity)