public void PermissionsActuallyWork() { if (PlatformID.Win32NT != Environment.OSVersion.Platform) { Assert.Ignore(); } bool createdNew; EventWaitHandleSecurity security; string name = @"Local\MonoTestWaitHandle"; using (EventWaitHandle handle = new EventWaitHandle(false, EventResetMode.ManualReset, name, out createdNew)) { Assert.IsFalse(handle.SafeWaitHandle.IsInvalid); Assert.IsTrue(createdNew); // Make sure our later error will be due to permissions and not some sharing bug. bool createdAnotherNew; using (EventWaitHandle anotherHandle = new EventWaitHandle(false, EventResetMode.ManualReset, name, out createdAnotherNew)) { Assert.IsFalse(anotherHandle.SafeWaitHandle.IsInvalid); Assert.IsFalse(createdAnotherNew); } // Let's make a deny all. security = handle.GetAccessControl(); foreach (EventWaitHandleAccessRule rule in security.GetAccessRules (true, false, typeof(SecurityIdentifier))) { security.RemoveAccessRuleSpecific(rule); } Assert.AreEqual(0, security.GetAccessRules(true, false, typeof(SecurityIdentifier)).Count); handle.SetAccessControl(security); security = handle.GetAccessControl(); Assert.AreEqual(0, security.GetAccessRules(true, false, typeof(SecurityIdentifier)).Count); // MS.NET will throw on the first line below. // For Mono testing the latter verifies the rest until the EventWaitHandle bug is fixed. // Also, NUnit 2.4 appears to lacks Assert.Pass (). EventWaitHandle badHandle = new EventWaitHandle(false, EventResetMode.ManualReset, name); if (badHandle.SafeWaitHandle.IsInvalid) { throw new UnauthorizedAccessException(); } } }
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); }
public void EventWaitHandle_OpenExisting() { string name = GetRandomName(); EventWaitHandleSecurity expectedSecurity = GetEventWaitHandleSecurity(WellKnownSidType.BuiltinUsersSid, EventWaitHandleRights.FullControl, AccessControlType.Allow); using EventWaitHandle EventWaitHandleNew = CreateAndVerifyEventWaitHandle(initialState: true, EventResetMode.AutoReset, name, expectedSecurity, expectedCreatedNew: true); using EventWaitHandle EventWaitHandleExisting = EventWaitHandleAcl.OpenExisting(name, EventWaitHandleRights.FullControl); VerifyHandles(EventWaitHandleNew, EventWaitHandleExisting); EventWaitHandleSecurity actualSecurity = EventWaitHandleExisting.GetAccessControl(); VerifyEventWaitHandleSecurity(expectedSecurity, actualSecurity); }
public PipeServer(string eventName, string pipeName, Func <uint, byte[], Tuple <ErrCode, byte[], uint> > cmdProc) { var eventConnect = new EventWaitHandle(false, EventResetMode.AutoReset, eventName); string trustee = "NT Service\\EpgTimer Service"; try { // "EpgTimer Service"のサービスセキュリティ識別子(Service-specific SID)に対するアクセス許可を追加する EventWaitHandleSecurity sec = eventConnect.GetAccessControl(); sec.AddAccessRule(new EventWaitHandleAccessRule(trustee, EventWaitHandleRights.Synchronize, AccessControlType.Allow)); eventConnect.SetAccessControl(sec); } catch { trustee = null; } var pipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, null, System.IO.HandleInheritability.None, trustee == null ? 0 : PipeAccessRights.ChangePermissions); if (trustee != null) { try { PipeSecurity sec = pipe.GetAccessControl(); sec.AddAccessRule(new PipeAccessRule(trustee, PipeAccessRights.ReadWrite, AccessControlType.Allow)); pipe.SetAccessControl(sec); } catch { } } m_ServerThread = new Thread(new ThreadStart(() => { using (eventConnect) using (pipe) { for (;;) { IAsyncResult ar = pipe.BeginWaitForConnection(null, null); eventConnect.Set(); using (ar.AsyncWaitHandle) { if (WaitHandle.WaitAny(new WaitHandle[] { m_StopEvent, ar.AsyncWaitHandle }) != 1) { pipe.Dispose(); ar.AsyncWaitHandle.WaitOne(); break; } pipe.EndWaitForConnection(ar); } if (pipe.IsConnected) { byte[] bHead = new byte[8]; if (ReadAll(pipe, bHead, 0, 8) == 8) { uint cmdParam = BitConverter.ToUInt32(bHead, 0); byte[] cmdData = new byte[BitConverter.ToUInt32(bHead, 4)]; if (ReadAll(pipe, cmdData, 0, cmdData.Length) == cmdData.Length) { Tuple <ErrCode, byte[], uint> res = cmdProc.Invoke(cmdParam, cmdData); BitConverter.GetBytes((uint)res.Item1).CopyTo(bHead, 0); BitConverter.GetBytes(res.Item2 == null ? 0 : res.Item2.Length).CopyTo(bHead, 4); pipe.Write(bHead, 0, 8); if (res.Item2 != null && res.Item2.Length > 0) { pipe.Write(res.Item2, 0, res.Item2.Length); } } } pipe.WaitForPipeDrain(); pipe.Disconnect(); } } } })); m_ServerThread.Start(); }