internal static unsafe void KeepOnlyPrivilegeInProcess(string privilege)
        {
            SafeCloseHandle process = OpenCurrentProcessForWrite();

            try
            {
                SafeCloseHandle processToken = GetProcessToken(process, 0x20028);
                try
                {
                    LUID luid;
                    if (!ListenerUnsafeNativeMethods.LookupPrivilegeValue(IntPtr.Zero, privilege, &luid))
                    {
                        int error = Marshal.GetLastWin32Error();
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(error));
                    }
                    byte[] tokenInformation = new byte[GetTokenInformationLength(processToken, ListenerUnsafeNativeMethods.TOKEN_INFORMATION_CLASS.TokenPrivileges)];
                    try
                    {
                        fixed(byte *numRef = tokenInformation)
                        {
                            GetTokenInformation(processToken, ListenerUnsafeNativeMethods.TOKEN_INFORMATION_CLASS.TokenPrivileges, tokenInformation);
                            ListenerUnsafeNativeMethods.TOKEN_PRIVILEGES *newState = (ListenerUnsafeNativeMethods.TOKEN_PRIVILEGES *)numRef;
                            LUID_AND_ATTRIBUTES *luid_and_attributesPtr            = &newState->Privileges;
                            int index = 0;

                            for (int i = 0; i < newState->PrivilegeCount; i++)
                            {
                                if (!luid_and_attributesPtr[i].Luid.Equals(luid))
                                {
                                    luid_and_attributesPtr[index].Attributes = PrivilegeAttribute.SE_PRIVILEGE_DISABLED | PrivilegeAttribute.SE_PRIVILEGE_REMOVED;
                                    luid_and_attributesPtr[index].Luid       = luid_and_attributesPtr[i].Luid;
                                    index++;
                                }
                            }
                            newState->PrivilegeCount = index;
                            bool flag = ListenerUnsafeNativeMethods.AdjustTokenPrivileges(processToken, false, newState, tokenInformation.Length, IntPtr.Zero, IntPtr.Zero);
                            int  num5 = Marshal.GetLastWin32Error();

                            if (!flag || (num5 != 0))
                            {
                                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(num5));
                            }
                        }
                    }
                    finally
                    {
                        numRef = null;
                    }
                }
                finally
                {
                    processToken.Close();
                }
            }
            finally
            {
                process.Close();
            }
        }
示例#2
0
        internal static void KeepOnlyPrivilegeInProcess(string privilege)
        {
            SafeCloseHandle process = OpenCurrentProcessForWrite();

            try
            {
                SafeCloseHandle token = GetProcessToken(process, ListenerUnsafeNativeMethods.TOKEN_QUERY | ListenerUnsafeNativeMethods.TOKEN_ADJUST_PRIVILEGES | ListenerUnsafeNativeMethods.READ_CONTROL);
                try
                {
                    LUID luid;
                    bool success = ListenerUnsafeNativeMethods.LookupPrivilegeValue(IntPtr.Zero, privilege, &luid);
                    if (!success)
                    {
                        int error = Marshal.GetLastWin32Error();
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(error));
                    }

                    int    length           = GetTokenInformationLength(token, ListenerUnsafeNativeMethods.TOKEN_INFORMATION_CLASS.TokenPrivileges);
                    byte[] tokenInformation = new byte[length];
                    fixed(byte *pTokenPrivileges = tokenInformation)
                    {
                        GetTokenInformation(token, ListenerUnsafeNativeMethods.TOKEN_INFORMATION_CLASS.TokenPrivileges,
                                            tokenInformation);

                        ListenerUnsafeNativeMethods.TOKEN_PRIVILEGES *pTP = (ListenerUnsafeNativeMethods.TOKEN_PRIVILEGES *)pTokenPrivileges;
                        LUID_AND_ATTRIBUTES *pLuidAndAttributes           = (LUID_AND_ATTRIBUTES *)(&(pTP->Privileges));
                        int privilegeCount = 0;

                        for (int i = 0; i < pTP->PrivilegeCount; i++)
                        {
                            if (!pLuidAndAttributes[i].Luid.Equals(luid))
                            {
                                pLuidAndAttributes[privilegeCount].Attributes = PrivilegeAttribute.SE_PRIVILEGE_REMOVED;
                                pLuidAndAttributes[privilegeCount].Luid       = pLuidAndAttributes[i].Luid;
                                privilegeCount++;
                            }
                        }
                        pTP->PrivilegeCount = privilegeCount;

                        success = ListenerUnsafeNativeMethods.AdjustTokenPrivileges(token, false, pTP, tokenInformation.Length, IntPtr.Zero, IntPtr.Zero);
                        int error = Marshal.GetLastWin32Error();

                        if (!success || error != UnsafeNativeMethods.ERROR_SUCCESS)
                        {
                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(error));
                        }
                    }
                }
                finally
                {
                    token.Close();
                }
            }
            finally
            {
                process.Close();
            }
        }