Como determinar se um thread está em execução no contexto de utilizador da conta de administrador local

IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática… erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.

Clique aqui para ver a versão em Inglês deste artigo: 118626
Sumário
Para determinar se um thread está em execução sob uma conta de administrador local, tem de examinar o token de acesso que está associado ao thread. Este artigo descreve como efectuar este procedimento.

Com o Windows 2000 e versões posteriores, pode utilizar a API CheckTokenMembership() em vez dos passos descritos neste artigo. Para obter informações adicionais, consulte a documentação do Microsoft Platform SDK.
Mais Informação
Por predefinição, o token associado a um thread é que o processo que contém. "Este utilizador" é substituído por qualquer token que esteja directamente ligada ao thread. Por conseguinte, para determinar o utilizador de um thread, deve primeiro tentar obter um token do thread com a função OpenThreadToken . Se este método falha e a função GetLastError relatórios ERROR_NO_TOKEN, em seguida, pode obter o token para o processo com a função de OpenProcessToken .

Depois de obter o token do utilizador actual, pode utilizar a função AccessCheck para detectar se o utilizador é um administrador. Para o fazer, siga estes passos:
  1. Crie um identificador de segurança (SID, Security Identifier) para o grupo de administradores local, utilizando a função AllocateAndInitializeSid .
  2. Criar um novo descritor de segurança (SD) com um discricionária controlo de acesso lista (DACL) que contém uma entrada de controlo de acesso (ACE) para o SID do grupo de administradores.
  3. Chame AccessCheck com o token do utilizador actual e o SD recentemente construído para detectar se o utilizador é um administrador.
O código de exemplo seguinte utiliza as funções que são mencionadas neste artigo para testar se o thread actual está em execução como um utilizador que é um administrador no computador local.

Exemplo de código

#include <windows.h>#include <stdio.h>#include <lmcons.h>BOOL IsCurrentUserLocalAdministrator(void);void main(int argc, char **argv){   if (IsCurrentUserLocalAdministrator())      printf("You are an administrator\n");   else      printf("You are not an administrator\n");}/*--------------------------------------------------------------------------IsCurrentUserLocalAdministrator ()This function checks the token of the calling thread to see if the callerbelongs to the Administrators group.Return Value:   TRUE if the caller is an administrator on the local machine.   Otherwise, FALSE.--------------------------------------------------------------------------*/BOOL IsCurrentUserLocalAdministrator(void){   BOOL   fReturn         = FALSE;   DWORD  dwStatus;   DWORD  dwAccessMask;   DWORD  dwAccessDesired;   DWORD  dwACLSize;   DWORD  dwStructureSize = sizeof(PRIVILEGE_SET);   PACL   pACL            = NULL;   PSID   psidAdmin       = NULL;   HANDLE hToken              = NULL;   HANDLE hImpersonationToken = NULL;   PRIVILEGE_SET   ps;   GENERIC_MAPPING GenericMapping;   PSECURITY_DESCRIPTOR     psdAdmin           = NULL;   SID_IDENTIFIER_AUTHORITY SystemSidAuthority = SECURITY_NT_AUTHORITY;   /*      Determine if the current thread is running as a user that is a member of      the local admins group.  To do this, create a security descriptor that      has a DACL which has an ACE that allows only local aministrators access.      Then, call AccessCheck with the current thread's token and the security      descriptor.  It will say whether the user could access an object if it      had that security descriptor.  Note: you do not need to actually create      the object.  Just checking access against the security descriptor alone      will be sufficient.   */   const DWORD ACCESS_READ  = 1;   const DWORD ACCESS_WRITE = 2;   __try   {      /*         AccessCheck() requires an impersonation token.  We first get a primary         token and then create a duplicate impersonation token.  The         impersonation token is not actually assigned to the thread, but is         used in the call to AccessCheck.  Thus, this function itself never         impersonates, but does use the identity of the thread.  If the thread         was impersonating already, this function uses that impersonation context.      */      if (!OpenThreadToken(GetCurrentThread(), TOKEN_DUPLICATE|TOKEN_QUERY, TRUE, &hToken))      {         if (GetLastError() != ERROR_NO_TOKEN)            __leave;         if (!OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE|TOKEN_QUERY, &hToken))            __leave;      }      if (!DuplicateToken (hToken, SecurityImpersonation, &hImpersonationToken))          __leave;      /*        Create the binary representation of the well-known SID that        represents the local administrators group.  Then create the security        descriptor and DACL with an ACE that allows only local admins access.        After that, perform the access check.  This will determine whether        the current user is a local admin.      */      if (!AllocateAndInitializeSid(&SystemSidAuthority, 2,                                    SECURITY_BUILTIN_DOMAIN_RID,                                    DOMAIN_ALIAS_RID_ADMINS,                                    0, 0, 0, 0, 0, 0, &psidAdmin))         __leave;      psdAdmin = LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);      if (psdAdmin == NULL)         __leave;      if (!InitializeSecurityDescriptor(psdAdmin, SECURITY_DESCRIPTOR_REVISION))         __leave;      // Compute size needed for the ACL.      dwACLSize = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) +                  GetLengthSid(psidAdmin) - sizeof(DWORD);      pACL = (PACL)LocalAlloc(LPTR, dwACLSize);      if (pACL == NULL)         __leave;      if (!InitializeAcl(pACL, dwACLSize, ACL_REVISION2))         __leave;      dwAccessMask= ACCESS_READ | ACCESS_WRITE;      if (!AddAccessAllowedAce(pACL, ACL_REVISION2, dwAccessMask, psidAdmin))         __leave;      if (!SetSecurityDescriptorDacl(psdAdmin, TRUE, pACL, FALSE))         __leave;      /*         AccessCheck validates a security descriptor somewhat; set the group         and owner so that enough of the security descriptor is filled out to         make AccessCheck happy.      */      SetSecurityDescriptorGroup(psdAdmin, psidAdmin, FALSE);      SetSecurityDescriptorOwner(psdAdmin, psidAdmin, FALSE);      if (!IsValidSecurityDescriptor(psdAdmin))         __leave;      dwAccessDesired = ACCESS_READ;      /*         Initialize GenericMapping structure even though you         do not use generic rights.      */      GenericMapping.GenericRead    = ACCESS_READ;      GenericMapping.GenericWrite   = ACCESS_WRITE;      GenericMapping.GenericExecute = 0;      GenericMapping.GenericAll     = ACCESS_READ | ACCESS_WRITE;      if (!AccessCheck(psdAdmin, hImpersonationToken, dwAccessDesired,                       &GenericMapping, &ps, &dwStructureSize, &dwStatus,                       &fReturn))      {         fReturn = FALSE;         __leave;      }   }   __finally   {      // Clean up.      if (pACL) LocalFree(pACL);      if (psdAdmin) LocalFree(psdAdmin);      if (psidAdmin) FreeSid(psidAdmin);      if (hImpersonationToken) CloseHandle (hImpersonationToken);      if (hToken) CloseHandle (hToken);   }   return fReturn;}

Aviso: Este artigo foi traduzido automaticamente

Propriedades

ID do Artigo: 118626 - Última Revisão: 11/21/2006 15:29:45 - Revisão: 4.3

Microsoft Win32 Application Programming Interface

  • kbmt kbapi kbhowto kbkernbase kbsecurity KB118626 KbMtpt
Comentários