Como Determinar se o Usuário é Membro do Grupo Administrador no Windows 7 com o UAC habilitado


Com o UAC habilitado no nível padrão, todas as contas de usuário, incluindo contas administrativas, executam com direitos de usuário padrão.

Quando um usuário faz logon no Windows, o sistema cria um token de acesso para ele. Esse token contém informações sobre o nível de acesso que é concedido ao usuário, incluindo os identificadores de segurança (SIDs) e privilégios do Windows. Quando um administrador faz logon, o Windows cria dois tokens de acesso separados para o usuário: um token de acesso sem privilégios administrativos (token filtrado) e um token de acesso de administrador (token full).

Para maiores detalhes sobre UAC veja o artigo: Controle de Conta de Usuário (UAC).

O UAC é um grande avanço para a segurança. No entanto, esse avanço quebra alguns paradigmas que você pode estar acostumado a usar para desenvolver aplicativos. Por exemplo, verificar se o usuário é administrador.

Se você utiliza a API IsUserAnAdmin do shell32 ou as classes WindowsIdentity e WindowsPrincipal do .NET Framework (veja o fragmento de código a seguir), você descobrirá que eles retornam verdadeiro quando o processo estiver elevado e falso caso contrário. 

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

O resultado está correto, entretanto, em alguns casos o valor não informa se o usuário é administrador independentemente se a aplicação está sendo executada elevada.

A API GetTokenInformation do advapi32.dll permite determinar qual é o token que o usuário está utilizando e com isso é possível assumir (isso mesmo, veja mais adiante) se o usuário é administrador independemente se o processo está ou não elevado.  

 

[DllImport("advapi32.dll", SetLastError = true)]
static extern bool GetTokenInformation(IntPtr tokenHandle, TokenInformationClass tokenInformationClass, IntPtr tokenInformation, int tokenInformationLength, out int returnLength);

/// <summary>
/// Passed to <see cref="GetTokenInformation"/> to specify what
/// information about the token to return.
/// </summary>
enum TokenInformationClass
{
TokenUser = 1,
TokenGroups,
TokenPrivileges,
TokenOwner,
TokenPrimaryGroup,
TokenDefaultDacl,
TokenSource,
TokenType,
TokenImpersonationLevel,
TokenStatistics,
TokenRestrictedSids,
TokenSessionId,
TokenGroupsAndPrivileges,
TokenSessionReference,
TokenSandBoxInert,
TokenAuditPolicy,
TokenOrigin,
TokenElevationType,
TokenLinkedToken,
TokenElevation,
TokenHasRestrictions,
TokenAccessInformation,
TokenVirtualizationAllowed,
TokenVirtualizationEnabled,
TokenIntegrityLevel,
TokenUiAccess,
TokenMandatoryPolicy,
TokenLogonSid,
MaxTokenInfoClass
}

/// <summary>
/// The elevation type for a user token.
/// </summary>
enum TokenElevationType
{
TokenElevationTypeDefault = 1,
TokenElevationTypeFull,
TokenElevationTypeLimited
}


bool IsUserAnAdministrator() {

WindowsIdentity identity = WindowsIdentity.GetCurrent();
WindowsPrincipal principal = new WindowsPrincipal(identity);

// Verifica se o usuário tem a role de Admin. Caso tiver retorna verdadeiro.
// Se o UAC estiver habilitado e o processo não estiver elevado a verificação abaixo retornará falso
//independentemente se o usuário pertencer ao grupo administrador
if (principal.IsInRole(WindowsBuiltInRole.Administrator)) return true;

// Se o processo não estiver executando a partir do Vista, não é necessário realizar a verificação do UAC.
if (Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major < 6)
{
return false;
}

int tokenInfLength = Marshal.SizeOf(typeof(int));
IntPtr tokenInformation = Marshal.AllocHGlobal(tokenInfLength);

try
{
var token = identity.Token;
var result = GetTokenInformation(token, TokenInformationClass.TokenElevationType, tokenInformation, tokenInfLength, out tokenInfLength);

if (!result)
{
var exception = Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
throw new InvalidOperationException("Não foi possível obter a informação do TOKEN", exception);
}

var elevationType = (TokenElevationType)Marshal.ReadInt32(tokenInformation);

switch (elevationType)
{
case TokenElevationType.TokenElevationTypeDefault:
// TokenElevationTypeDefault - O usuário possui apenas um token, portanto não é administrador.
return false;
case TokenElevationType.TokenElevationTypeFull:
// TokenElevationTypeFull - O usuário possui dois tokens e o processo está sendo executado elevado.
return true;
case TokenElevationType.TokenElevationTypeLimited:
// TokenElevationTypeLimited - O usuário possui dois tokens mas o processo não está sendo executado elevado.
return true;
default:
// Não foi possível determinar qual o token do usuário.
return false;
}
}
finally
{
if (tokenInformation != IntPtr.Zero) Marshal.FreeHGlobal(tokenInformation);
}

}

 

Observe que essa técnica apenas detecta qual é o token que o usuário possui. Na maioria das situações, isso irá determinar se o usuário está executando como administrador. No entanto, existem outros tipos de usuários com permissões avançadas que podem gerar uma divisão de token durante um logon interativo (por exemplo, o grupo operadores de configuração de rede). Se você estiver usando um desses grupos de permissão avançada, esta técnica irá determinar o tipo de elevação e não a presença (ou ausência) de credenciais de administrador.

Se o UAC estiver desabilitado, a API  irá retornar apenas o TOKEN TokenElevationTypeDefault. Caso o usuário estiver logado como administrador o nosso código de exemplo irá identificá-lo erroneamente como usuário comum. Por isso, nesse caso, é importante combinar os dois tipos de verificação (IsUserAnAdmin ou WindowsIdentity e WindowsPrincipal) com o TOKEN.

Para finalizar, a não ser que você realmente precise e saiba o que está fazendo, não utilize esses mecanismos de verificação. Caso você precise de direitos administrativos, crie, por exemplo, um manifesto para sua aplicação e defina que a aplicação precisa ser executada com privilégios administrativos.

No Visual Studio é possível definir essa configuração através do manifesto da aplicação localizado na pasta properties do projeto, conforme:

 

 <?xml version="1.0" encoding="utf-8"?>
<asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<assemblyIdentity version="1.0.0.0" name="MyApplication.app" />
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
<!-- UAC Manifest Options
If you want to change the Windows User Account Control level replace the
requestedExecutionLevel node with one of the following.

<requestedExecutionLevel level="asInvoker" uiAccess="false" />
<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
<requestedExecutionLevel level="highestAvailable" uiAccess="false" />

If you want to utilize File and Registry Virtualization for backward
compatibility then delete the requestedExecutionLevel node.
-->

<requestedExecutionLevel level="asInvoker" uiAccess="false" />
</requestedPrivileges>
<applicationRequestMinimum>
<defaultAssemblyRequest permissionSetReference="Custom" />
<PermissionSet class="System.Security.PermissionSet" version="1" ID="Custom" SameSite="site" Unrestricted="true" />
</applicationRequestMinimum>
</security>
</trustInfo>
</asmv1:assembly>
 

A tabela a seguir descreve os tipos de execução:

 

Nível de Execução

Descrição

asInvoker

Executa a aplicação com o token atual. Nunca solicita elevação.

highestAvailable

Tenta usar os direitos de usuário mais alto disponíveis. Solicitará o modo de aprovação
  de administrador caso o usuário for administrador.

requireAdministrator

Solicitará elevação, a menos que ser que o processo pai já esteja elevado.

Comments (0)

Skip to main content