get a hard disk security dentifier (SID)

gistfile1.cpp

SID_AND_ATTRIBUTES user;

bool ConvertSid( PSID pSid, char * pszSidText, DWORD dwBufferlen)
{
 DWORD dwSidRev;
 DWORD dwSubAuthorities;
 DWORD dwCounter;
 DWORD dwSidSize;
 PSID_IDENTIFIER_AUTHORITY SecIA; 
 

 dwSidRev = SID_REVISION; 
 SecIA = (PSID_IDENTIFIER_AUTHORITY)LocalAlloc(LPTR, sizeof(SID_IDENTIFIER_AUTHORITY));

 SecIA = GetSidIdentifierAuthority(pSid); 
 dwSubAuthorities  = *GetSidSubAuthorityCount(pSid);
 dwSidSize = (15 + 12 + (12 * dwSubAuthorities) +1 ) *sizeof(char);
 
 if ( dwBufferlen < dwSidSize )
 {
  dwBufferlen = dwSidSize;
  SetLastError(ERROR_INSUFFICIENT_BUFFER);
  return false;
 }

 sprintf(pszSidText, "S-%u-", dwSidRev);
 if ( SecIA->Value[0] != 0 || SecIA->Value[1] != 0 )
 {
  sprintf(pszSidText+strlen(pszSidText), "%x%02x%02x%02x%02x%02x%02x", SecIA->Value[0], SecIA->Value[1], SecIA->Value[2], SecIA->Value[3], SecIA->Value[4], SecIA->Value[5]);
 }
 else
 {
  sprintf(pszSidText+strlen(pszSidText), "%d", ((DWORD)SecIA->Value[0] + (DWORD)SecIA->Value[1] + (DWORD)SecIA->Value[2] + (DWORD)SecIA->Value[3] + (DWORD)SecIA->Value[4] + (DWORD)SecIA->Value[5]));
  
  dwSidSize = strlen(pszSidText);
  for ( dwCounter = 0; dwCounter < dwSubAuthorities; dwCounter++)
  {
   sprintf(pszSidText+dwSidSize, "-%u", *GetSidSubAuthority(pSid, dwCounter)); 
   dwSidSize = strlen(pszSidText);
  }
 }

 return true;
}

bool ObtainTextSid(HANDLE hToken, char * pszSid, DWORD dwBufferlen)
{
 DWORD dwReturnLength;
 DWORD dwTokenUserLength;
 TOKEN_INFORMATION_CLASS tic = TokenUser;
 PVOID ptu;
 
 dwReturnLength = 0;
 dwTokenUserLength = 0; 
 ptu = NULL; 

 if ( !GetTokenInformation(hToken, tic, ptu, dwTokenUserLength, &dwReturnLength) )
 {
  if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
  {
   ptu = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwReturnLength);
   if (ptu == NULL)
    return false;

   dwTokenUserLength = dwReturnLength;
   dwReturnLength = 0;

   if (!GetTokenInformation(hToken, tic, ptu, dwTokenUserLength, &dwReturnLength))
    return false;
  }
 }
 else
  return false;

 if ( !ConvertSid((PTOKEN_USER(ptu)->User).Sid, pszSid, dwBufferlen))
  return false;

 if (!HeapFree(GetProcessHeap(), 0, ptu))
  return false;

 return true;

}

std::string GetCurrentUserSid()
{
 HANDLE hAccessToken;
 bool bSuccess;
 DWORD dwBufferLen;
 char szSid[260] = {};

 bSuccess = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &hAccessToken);

 if ( !bSuccess )
 {
  if ( GetLastError() == ERROR_NO_TOKEN )
  {
   bSuccess = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hAccessToken);
  }
 }

 if ( bSuccess )
 {
  ZeroMemory(&szSid, sizeof(szSid));
  dwBufferLen  = sizeof(szSid);

  if ( ObtainTextSid(hAccessToken, szSid, dwBufferLen))
  {
   CloseHandle(hAccessToken);
   return szSid;
  }
 }

 return szSid;
}

 

sid = GetCurrentUserSid();