c# - Compruebe si el usuario actual es administrador

windows-administration

Question

Mi aplicación necesita ejecutar algunos scripts, y debo estar seguro de que el usuario que los ejecuta es un administrador ... ¿Cuál es la mejor manera de hacerlo utilizando C #?

Answer 1

Debo estar seguro de que el usuario que los ejecuta es un administrador

Si su aplicación debe ejecutarse con derechos de administrador, sería correcto actualizar su manifiesto.
Establezca el nivel de requireAdminstrator requestedExecutionlevel en requireAdminstrator .

Answer 2

Las respuestas anteriores con IsInRole son realmente correctas: comprueba si el usuario actual tiene privilegios de administrador. Sin embargo,

A partir de Windows Vista, el Control de cuentas de usuario (UAC) determina los privilegios de un usuario. Si es miembro del grupo de administradores integrados, se le asignan dos tokens de acceso en tiempo de ejecución: un token de acceso de usuario estándar y un token de acceso de administrador. Por defecto, estás en el rol de usuario estándar.

(de MSDN, por ejemplo, https://msdn.microsoft.com/en-us/library/system.diagnostics.eventlogpermission(v=vs.110).aspx )

Por lo tanto, IsInRole considerará por defecto el privilegio del usuario y, por lo tanto, el método devolverá el valor falso. Solo es cierto cuando el software se ejecuta explícitamente como administrador.

El otro método que verifica AD en https://ayende.com/blog/158401/are-you-an-administrator verificará si el nombre de usuario está en un grupo de administradores.

Mi método completo combinando ambos es así:

    public static bool IsCurrentUserAdmin(bool checkCurrentRole = true)
    {
        bool isElevated = false;

        using (WindowsIdentity identity = WindowsIdentity.GetCurrent())
        {
            if (checkCurrentRole)
            {
                // Even if the user is defined in the Admin group, UAC defines 2 roles: one user and one admin. 
                // IsInRole consider the current default role as user, thus will return false!
                // Will consider the admin role only if the app is explicitly run as admin!
                WindowsPrincipal principal = new WindowsPrincipal(identity);
                isElevated = principal.IsInRole(WindowsBuiltInRole.Administrator);
            }
            else
            {
                // read all roles for the current identity name, asking ActiveDirectory
                isElevated = IsAdministratorNoCache(identity.Name);
            }
        }

        return isElevated;
    }

    /// <summary>
    /// Determines whether the specified user is an administrator.
    /// </summary>
    /// <param name="username">The user name.</param>
    /// <returns>
    ///   <c>true</c> if the specified user is an administrator; otherwise, <c>false</c>.
    /// </returns>
    /// <seealso href="https://ayende.com/blog/158401/are-you-an-administrator"/>
    private static bool IsAdministratorNoCache(string username)
    {
        PrincipalContext ctx;
        try
        {
            Domain.GetComputerDomain();
            try
            {
                ctx = new PrincipalContext(ContextType.Domain);
            }
            catch (PrincipalServerDownException)
            {
                // can''t access domain, check local machine instead 
                ctx = new PrincipalContext(ContextType.Machine);
            }
        }
        catch (ActiveDirectoryObjectNotFoundException)
        {
            // not in a domain
            ctx = new PrincipalContext(ContextType.Machine);
        }
        var up = UserPrincipal.FindByIdentity(ctx, username);
        if (up != null)
        {
            PrincipalSearchResult<Principal> authGroups = up.GetAuthorizationGroups();
            return authGroups.Any(principal =>
                                  principal.Sid.IsWellKnown(WellKnownSidType.BuiltinAdministratorsSid) ||
                                  principal.Sid.IsWellKnown(WellKnownSidType.AccountDomainAdminsSid) ||
                                  principal.Sid.IsWellKnown(WellKnownSidType.AccountAdministratorSid) ||
                                  principal.Sid.IsWellKnown(WellKnownSidType.AccountEnterpriseAdminsSid));
        }
        return false;
    }

Para un usuario en un grupo de administración sin privilegios elevados (UAC habilitado), este método IsCurrentUserAdmin () return! CheckCurrentRole: true si checkCurrentRole == false, pero false si checkCurrentRole == true

Si ejecuta el código que REQUIERE privilegios de administrador, considere el checkCurrentRole == verdadero. De lo contrario, obtendrá una excepción de seguridad para entonces. Por lo tanto, la correcta lógica IsInRole .

Answer 3

Solo pensé en añadir otra solución; como el IsInRole no siempre funciona.

• Si el usuario no es miembro del grupo de usuarios de Windows especificado en la sesión actual.
• El administrador ha realizado cambios en la configuración de la directiva de grupo.
• El parámetro de rol se trata como un método ''sensible a mayúsculas y minúsculas''.
• Y si una máquina XP no tiene instalada la versión .NET Framework, no funcionará.

Dependiendo de sus necesidades, si necesita soportar sistemas más antiguos; o no está seguro de cómo su cliente está administrando físicamente su sistema. Esta es una solución que implementé; Por flexibilidad y alteraciones.

class Elevated_Rights
    {

        // Token Bool:
        private bool _level = false;

        #region Constructor:

        protected Elevated_Rights()
        {

            // Invoke Method On Creation:
            Elevate();

        }

        #endregion

        public void Elevate()
        {

            // Get Identity:
            WindowsIdentity user = WindowsIdentity.GetCurrent();

            // Set Principal
            WindowsPrincipal role = new WindowsPrincipal(user);

            #region Test Operating System for UAC:

            if (Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major < 6)
            {

                // False:
                _level = false;

                // Todo: Exception/ Exception Log

            }

            #endregion

            else
            {

                #region Test Identity Not Null:

                if (user == null)
                {

                    // False:
                    _level = false;

                    // Todo: "Exception Log / Exception"

                }

                #endregion

                else
                {

                    #region Ensure Security Role:

                    if (!(role.IsInRole(WindowsBuiltInRole.Administrator)))
                    {

                        // False:
                        _level = false;

                        // Todo: "Exception Log / Exception"

                    }

                    else
                    {

                        // True:
                        _level = true;

                    }

                    #endregion


                } // Nested Else ''Close''

            } // Initial Else ''Close''

        } // End of Class.

Así que el código anterior tiene algunas construcciones; en realidad se probará para ver si el usuario está en Vista o superior. De esa manera, si un cliente está en XP sin un marco o un marco beta desde hace años, le permitirá modificar lo que le gustaría hacer.

Luego se probará físicamente para evitar un valor nulo para la cuenta.

Luego, por último, proporcionará la verificación para verificar que el usuario tenga la función adecuada.

Sé que la pregunta ha sido contestada; pero pensé que mi solución sería una gran adición a la página para cualquier otra persona que esté buscando en Stack. Mi razonamiento detrás del Constructor Protegido le permitiría usar esta clase como una Clase Derivada de la que podría controlar el estado en que se crea una instancia de la clase.

Answer 4

También puede llamar a la API de Windows para hacer esto:

[DllImport("shell32.dll", SetLastError=true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool IsUserAnAdmin();

que de forma más general le dice si el usuario se está ejecutando con derechos elevados.

Answer 5

return new WindowsPrincipal(WindowsIdentity.GetCurrent())
    .IsInRole(WindowsBuiltInRole.Administrator);

Answer 6

using System.Security.Principal;

public static bool IsAdministrator()
{
    WindowsIdentity identity = WindowsIdentity.GetCurrent();
    WindowsPrincipal principal = new WindowsPrincipal(identity);
    return principal.IsInRole(WindowsBuiltInRole.Administrator);
}