diff --git a/src/Common/src/CoreLib/Interop/Windows/Kernel32/Interop.EventWaitHandle.cs b/src/Common/src/CoreLib/Interop/Windows/Kernel32/Interop.EventWaitHandle.cs index dabe8c2dc2bd..c3adfadb53d5 100644 --- a/src/Common/src/CoreLib/Interop/Windows/Kernel32/Interop.EventWaitHandle.cs +++ b/src/Common/src/CoreLib/Interop/Windows/Kernel32/Interop.EventWaitHandle.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +#nullable enable using Microsoft.Win32.SafeHandles; using System; using System.Runtime.InteropServices; @@ -13,16 +14,16 @@ internal static partial class Kernel32 internal const uint CREATE_EVENT_INITIAL_SET = 0x2; internal const uint CREATE_EVENT_MANUAL_RESET = 0x1; - [DllImport(Interop.Libraries.Kernel32, SetLastError = true)] + [DllImport(Libraries.Kernel32, SetLastError = true)] internal static extern bool SetEvent(SafeWaitHandle handle); - [DllImport(Interop.Libraries.Kernel32, SetLastError = true)] + [DllImport(Libraries.Kernel32, SetLastError = true)] internal static extern bool ResetEvent(SafeWaitHandle handle); - [DllImport(Interop.Libraries.Kernel32, EntryPoint = "CreateEventExW", SetLastError = true, CharSet = CharSet.Unicode)] + [DllImport(Libraries.Kernel32, EntryPoint = "CreateEventExW", SetLastError = true, CharSet = CharSet.Unicode)] internal static extern SafeWaitHandle CreateEventEx(IntPtr lpSecurityAttributes, string? name, uint flags, uint desiredAccess); - [DllImport(Interop.Libraries.Kernel32, EntryPoint = "OpenEventW", SetLastError = true, CharSet = CharSet.Unicode)] + [DllImport(Libraries.Kernel32, EntryPoint = "OpenEventW", SetLastError = true, CharSet = CharSet.Unicode)] internal static extern SafeWaitHandle OpenEvent(uint desiredAccess, bool inheritHandle, string name); } } diff --git a/src/System.Threading.AccessControl/ref/System.Threading.AccessControl.cs b/src/System.Threading.AccessControl/ref/System.Threading.AccessControl.cs index 0298eb449501..a4b5d31fb177 100644 --- a/src/System.Threading.AccessControl/ref/System.Threading.AccessControl.cs +++ b/src/System.Threading.AccessControl/ref/System.Threading.AccessControl.cs @@ -147,6 +147,10 @@ public static void SetAccessControl(this System.Threading.EventWaitHandle handle public static void SetAccessControl(this System.Threading.Mutex mutex, System.Security.AccessControl.MutexSecurity mutexSecurity) { } public static void SetAccessControl(this System.Threading.Semaphore semaphore, System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity) { } } + public static class EventWaitHandleAcl + { + public static System.Threading.EventWaitHandle Create(bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew, System.Security.AccessControl.EventWaitHandleSecurity eventSecurity) { throw null; } + } public static class MutexAcl { public static System.Threading.Mutex Create(bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity) { throw null; } diff --git a/src/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj b/src/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj index 23200dd3920c..44aa39c63825 100644 --- a/src/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj +++ b/src/System.Threading.AccessControl/src/System.Threading.AccessControl.csproj @@ -13,6 +13,7 @@ + @@ -22,6 +23,7 @@ + @@ -29,6 +31,7 @@ + diff --git a/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.cs b/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.cs new file mode 100644 index 000000000000..f6a15ff7576d --- /dev/null +++ b/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.cs @@ -0,0 +1,88 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.IO; +using System.Runtime.InteropServices; +using System.Security.AccessControl; +using Microsoft.Win32.SafeHandles; + +namespace System.Threading +{ + public static class EventWaitHandleAcl + { + /// Gets or creates an instance, allowing a instance to be optionally specified to set it during the event creation. + /// to set the initial state to signaled if the named event is created as a result of this call; to set it to non-signaled. + /// One of the enum values that determines whether the event resets automatically or manually. + /// The name, if the event is a system-wide synchronization event; otherwise, or an empty string. + /// When this method returns, this argument is always set to if a local event is created; that is, when is or . If has a valid, non-empty value, this argument is set to when the system event is created, or it is set to if an existing system event is found with that name. This parameter is passed uninitialized. + /// The optional Windows access control security to apply. + /// An object that represents a system event wait handle, if named, or a local event wait handle, if nameless. + /// .NET Framework only: The length is beyond MAX_PATH (260 characters). + /// The enum value was out of legal range. + /// Could not find a part of the path specified in . + /// A system-wide synchronization event with the provided was not found. + /// -or- + /// An with system-wide name cannot be created. An of a different type might have the same name. + /// If a `name` is passed and the system event already exists, the existing event is returned. If `name` is `null` or , a new local event is always created. + public static unsafe EventWaitHandle Create(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) + { + if (eventSecurity == null) + { + return new EventWaitHandle(initialState, mode, name, out createdNew); + } + + if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset) + { + throw new ArgumentOutOfRangeException(nameof(mode)); + } + + uint eventFlags = initialState ? Interop.Kernel32.CREATE_EVENT_INITIAL_SET : 0; + if (mode == EventResetMode.ManualReset) + { + eventFlags |= Interop.Kernel32.CREATE_EVENT_MANUAL_RESET; + } + + fixed (byte* pSecurityDescriptor = eventSecurity.GetSecurityDescriptorBinaryForm()) + { + var secAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES + { + nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES), + lpSecurityDescriptor = (IntPtr)pSecurityDescriptor + }; + + SafeWaitHandle handle = Interop.Kernel32.CreateEventEx( + (IntPtr)(&secAttrs), + name, + eventFlags, + (uint)EventWaitHandleRights.FullControl); + + ValidateHandle(handle, name, out createdNew); + + EventWaitHandle ewh = new EventWaitHandle(initialState, mode); + SafeWaitHandle old = ewh.SafeWaitHandle; + ewh.SafeWaitHandle = handle; + old.Dispose(); + + return ewh; + } + } + + private static void ValidateHandle(SafeWaitHandle handle, string name, out bool createdNew) + { + int errorCode = Marshal.GetLastWin32Error(); + + if (handle.IsInvalid) + { + handle.SetHandleAsInvalid(); + + if (!string.IsNullOrEmpty(name) && errorCode == Interop.Errors.ERROR_INVALID_HANDLE) + throw new WaitHandleCannotBeOpenedException(SR.Format(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name)); + + throw Win32Marshal.GetExceptionForWin32Error(errorCode, name); + } + + createdNew = (errorCode != Interop.Errors.ERROR_ALREADY_EXISTS); + } + } +} diff --git a/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.net46.cs b/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.net46.cs new file mode 100644 index 000000000000..2b8e65d72448 --- /dev/null +++ b/src/System.Threading.AccessControl/src/System/Threading/EventWaitHandleAcl.net46.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Security.AccessControl; + +namespace System.Threading +{ + public static class EventWaitHandleAcl + { + public static EventWaitHandle Create( + bool initialState, + EventResetMode mode, + string name, + out bool createdNew, + EventWaitHandleSecurity eventSecurity) + { + return new EventWaitHandle(initialState, mode, name, out createdNew, eventSecurity); + } + } +} diff --git a/src/System.Threading.AccessControl/tests/EventWaitHandleAclTests.cs b/src/System.Threading.AccessControl/tests/EventWaitHandleAclTests.cs new file mode 100644 index 000000000000..ca02c306cff2 --- /dev/null +++ b/src/System.Threading.AccessControl/tests/EventWaitHandleAclTests.cs @@ -0,0 +1,247 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.AccessControl; +using System.Security.Principal; +using Xunit; + +namespace System.Threading.Tests +{ + public class EventWaitHandleAclTests : AclTests + { + [Fact] + public void EventWaitHandle_Create_NullSecurity() + { + CreateAndVerifyEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + name: GetRandomName(), + expectedSecurity: null, + expectedCreatedNew: true).Dispose(); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + public void EventWaitHandle_Create_NameMultipleNew(string name) + { + EventWaitHandleSecurity security = GetBasicEventWaitHandleSecurity(); + + using EventWaitHandle handle1 = CreateAndVerifyEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + name, + security, + expectedCreatedNew: true); + + using EventWaitHandle handle2 = CreateAndVerifyEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + name, + security, + expectedCreatedNew: true); + } + + [Fact] + public void EventWaitHandle_Create_CreateNewExisting() + { + string name = GetRandomName(); + EventWaitHandleSecurity security = GetBasicEventWaitHandleSecurity(); + + using EventWaitHandle handle1 = CreateAndVerifyEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + name, + security, + expectedCreatedNew: true); + + using EventWaitHandle handle2 = CreateAndVerifyEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + name, + security, + expectedCreatedNew: false); + } + + [Fact] + public void EventWaitHandle_Create_GlobalPrefixNameNotFound() + { + string prefixedName = @"GLOBAL\" + GetRandomName(); + + Assert.Throws(() => + { + CreateEventWaitHandle( + initialState: true, + mode: EventResetMode.AutoReset, + prefixedName, + expectedSecurity: GetBasicEventWaitHandleSecurity(), + expectedCreatedNew: true).Dispose(); + }); + } + + // The documentation says MAX_PATH is the length limit for name, but it won't throw any errors: + // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-createeventexw + // The .NET Core constructors for EventWaitHandle do not throw on name longer than MAX_LENGTH, so the extension method should match the behavior: + // https://source.dot.net/#System.Private.CoreLib/shared/System/Threading/EventWaitHandle.Windows.cs,20 + // The .NET Framework constructor throws: + // https://referencesource.microsoft.com/#mscorlib/system/threading/eventwaithandle.cs,59 + [Fact] + public void EventWaitHandle_Create_BeyondMaxPathLength() + { + string name = new string('x', Interop.Kernel32.MAX_PATH + 100); + EventWaitHandleSecurity security = GetBasicEventWaitHandleSecurity(); + EventResetMode mode = EventResetMode.AutoReset; + + if (PlatformDetection.IsFullFramework) + { + Assert.Throws(() => + { + CreateEventWaitHandle( + initialState: true, + mode, + name, + security, + expectedCreatedNew: true).Dispose(); + }); + } + else + { + using EventWaitHandle created = CreateAndVerifyEventWaitHandle( + initialState: true, + mode, + name, + security, + expectedCreatedNew: true); + + using EventWaitHandle openedByName = EventWaitHandle.OpenExisting(name); + Assert.NotNull(openedByName); + } + } + + [Theory] + [InlineData((EventResetMode)int.MinValue)] + [InlineData((EventResetMode)(-1))] + [InlineData((EventResetMode)2)] + [InlineData((EventResetMode)int.MaxValue)] + public void EventWaitHandle_Create_InvalidMode(EventResetMode mode) + { + if (PlatformDetection.IsFullFramework) + { + Assert.Throws(() => + { + CreateEventWaitHandle( + initialState: true, + mode, + GetRandomName(), + GetBasicEventWaitHandleSecurity(), + expectedCreatedNew: true).Dispose(); + }); + } + else + { + Assert.Throws("mode", () => + { + CreateEventWaitHandle( + initialState: true, + mode, + GetRandomName(), + GetBasicEventWaitHandleSecurity(), + expectedCreatedNew: true).Dispose(); + }); + } + } + + public static IEnumerable EventWaitHandle_Create_SpecificParameters_MemberData() => + from initialState in new[] { true, false } + from mode in new[] { EventResetMode.AutoReset, EventResetMode.ManualReset } + from rights in new[] { EventWaitHandleRights.FullControl, EventWaitHandleRights.Synchronize, EventWaitHandleRights.Modify, EventWaitHandleRights.Modify | EventWaitHandleRights.Synchronize } + from accessControl in new[] { AccessControlType.Allow, AccessControlType.Deny } + select new object[] { initialState, mode, rights, accessControl }; + + [Theory] + [MemberData(nameof(EventWaitHandle_Create_SpecificParameters_MemberData))] + public void EventWaitHandle_Create_SpecificParameters(bool initialState, EventResetMode mode, EventWaitHandleRights rights, AccessControlType accessControl) + { + EventWaitHandleSecurity security = GetEventWaitHandleSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); + CreateAndVerifyEventWaitHandle( + initialState, + mode, + GetRandomName(), + security, + expectedCreatedNew: true).Dispose(); + + } + + private EventWaitHandleSecurity GetBasicEventWaitHandleSecurity() + { + return GetEventWaitHandleSecurity( + WellKnownSidType.BuiltinUsersSid, + EventWaitHandleRights.FullControl, + AccessControlType.Allow); + } + + private EventWaitHandleSecurity GetEventWaitHandleSecurity(WellKnownSidType sid, EventWaitHandleRights rights, AccessControlType accessControl) + { + EventWaitHandleSecurity security = new EventWaitHandleSecurity(); + SecurityIdentifier identity = new SecurityIdentifier(sid, null); + EventWaitHandleAccessRule accessRule = new EventWaitHandleAccessRule(identity, rights, accessControl); + security.AddAccessRule(accessRule); + return security; + } + private EventWaitHandle CreateEventWaitHandle(bool initialState, EventResetMode mode, string name, EventWaitHandleSecurity expectedSecurity, bool expectedCreatedNew) + { + EventWaitHandle handle = EventWaitHandleAcl.Create(initialState, mode, name, out bool createdNew, expectedSecurity); + Assert.NotNull(handle); + Assert.Equal(expectedCreatedNew, createdNew); + return handle; + } + + private EventWaitHandle CreateAndVerifyEventWaitHandle(bool initialState, EventResetMode mode, string name, EventWaitHandleSecurity expectedSecurity, bool expectedCreatedNew) + { + EventWaitHandle eventHandle = CreateEventWaitHandle(initialState, mode, name, expectedSecurity, expectedCreatedNew); + + if (expectedSecurity != null) + { + EventWaitHandleSecurity actualSecurity = eventHandle.GetAccessControl(); + VerifyEventWaitHandleSecurity(expectedSecurity, actualSecurity); + } + + return eventHandle; + } + + private void VerifyEventWaitHandleSecurity(EventWaitHandleSecurity expectedSecurity, EventWaitHandleSecurity actualSecurity) + { + Assert.Equal(typeof(EventWaitHandleRights), expectedSecurity.AccessRightType); + Assert.Equal(typeof(EventWaitHandleRights), actualSecurity.AccessRightType); + + List expectedAccessRules = expectedSecurity.GetAccessRules(includeExplicit: true, includeInherited: false, typeof(SecurityIdentifier)) + .Cast().ToList(); + + List actualAccessRules = actualSecurity.GetAccessRules(includeExplicit: true, includeInherited: false, typeof(SecurityIdentifier)) + .Cast().ToList(); + + Assert.Equal(expectedAccessRules.Count, actualAccessRules.Count); + if (expectedAccessRules.Count > 0) + { + Assert.All(expectedAccessRules, actualAccessRule => + { + int count = expectedAccessRules.Count(expectedAccessRule => AreAccessRulesEqual(expectedAccessRule, actualAccessRule)); + Assert.True(count > 0); + }); + } + } + + private bool AreAccessRulesEqual(EventWaitHandleAccessRule expectedRule, EventWaitHandleAccessRule actualRule) + { + return + expectedRule.AccessControlType == actualRule.AccessControlType && + expectedRule.EventWaitHandleRights == actualRule.EventWaitHandleRights && + expectedRule.InheritanceFlags == actualRule.InheritanceFlags && + expectedRule.PropagationFlags == actualRule.PropagationFlags; + } + } +} diff --git a/src/System.Threading.AccessControl/tests/MutexAclTests.cs b/src/System.Threading.AccessControl/tests/MutexAclTests.cs index f51f09e04e6a..2b5bf0047442 100644 --- a/src/System.Threading.AccessControl/tests/MutexAclTests.cs +++ b/src/System.Threading.AccessControl/tests/MutexAclTests.cs @@ -23,7 +23,7 @@ public void Mutex_Create_NullSecurity() [InlineData("")] public void Mutex_Create_NameMultipleNew(string name) { - var security = GetBasicMutexSecurity(); + MutexSecurity security = GetBasicMutexSecurity(); using Mutex mutex1 = CreateAndVerifyMutex(initiallyOwned: true, name, security, expectedCreatedNew: true); using Mutex mutex2 = CreateAndVerifyMutex(initiallyOwned: true, name, security, expectedCreatedNew: true); @@ -33,7 +33,7 @@ public void Mutex_Create_NameMultipleNew(string name) public void Mutex_Create_CreateNewExisting() { string name = GetRandomName(); - var security = GetBasicMutexSecurity(); + MutexSecurity security = GetBasicMutexSecurity(); using Mutex mutexNew = CreateAndVerifyMutex(initiallyOwned: true, name, security, expectedCreatedNew: true); using Mutex mutexExisting = CreateAndVerifyMutex(initiallyOwned: true, name, security, expectedCreatedNew: false); @@ -76,7 +76,7 @@ public void Mutex_Create_BeyondMaxPathLength() [InlineData(false, MutexRights.Modify, AccessControlType.Deny)] public void Mutex_Create_SpecificParameters(bool initiallyOwned, MutexRights rights, AccessControlType accessControl) { - var security = GetMutexSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); + MutexSecurity security = GetMutexSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); CreateAndVerifyMutex(initiallyOwned, GetRandomName(), security, expectedCreatedNew: true).Dispose(); } @@ -91,9 +91,9 @@ private MutexSecurity GetBasicMutexSecurity() private MutexSecurity GetMutexSecurity(WellKnownSidType sid, MutexRights rights, AccessControlType accessControl) { - var security = new MutexSecurity(); + MutexSecurity security = new MutexSecurity(); SecurityIdentifier identity = new SecurityIdentifier(sid, null); - var accessRule = new MutexAccessRule(identity, rights, accessControl); + MutexAccessRule accessRule = new MutexAccessRule(identity, rights, accessControl); security.AddAccessRule(accessRule); return security; } diff --git a/src/System.Threading.AccessControl/tests/SemaphoreAclTests.cs b/src/System.Threading.AccessControl/tests/SemaphoreAclTests.cs index 028cc316077e..970217fb8d34 100644 --- a/src/System.Threading.AccessControl/tests/SemaphoreAclTests.cs +++ b/src/System.Threading.AccessControl/tests/SemaphoreAclTests.cs @@ -48,7 +48,7 @@ public void Semaphore_Create_InvalidCounts(int initialCount, int maximumCount) [InlineData("")] public void Semaphore_Create_NameMultipleNew(string name) { - var security = GetBasicSemaphoreSecurity(); + SemaphoreSecurity security = GetBasicSemaphoreSecurity(); bool expectedCreatedNew = true; using Semaphore semaphore1 = CreateAndVerifySemaphore( @@ -70,7 +70,7 @@ public void Semaphore_Create_NameMultipleNew(string name) public void Semaphore_Create_CreateNewExisting() { string name = GetRandomName(); - var security = GetBasicSemaphoreSecurity(); + SemaphoreSecurity security = GetBasicSemaphoreSecurity(); using Semaphore SemaphoreNew = CreateAndVerifySemaphore( DefaultInitialCount, @@ -129,7 +129,7 @@ public void Semaphore_Create_BeyondMaxPathLength() [InlineData(SemaphoreRights.Modify | SemaphoreRights.Synchronize, AccessControlType.Deny)] public void Semaphore_Create_SpecificSecurity(SemaphoreRights rights, AccessControlType accessControl) { - var security = GetSemaphoreSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); + SemaphoreSecurity security = GetSemaphoreSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl); CreateAndVerifySemaphore( DefaultInitialCount, @@ -150,9 +150,9 @@ private SemaphoreSecurity GetBasicSemaphoreSecurity() private SemaphoreSecurity GetSemaphoreSecurity(WellKnownSidType sid, SemaphoreRights rights, AccessControlType accessControl) { - var security = new SemaphoreSecurity(); + SemaphoreSecurity security = new SemaphoreSecurity(); SecurityIdentifier identity = new SecurityIdentifier(sid, null); - var accessRule = new SemaphoreAccessRule(identity, rights, accessControl); + SemaphoreAccessRule accessRule = new SemaphoreAccessRule(identity, rights, accessControl); security.AddAccessRule(accessRule); return security; } diff --git a/src/System.Threading.AccessControl/tests/System.Threading.AccessControl.Tests.csproj b/src/System.Threading.AccessControl/tests/System.Threading.AccessControl.Tests.csproj index 478d1d8db82e..3974171d2b43 100644 --- a/src/System.Threading.AccessControl/tests/System.Threading.AccessControl.Tests.csproj +++ b/src/System.Threading.AccessControl/tests/System.Threading.AccessControl.Tests.csproj @@ -6,6 +6,7 @@ +