internal static bool RestoreTokenPrivilege(string privilegeName, ref Win32Native.TOKEN_PRIVILEGE previousPrivilegeState) { if (previousPrivilegeState.PrivilegeCount != 0) { bool flag = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); if (Win32Native.LookupPrivilegeValue(null, privilegeName, ref tOKENPRIVILEGE.Privilege.Luid) && tOKENPRIVILEGE.Privilege.Luid.HighPart == previousPrivilegeState.Privilege.Luid.HighPart && tOKENPRIVILEGE.Privilege.Luid.LowPart == previousPrivilegeState.Privilege.Luid.LowPart) { IntPtr currentProcess = Win32Native.GetCurrentProcess(); if (currentProcess != IntPtr.Zero) { IntPtr zero = IntPtr.Zero; if (Win32Native.OpenProcessToken(currentProcess, 40, out zero)) { int num = Marshal.SizeOf(typeof(Win32Native.TOKEN_PRIVILEGE)); int num1 = 0; if (Win32Native.AdjustTokenPrivileges(zero, false, ref previousPrivilegeState, num, out tOKENPRIVILEGE, ref num1) && Marshal.GetLastWin32Error() == 0) { flag = true; } } if (zero != IntPtr.Zero) { Win32Native.CloseHandle(zero); } Win32Native.CloseHandle(currentProcess); } } return(flag); } else { return(true); } }
public void Revert() { int num = 0; if (!this.currentThread.Equals(Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (this.NeedToRevert) { RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { bool flag = true; try { if (this.stateWasChanged && ((this.tlsContents.ReferenceCountValue > 1) || !this.tlsContents.IsImpersonating)) { Win32Native.TOKEN_PRIVILEGE newState = new Win32Native.TOKEN_PRIVILEGE { PrivilegeCount = 1 }; newState.Privilege.Luid = this.luid; newState.Privilege.Attributes = this.initialState ? 2 : 0; Win32Native.TOKEN_PRIVILEGE structure = new Win32Native.TOKEN_PRIVILEGE(); uint returnLength = 0; int introduced5 = Marshal.SizeOf(structure); if (!Win32Native.AdjustTokenPrivileges(this.tlsContents.ThreadHandle, false, ref newState, (uint)introduced5, ref structure, ref returnLength)) { num = Marshal.GetLastWin32Error(); flag = false; } } } finally { if (flag) { this.Reset(); } } } switch (num) { case 8: throw new OutOfMemoryException(); case 5: throw new UnauthorizedAccessException(); } if (num != 0) { throw new InvalidOperationException(); } } }
public void Revert() { int num = 0; if (!this.currentThread.Equals(Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (!this.NeedToRevert) { return; } RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { bool flag = true; try { if (this.stateWasChanged && (this.tlsContents.ReferenceCountValue > 1 || !this.tlsContents.IsImpersonating)) { Win32Native.TOKEN_PRIVILEGE token_PRIVILEGE = default(Win32Native.TOKEN_PRIVILEGE); token_PRIVILEGE.PrivilegeCount = 1U; token_PRIVILEGE.Privilege.Luid = this.luid; token_PRIVILEGE.Privilege.Attributes = (this.initialState ? 2U : 0U); Win32Native.TOKEN_PRIVILEGE structure = default(Win32Native.TOKEN_PRIVILEGE); uint num2 = 0U; if (!Win32Native.AdjustTokenPrivileges(this.tlsContents.ThreadHandle, false, ref token_PRIVILEGE, (uint)Marshal.SizeOf <Win32Native.TOKEN_PRIVILEGE>(structure), ref structure, ref num2)) { num = Marshal.GetLastWin32Error(); flag = false; } } } finally { if (flag) { this.Reset(); } } } if (num == 8) { throw new OutOfMemoryException(); } if (num == 5) { throw new UnauthorizedAccessException(); } if (num != 0) { throw new InvalidOperationException(); } }
internal static bool EnableTokenPrivilege(string privilegeName, ref Win32Native.TOKEN_PRIVILEGE oldPrivilegeState) { bool flag = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); if (Win32Native.LookupPrivilegeValue(null, privilegeName, ref tOKENPRIVILEGE.Privilege.Luid)) { IntPtr currentProcess = Win32Native.GetCurrentProcess(); if (currentProcess != IntPtr.Zero) { IntPtr zero = IntPtr.Zero; if (Win32Native.OpenProcessToken(currentProcess, 40, out zero)) { Win32Native.PRIVILEGE_SET luid = new Win32Native.PRIVILEGE_SET(); luid.Privilege.Luid = tOKENPRIVILEGE.Privilege.Luid; luid.PrivilegeCount = 1; luid.Control = 1; bool flag1 = false; if (!Win32Native.PrivilegeCheck(zero, ref luid, out flag1) || !flag1) { tOKENPRIVILEGE.PrivilegeCount = 1; tOKENPRIVILEGE.Privilege.Attributes = 2; int num = Marshal.SizeOf(typeof(Win32Native.TOKEN_PRIVILEGE)); int num1 = 0; if (Win32Native.AdjustTokenPrivileges(zero, false, ref tOKENPRIVILEGE, num, out oldPrivilegeState, ref num1)) { int lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error != 0) { if (lastWin32Error == 0x514) { oldPrivilegeState.PrivilegeCount = 0; flag = true; } } else { flag = true; } } } else { oldPrivilegeState.PrivilegeCount = 0; flag = true; } } if (zero != IntPtr.Zero) { Win32Native.CloseHandle(zero); } Win32Native.CloseHandle(currentProcess); } } return(flag); }
internal static bool EnableTokenPrivilege(string privilegeName, ref Win32Native.TOKEN_PRIVILEGE oldPrivilegeState) { bool flag = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); if (Win32Native.LookupPrivilegeValue(null, privilegeName, ref tOKENPRIVILEGE.Privilege.Luid)) { IntPtr currentProcess = Win32Native.GetCurrentProcess(); if (currentProcess != IntPtr.Zero) { IntPtr zero = IntPtr.Zero; if (Win32Native.OpenProcessToken(currentProcess, 40, out zero)) { Win32Native.PRIVILEGE_SET luid = new Win32Native.PRIVILEGE_SET(); luid.Privilege.Luid = tOKENPRIVILEGE.Privilege.Luid; luid.PrivilegeCount = 1; luid.Control = 1; bool flag1 = false; if (!Win32Native.PrivilegeCheck(zero, ref luid, out flag1) || !flag1) { tOKENPRIVILEGE.PrivilegeCount = 1; tOKENPRIVILEGE.Privilege.Attributes = 2; int num = Marshal.SizeOf(typeof(Win32Native.TOKEN_PRIVILEGE)); int num1 = 0; if (Win32Native.AdjustTokenPrivileges(zero, false, ref tOKENPRIVILEGE, num, out oldPrivilegeState, ref num1)) { int lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error != 0) { if (lastWin32Error == 0x514) { oldPrivilegeState.PrivilegeCount = 0; flag = true; } } else { flag = true; } } } else { oldPrivilegeState.PrivilegeCount = 0; flag = true; } } if (zero != IntPtr.Zero) { Win32Native.CloseHandle(zero); } Win32Native.CloseHandle(currentProcess); } } return flag; }
internal static bool RestoreTokenPrivilege(string privilegeName, ref Win32Native.TOKEN_PRIVILEGE previousPrivilegeState) { if (previousPrivilegeState.PrivilegeCount != 0) { bool flag = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); if (Win32Native.LookupPrivilegeValue(null, privilegeName, ref tOKENPRIVILEGE.Privilege.Luid) && tOKENPRIVILEGE.Privilege.Luid.HighPart == previousPrivilegeState.Privilege.Luid.HighPart && tOKENPRIVILEGE.Privilege.Luid.LowPart == previousPrivilegeState.Privilege.Luid.LowPart) { IntPtr currentProcess = Win32Native.GetCurrentProcess(); if (currentProcess != IntPtr.Zero) { IntPtr zero = IntPtr.Zero; if (Win32Native.OpenProcessToken(currentProcess, 40, out zero)) { int num = Marshal.SizeOf(typeof(Win32Native.TOKEN_PRIVILEGE)); int num1 = 0; if (Win32Native.AdjustTokenPrivileges(zero, false, ref previousPrivilegeState, num, out tOKENPRIVILEGE, ref num1) && Marshal.GetLastWin32Error() == 0) { flag = true; } } if (zero != IntPtr.Zero) { Win32Native.CloseHandle(zero); } Win32Native.CloseHandle(currentProcess); } } return flag; } else { return true; } }
private void ToggleState(bool enable) { int num = 0; if (!this.currentThread.Equals(Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (this.needToRevert) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustRevertPrivilege")); } RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { try { this.tlsContents = Thread.GetData(tlsSlot) as TlsContents; if (this.tlsContents == null) { this.tlsContents = new TlsContents(); Thread.SetData(tlsSlot, this.tlsContents); } else { this.tlsContents.IncrementReferenceCount(); } Win32Native.TOKEN_PRIVILEGE newState = new Win32Native.TOKEN_PRIVILEGE { PrivilegeCount = 1 }; newState.Privilege.Luid = this.luid; newState.Privilege.Attributes = enable ? 2 : 0; Win32Native.TOKEN_PRIVILEGE structure = new Win32Native.TOKEN_PRIVILEGE(); uint returnLength = 0; int introduced4 = Marshal.SizeOf(structure); if (!Win32Native.AdjustTokenPrivileges(this.tlsContents.ThreadHandle, false, ref newState, (uint)introduced4, ref structure, ref returnLength)) { num = Marshal.GetLastWin32Error(); } else if (0x514 == Marshal.GetLastWin32Error()) { num = 0x514; } else { this.initialState = (structure.Privilege.Attributes & 2) != 0; this.stateWasChanged = this.initialState != enable; this.needToRevert = this.tlsContents.IsImpersonating || this.stateWasChanged; } } finally { if (!this.needToRevert) { this.Reset(); } } } switch (num) { case 0x514: throw new PrivilegeNotHeldException(privileges[this.luid] as string); case 8: throw new OutOfMemoryException(); case 5: case 0x543: throw new UnauthorizedAccessException(); } if (num != 0) { throw new InvalidOperationException(); } }
public void Revert() { int error = 0; if (!this.currentThread.Equals(Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (!this.NeedToRevert) { return; } // // This code must be eagerly prepared and non-interruptible. // RuntimeHelpers.PrepareConstrainedRegions(); try { // // The payload is entirely in the finally block // This is how we ensure that the code will not be // interrupted by catastrophic exceptions // } finally { bool success = true; try { // // Only call AdjustTokenPrivileges if we're not going to be reverting to self, // on this Revert, since doing the latter obliterates the thread token anyway // if (this.stateWasChanged && (this.tlsContents.ReferenceCountValue > 1 || !this.tlsContents.IsImpersonating)) { Win32Native.TOKEN_PRIVILEGE newState = new Win32Native.TOKEN_PRIVILEGE(); newState.PrivilegeCount = 1; newState.Privilege.Luid = this.luid; newState.Privilege.Attributes = (this.initialState ? Win32Native.SE_PRIVILEGE_ENABLED : Win32Native.SE_PRIVILEGE_DISABLED); Win32Native.TOKEN_PRIVILEGE previousState = new Win32Native.TOKEN_PRIVILEGE(); uint previousSize = 0; if (false == Win32Native.AdjustTokenPrivileges( this.tlsContents.ThreadHandle, false, ref newState, ( uint )Marshal.SizeOf(previousState), ref previousState, ref previousSize)) { error = Marshal.GetLastWin32Error(); success = false; } } } finally { if (success) { this.Reset(); } } } if (error == Win32Native.ERROR_NOT_ENOUGH_MEMORY) { throw new OutOfMemoryException(); } else if (error == Win32Native.ERROR_ACCESS_DENIED) { throw new UnauthorizedAccessException(); } else if (error != 0) { Contract.Assert(false, string.Format(CultureInfo.InvariantCulture, "AdjustTokenPrivileges() failed with unrecognized error code {0}", error)); throw new InvalidOperationException(); } }
private void ToggleState(bool enable) { int error = 0; // // All privilege operations must take place on the same thread // if (!this.currentThread.Equals(Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } // // This privilege was already altered and needs to be reverted before it can be altered again // if (this.needToRevert) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustRevertPrivilege")); } // // Need to make this block of code non-interruptible so that it would preserve // consistency of thread oken state even in the face of catastrophic exceptions // RuntimeHelpers.PrepareConstrainedRegions(); try { // // The payload is entirely in the finally block // This is how we ensure that the code will not be // interrupted by catastrophic exceptions // } finally { try { // // Retrieve TLS state // this.tlsContents = Thread.GetData(tlsSlot) as TlsContents; if (this.tlsContents == null) { this.tlsContents = new TlsContents(); Thread.SetData(tlsSlot, this.tlsContents); } else { this.tlsContents.IncrementReferenceCount(); } Win32Native.TOKEN_PRIVILEGE newState = new Win32Native.TOKEN_PRIVILEGE(); newState.PrivilegeCount = 1; newState.Privilege.Luid = this.luid; newState.Privilege.Attributes = enable ? Win32Native.SE_PRIVILEGE_ENABLED : Win32Native.SE_PRIVILEGE_DISABLED; Win32Native.TOKEN_PRIVILEGE previousState = new Win32Native.TOKEN_PRIVILEGE(); uint previousSize = 0; // // Place the new privilege on the thread token and remember the previous state. // if (false == Win32Native.AdjustTokenPrivileges( this.tlsContents.ThreadHandle, false, ref newState, ( uint )Marshal.SizeOf(previousState), ref previousState, ref previousSize)) { error = Marshal.GetLastWin32Error(); } else if (Win32Native.ERROR_NOT_ALL_ASSIGNED == Marshal.GetLastWin32Error()) { error = Win32Native.ERROR_NOT_ALL_ASSIGNED; } else { // // This is the initial state that revert will have to go back to // this.initialState = ((previousState.Privilege.Attributes & Win32Native.SE_PRIVILEGE_ENABLED) != 0); // // Remember whether state has changed at all // this.stateWasChanged = (this.initialState != enable); // // If we had to impersonate, or if the privilege state changed we'll need to revert // this.needToRevert = this.tlsContents.IsImpersonating || this.stateWasChanged; } } finally { if (!this.needToRevert) { this.Reset(); } } } if (error == Win32Native.ERROR_NOT_ALL_ASSIGNED) { throw new PrivilegeNotHeldException(privileges[this.luid] as string); } if (error == Win32Native.ERROR_NOT_ENOUGH_MEMORY) { throw new OutOfMemoryException(); } else if (error == Win32Native.ERROR_ACCESS_DENIED || error == Win32Native.ERROR_CANT_OPEN_ANONYMOUS) { throw new UnauthorizedAccessException(); } else if (error != 0) { Contract.Assert(false, string.Format(CultureInfo.InvariantCulture, "AdjustTokenPrivileges() failed with unrecognized error code {0}", error)); throw new InvalidOperationException(); } }
public void Revert() { int num = 0; if (!this.currentThread.Equals((object)Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (!this.NeedToRevert) { return; } RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { bool flag = true; try { if (this.stateWasChanged) { if (this.tlsContents.ReferenceCountValue <= 1) { if (this.tlsContents.IsImpersonating) { goto label_16; } } Win32Native.TOKEN_PRIVILEGE NewState = new Win32Native.TOKEN_PRIVILEGE(); NewState.PrivilegeCount = 1U; NewState.Privilege.Luid = this.luid; NewState.Privilege.Attributes = this.initialState ? 2U : 0U; Win32Native.TOKEN_PRIVILEGE PreviousState = new Win32Native.TOKEN_PRIVILEGE(); uint ReturnLength = 0; if (!Win32Native.AdjustTokenPrivileges(this.tlsContents.ThreadHandle, false, ref NewState, (uint)Marshal.SizeOf <Win32Native.TOKEN_PRIVILEGE>(PreviousState), out PreviousState, out ReturnLength)) { num = Marshal.GetLastWin32Error(); flag = false; } } } finally { if (flag) { this.Reset(); } } label_16 :; } if (num == 8) { throw new OutOfMemoryException(); } if (num == 5) { throw new UnauthorizedAccessException(); } if (num != 0) { throw new InvalidOperationException(); } }
private void ToggleState(bool enable) { int num = 0; if (!this.currentThread.Equals((object)Thread.CurrentThread)) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustBeSameThread")); } if (this.needToRevert) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_MustRevertPrivilege")); } RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { try { this.tlsContents = Thread.GetData(Privilege.tlsSlot) as Privilege.TlsContents; if (this.tlsContents == null) { this.tlsContents = new Privilege.TlsContents(); Thread.SetData(Privilege.tlsSlot, (object)this.tlsContents); } else { this.tlsContents.IncrementReferenceCount(); } Win32Native.TOKEN_PRIVILEGE NewState = new Win32Native.TOKEN_PRIVILEGE(); NewState.PrivilegeCount = 1U; NewState.Privilege.Luid = this.luid; NewState.Privilege.Attributes = enable ? 2U : 0U; Win32Native.TOKEN_PRIVILEGE PreviousState = new Win32Native.TOKEN_PRIVILEGE(); uint ReturnLength = 0; if (!Win32Native.AdjustTokenPrivileges(this.tlsContents.ThreadHandle, false, ref NewState, (uint)Marshal.SizeOf <Win32Native.TOKEN_PRIVILEGE>(PreviousState), out PreviousState, out ReturnLength)) { num = Marshal.GetLastWin32Error(); } else if (1300 == Marshal.GetLastWin32Error()) { num = 1300; } else { this.initialState = (PreviousState.Privilege.Attributes & 2U) > 0U; this.stateWasChanged = this.initialState != enable; this.needToRevert = this.tlsContents.IsImpersonating || this.stateWasChanged; } } finally { if (!this.needToRevert) { this.Reset(); } } } if (num == 1300) { throw new PrivilegeNotHeldException(Privilege.privileges[(object)this.luid] as string); } if (num == 8) { throw new OutOfMemoryException(); } if (num == 5 || num == 1347) { throw new UnauthorizedAccessException(); } if (num != 0) { throw new InvalidOperationException(); } }
private void ConnectInvokeWmi() { ManagementObject managementObject; object obj; string str; InvokeWmiMethod invokeWmiMethod = (InvokeWmiMethod)this.wmiObject; this.state = WmiState.Running; this.RaiseWmiOperationState(null, WmiState.Running); if (invokeWmiMethod.InputObject == null) { ConnectionOptions connectionOption = invokeWmiMethod.GetConnectionOption(); ManagementPath managementPath = null; if (invokeWmiMethod.Path != null) { managementPath = new ManagementPath(invokeWmiMethod.Path); if (!string.IsNullOrEmpty(managementPath.NamespacePath)) { if (invokeWmiMethod.namespaceSpecified) { InvalidOperationException invalidOperationException = new InvalidOperationException("NamespaceSpecifiedWithPath"); this.internalException = invalidOperationException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } else { managementPath.NamespacePath = invokeWmiMethod.Namespace; } if (!(managementPath.Server != ".") || !invokeWmiMethod.serverNameSpecified) { if (!(managementPath.Server == ".") || !invokeWmiMethod.serverNameSpecified) { this.computerName = managementPath.Server; } } else { InvalidOperationException invalidOperationException1 = new InvalidOperationException("ComputerNameSpecifiedWithPath"); this.internalException = invalidOperationException1; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } bool flag = false; bool enablePrivilege = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); try { try { enablePrivilege = this.NeedToEnablePrivilege(this.computerName, invokeWmiMethod.Name, ref flag); if (!enablePrivilege || flag && ComputerWMIHelper.EnableTokenPrivilege("SeShutdownPrivilege", ref tOKENPRIVILEGE) || !flag && ComputerWMIHelper.EnableTokenPrivilege("SeRemoteShutdownPrivilege", ref tOKENPRIVILEGE)) { if (invokeWmiMethod.Path == null) { ManagementScope managementScope = new ManagementScope(WMIHelper.GetScopeString(this.computerName, invokeWmiMethod.Namespace), connectionOption); ManagementClass managementClass = new ManagementClass(invokeWmiMethod.Class); managementObject = managementClass; managementObject.Scope = managementScope; } else { managementPath.Server = this.computerName; if (!managementPath.IsClass) { ManagementObject managementObject1 = new ManagementObject(managementPath); managementObject = managementObject1; } else { ManagementClass managementClass1 = new ManagementClass(managementPath); managementObject = managementClass1; } ManagementScope managementScope1 = new ManagementScope(managementPath, connectionOption); managementObject.Scope = managementScope1; } ManagementBaseObject methodParameters = managementObject.GetMethodParameters(invokeWmiMethod.Name); if (invokeWmiMethod.ArgumentList != null) { int length = (int)invokeWmiMethod.ArgumentList.Length; foreach (PropertyData property in methodParameters.Properties) { if (length == 0) { break; } property.Value = invokeWmiMethod.ArgumentList[(int)invokeWmiMethod.ArgumentList.Length - length]; length--; } } if (!enablePrivilege) { managementObject.InvokeMethod(this.results, invokeWmiMethod.Name, methodParameters, null); } else { ManagementBaseObject managementBaseObject = managementObject.InvokeMethod(invokeWmiMethod.Name, methodParameters, null); int num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); if (num == 0) { this.ShutdownComplete.SafeInvoke <EventArgs>(this, null); } else { Win32Exception win32Exception = new Win32Exception(num); this.internalException = win32Exception; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } } } else { string privilegeNotEnabled = ComputerResources.PrivilegeNotEnabled; string str1 = this.computerName; if (flag) { obj = "SeShutdownPrivilege"; } else { obj = "SeRemoteShutdownPrivilege"; } string str2 = StringUtil.Format(privilegeNotEnabled, str1, obj); InvalidOperationException invalidOperationException2 = new InvalidOperationException(str2); this.internalException = invalidOperationException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; this.internalException = managementException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (COMException cOMException1) { COMException cOMException = cOMException1; this.internalException = cOMException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (UnauthorizedAccessException unauthorizedAccessException1) { UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1; this.internalException = unauthorizedAccessException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } } finally { if (enablePrivilege) { if (flag) { str = "SeShutdownPrivilege"; } else { str = "SeRemoteShutdownPrivilege"; } ComputerWMIHelper.RestoreTokenPrivilege(str, ref tOKENPRIVILEGE); } } return; } else { try { ManagementBaseObject methodParameters1 = invokeWmiMethod.InputObject.GetMethodParameters(invokeWmiMethod.Name); if (invokeWmiMethod.ArgumentList != null) { int length1 = (int)invokeWmiMethod.ArgumentList.Length; foreach (PropertyData argumentList in methodParameters1.Properties) { if (length1 == 0) { break; } argumentList.Value = invokeWmiMethod.ArgumentList[(int)invokeWmiMethod.ArgumentList.Length - length1]; length1--; } } invokeWmiMethod.InputObject.InvokeMethod(this.results, invokeWmiMethod.Name, methodParameters1, null); } catch (ManagementException managementException3) { ManagementException managementException2 = managementException3; this.internalException = managementException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (COMException cOMException3) { COMException cOMException2 = cOMException3; this.internalException = cOMException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (UnauthorizedAccessException unauthorizedAccessException3) { UnauthorizedAccessException unauthorizedAccessException2 = unauthorizedAccessException3; this.internalException = unauthorizedAccessException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } return; } }