PSID vncImportACL::GetSID(const TCHAR *domainaccount){ PSID pSid = NULL; unsigned long ulDomLen = 0; unsigned long ulSidLen = 0; SID_NAME_USE peUse; TCHAR *domain = NULL; // Get accounts's SID // First call to LookupAccountName is expected to fail. // Sets pSid and domain size LookupAccountName(NULL, domainaccount, pSid, &ulSidLen, domain, &ulDomLen, &peUse); pSid = (PSID)new TCHAR[ulSidLen]; domain = new TCHAR[ulDomLen]; LookupAccountName(NULL, domainaccount, pSid, &ulSidLen, domain, &ulDomLen, &peUse); if (!IsValidSid(pSid)){ _ftprintf(stderr, _T("%s: SID not valid.\n"), domainaccount); delete [] pSid; pSid = NULL; } delete [] domain; return pSid; }
uid_t getuid() { const int UNLEN = 256; PSID sid = NULL; TCHAR* domain = NULL; DWORD sid_size = 0; DWORD domain_size = 0; SID_NAME_USE use = SidTypeUnknown; TCHAR buffer[257]; DWORD buffer_len = _countof(buffer); if (!GetUserName(buffer, &buffer_len)) { return 0; } //Called once to set the size of the sid pointer and domain LookupAccountName(NULL, buffer, NULL, &sid_size, NULL, &domain_size, &use); //Allocate memory based on sid and domain size sid = (PSID)LocalAlloc(LMEM_FIXED, sid_size); domain = (TCHAR*)malloc(domain_size * sizeof(TCHAR)); //Initialize sid and domain if (!LookupAccountName(NULL, buffer, sid, &sid_size, domain, &domain_size, &use)) { return 0; } if (!IsValidSid(sid)) { return 0; } return (uid_t)sid; }
//------------------------------------------------------------------------------ //lecture du SID à partir d'un nom BOOL get_sid(const char *name, SID **ppsid) { SID_NAME_USE sid_use; DWORD sid_size = 0; DWORD dom_size = 0; char *domain; *ppsid = 0; if(LookupAccountName(0, name, 0, &sid_size, 0, &dom_size, &sid_use) == 0) { if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)return FALSE; } *ppsid = (SID *)LocalAlloc( LMEM_FIXED, sid_size); domain = (char *)LocalAlloc( LMEM_FIXED, dom_size); if( (*ppsid == 0) || (domain == 0)) { if(*ppsid) LocalFree((HLOCAL)*ppsid); if(domain) LocalFree((HLOCAL)domain); *ppsid = 0; return FALSE; } if(LookupAccountName(0, name, *ppsid, &sid_size, domain, &dom_size, &sid_use) == 0) { LocalFree((HLOCAL)*ppsid); LocalFree((HLOCAL)domain); *ppsid = 0; return FALSE; } LocalFree((HLOCAL)domain); return TRUE; }
bool QualifyName(const TCHAR *user, LPTSTR DomName) { PSID pSid = NULL; DWORD cbSid = 0; DWORD cbDomName = MAXLEN; SID_NAME_USE sidUse; bool isNameQualified = false; __try { // Get Sid buffer size LookupAccountName(NULL, user, pSid, &cbSid, DomName, &cbDomName, &sidUse); if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) __leave; if (!(pSid = (PSID) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbSid))) __leave; if (cbDomName > MAXLEN) __leave; // Get DomName if (!LookupAccountName(NULL, user, pSid, &cbSid, DomName, &cbDomName, &sidUse)) __leave; isNameQualified = true; } __finally { HeapFree(GetProcessHeap(), 0, pSid); } return isNameQualified; }
HRESULT COpcSecurity::GetPrincipalSID(LPCTSTR pszPrincipal, PSID *ppSid) { HRESULT hr; LPTSTR pszRefDomain = NULL; DWORD dwDomainSize = 0; DWORD dwSidSize = 0; SID_NAME_USE snu; // Call to get size info for alloc LookupAccountName(NULL, pszPrincipal, *ppSid, &dwSidSize, pszRefDomain, &dwDomainSize, &snu); hr = GetLastError(); if (hr != ERROR_INSUFFICIENT_BUFFER) return HRESULT_FROM_WIN32(hr); OPCTRY(pszRefDomain = new TCHAR[dwDomainSize]); if (pszRefDomain == NULL) return E_OUTOFMEMORY; *ppSid = (PSID) malloc(dwSidSize); if (*ppSid != NULL) { if (!LookupAccountName(NULL, pszPrincipal, *ppSid, &dwSidSize, pszRefDomain, &dwDomainSize, &snu)) { free(*ppSid); *ppSid = NULL; delete[] pszRefDomain; return HRESULT_FROM_WIN32(GetLastError()); } delete[] pszRefDomain; return S_OK; } delete[] pszRefDomain; return E_OUTOFMEMORY; }
PUBLIC_FUNCTION_END PUBLIC_FUNCTION(IsUserTheAdministrator) { TCHAR * name = (TCHAR *)LocalAlloc(LPTR, string_size*sizeof(TCHAR)); TCHAR * sidstr = NULL; DWORD dwName = string_size; PSID pSid = NULL; DWORD sidLen = 0; DWORD domLen = 0; TCHAR * domain = NULL; SID_NAME_USE use; if (popstring(name)) ABORT("Missing user name plug-in parameter."); if ((LookupAccountName(NULL, name, NULL, &sidLen, NULL, &domLen, &use) || ERROR_INSUFFICIENT_BUFFER == GetLastError()) && NULL != (domain = (TCHAR *)LocalAlloc(LPTR, domLen*sizeof(TCHAR))) && NULL != (pSid = (PSID)LocalAlloc(LPTR, sidLen))) { if (!LookupAccountName(NULL, name, pSid, &sidLen, domain, &domLen, &use)) { LocalFree(pSid); pSid = NULL; ABORT_d("Couldn't lookup current user name. Error code %d: ", GetLastError()); } int uid; if (500 == (uid = *GetSidSubAuthority(pSid, *GetSidSubAuthorityCount(pSid) - 1))) pushstring(_T("yes")); else pushstring(_T("no")); sidstr = (TCHAR *)LocalAlloc(LPTR, string_size*sizeof(TCHAR)); ConvertSidToStringSid(pSid, &sidstr); int len = lstrlen(sidstr); TCHAR * strend = sidstr + len - 1; TCHAR * strstart = sidstr; while (*strend != '-' && len >= 0) { strend--; len--; } *strend = '\0'; lstrcat(strend, _T("-500")); pushstring(sidstr); } cleanup: if (NULL != sidstr) LocalFree(sidstr); LocalFree(name); }
DWORD GetAccountSid( IN const WCHAR *accountName, IN const WCHAR *systemName, OUT SID **sid ) { SID_NAME_USE sidUsage; DWORD cbSid; DWORD cchReferencedDomainName = MAX_PATH; WCHAR referencedDomainName[MAX_PATH]; DWORD status; if (!accountName || !sid) return ERROR_INVALID_PARAMETER; cbSid = 0; *sid = NULL; if (!LookupAccountName( systemName, accountName, NULL, &cbSid, referencedDomainName, &cchReferencedDomainName, &sidUsage)) { status = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER != status) { return perror("LookupAccountName"); } } *sid = LocalAlloc(LPTR, cbSid); if (*sid == NULL) { return perror("LocalAlloc"); } if (!LookupAccountName( systemName, accountName, *sid, &cbSid, referencedDomainName, &cchReferencedDomainName, &sidUsage)) { status = GetLastError(); LocalFree(*sid); return perror2(status, "LookupAccountName"); } return ERROR_SUCCESS; }
/*---------------------------------------------------------------------------*\ * NAME: GetPrincipalSID * * --------------------------------------------------------------------------* * DESCRIPTION: Creates a SID for the supplied principal. * \*---------------------------------------------------------------------------*/ DWORD GetPrincipalSID ( LPTSTR tszPrincipal, PSID *pSid ) { DWORD cbSid = 0; TCHAR tszRefDomain [256] = {0}; DWORD cbRefDomain = 0; DWORD dwReturnValue = ERROR_SUCCESS; SID_NAME_USE snu; cbSid = 0; cbRefDomain = 255; if(ConstructWellKnownSID(tszPrincipal, pSid)) return ERROR_SUCCESS; LookupAccountName (NULL, tszPrincipal, *pSid, &cbSid, tszRefDomain, &cbRefDomain, &snu); dwReturnValue = GetLastError(); if (dwReturnValue != ERROR_INSUFFICIENT_BUFFER) goto CLEANUP; dwReturnValue = ERROR_SUCCESS; *pSid = (PSID) malloc (cbSid); if(!pSid) { dwReturnValue = ERROR_OUTOFMEMORY; goto CLEANUP; } cbRefDomain = 255; if (!LookupAccountName (NULL, tszPrincipal, *pSid, &cbSid, tszRefDomain, &cbRefDomain, &snu)) { dwReturnValue = GetLastError(); goto CLEANUP; } CLEANUP: return dwReturnValue; }
isc_result_t isc_fsaccess_changeowner(const char *filename, const char *user) { SECURITY_DESCRIPTOR psd; BYTE sidBuffer[500]; BYTE groupBuffer[500]; PSID psid=(PSID) &sidBuffer; DWORD sidBufferSize = sizeof(sidBuffer); char domainBuffer[100]; DWORD domainBufferSize = sizeof(domainBuffer); SID_NAME_USE snu; PSID pSidGroup = (PSID) &groupBuffer; DWORD groupBufferSize = sizeof(groupBuffer); /* * Determine if this is a FAT or NTFS disk and * call the appropriate function to set the ownership * FAT disks do not have ownership attributes so it's * a noop. */ if (is_ntfs(filename) == FALSE) return (ISC_R_SUCCESS); if (!InitializeSecurityDescriptor(&psd, SECURITY_DESCRIPTOR_REVISION)) return (ISC_R_NOPERM); if (!LookupAccountName(0, user, psid, &sidBufferSize, domainBuffer, &domainBufferSize, &snu)) return (ISC_R_NOPERM); /* Make sure administrators can get to it */ domainBufferSize = sizeof(domainBuffer); if (!LookupAccountName(0, "Administrators", pSidGroup, &groupBufferSize, domainBuffer, &domainBufferSize, &snu)) return (ISC_R_NOPERM); if (!SetSecurityDescriptorOwner(&psd, psid, FALSE)) return (ISC_R_NOPERM); if (!SetSecurityDescriptorGroup(&psd, pSidGroup, FALSE)) return (ISC_R_NOPERM); if (!SetFileSecurity(filename, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION, &psd)) return (ISC_R_NOPERM); return (ISC_R_SUCCESS); }
// // Return the SID of specified user account // PSID GetUserSid(LPCTSTR szUserName) { SID *sid = 0; TCHAR *dom = 0; DWORD sidlen = 0; DWORD domlen = 0; SID_NAME_USE snu; // // with no machine specified, LookupAccountName looks up user's sid in // following locations: // // well-known, built-in, local-machine, primary-domain, trusted-domain // while(!LookupAccountName(NULL, szUserName, sid, &sidlen, dom, &domlen, &snu)) { if(sid) free(sid); if(dom) free(dom); if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) return 0; sid = malloc(sidlen); dom = malloc(domlen); } printf("domain: %s\n", dom); free(dom); return sid; }
LPTSTR CDialupass::GetLocalSid() { union { SID s; char c[256]; }Sid; DWORD sizeSid=sizeof(Sid); char DomainName[256]; DWORD sizeDomainName=sizeof(DomainName); SID_NAME_USE peUse; LPSTR pSid; if (m_lpCurrentUser == NULL) return NULL; if(!LookupAccountName(NULL,m_lpCurrentUser,(SID*)&Sid,&sizeSid,DomainName,&sizeDomainName,&peUse))return NULL; if(!IsValidSid(&Sid))return NULL; typedef BOOL (WINAPI *ConvertSid2StringSid)(PSID , LPTSTR *); ConvertSid2StringSid proc; HINSTANCE hLibrary = LoadLibrary("advapi32.dll"); proc = (ConvertSid2StringSid) GetProcAddress(hLibrary, "ConvertSidToStringSidA"); if(proc) proc((SID*)&Sid.s,&pSid); FreeLibrary(hLibrary); return pSid; }
void main() { char sid[256]; // sid를 담을 변수 가변길이 이므로 충분한 크기로 버퍼를 만든다 char domain[256]; DWORD sid_size = 256; DWORD domain_size = 256; SID_NAME_USE use; // sid의 종류.. // power의 sid를 구한다. LookupAccountName("." , // PC이름 "power", // 사용자 id sid, &sid_size, // sid를 담을 변수,. 크기 domain, &domain_size, &use); // sid의 종류 cout << "Domain : " << domain << endl; cout << "SID 종류 : " << use << endl; // sid는 문자열이 아닌 이진 값이 므로 바로 출력할수는 없다. // 2진 sid를 문자열 sid로 변경하기. - sddl.h 가 필요..( platform sdk를 설치해야 가능) char* temp; ConvertSidToStringSid( sid, &temp);// 내부적으로 temp에 메모리할당을 해준다. cout << "SID : " << temp << endl; LocalFree( temp ); }
bool SetOwnerInternal(LPCWSTR Object, LPCWSTR Owner) { bool Result = false; PSID Sid = nullptr; //в winapi от mingw.org неправильный тип параметра. if(!ConvertStringSidToSid((LPWSTR)Owner, &Sid)) { SID_NAME_USE Use; DWORD cSid=0, ReferencedDomain=0; LookupAccountName(nullptr, Owner, nullptr, &cSid, nullptr, &ReferencedDomain, &Use); if(cSid) { Sid = LocalAlloc(LMEM_FIXED, cSid); if(Sid) { LPWSTR ReferencedDomainName = new WCHAR[ReferencedDomain]; if(ReferencedDomainName) { if(LookupAccountName(nullptr, Owner, Sid, &cSid, ReferencedDomainName, &ReferencedDomain, &Use)) { } delete[] ReferencedDomainName; } } } } if(Sid) { Privilege TakeOwnershipPrivilege(SE_TAKE_OWNERSHIP_NAME); Privilege RestorePrivilege(SE_RESTORE_NAME); DWORD dwResult = SetNamedSecurityInfo(const_cast<LPWSTR>(Object), SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, Sid, nullptr, nullptr, nullptr); if(dwResult == ERROR_SUCCESS) { Result = true; } else { SetLastError(dwResult); } } if(Sid) { LocalFree(Sid); } return Result; }
void getWindowsSID_2 ( char *output) { char computer_name[256]; SID *sid; SID_NAME_USE snu; char *domain; char *stringsid; unsigned long size, domainsize; *output = 0; /* Get the computer name */ size = sizeof (computer_name); if (! GetComputerName ((LPSTR) computer_name, &size)) return; /* First find the size of buffers required for the SID and domain name */ sid = 0; domain = 0; size = domainsize = 0; LookupAccountName(0, (LPCSTR) computer_name, sid, &size, domain, &domainsize, &snu); /* Should have failed with ERROR_INSUFFICIENT_BUFFER */ if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return; /* Allocate memory */ sid = (SID *) malloc (size); domain = (char *) malloc (domainsize); /* Get the SID */ if (sid != NULL && domain != NULL && LookupAccountName (0, (LPCSTR) computer_name, sid, &size, domain, &domainsize, &snu) && ConvertSidToStringSid(sid, &stringsid)) { strcpy (output, stringsid); LocalFree (stringsid); } /* Cleanup */ free (sid); free (domain); }
APR_DECLARE(apr_status_t) apr_uid_get(apr_uid_t *uid, apr_gid_t *gid, const char *username, apr_pool_t *p) { #ifdef _WIN32_WCE return APR_ENOTIMPL; #else SID_NAME_USE sidtype; char anydomain[256]; char *domain; DWORD sidlen = 0; DWORD domlen = sizeof(anydomain); DWORD rv; char *pos; if (pos = strchr(username, '/')) { domain = apr_pstrndup(p, username, pos - username); username = pos + 1; } else if (pos = strchr(username, '\\')) { domain = apr_pstrndup(p, username, pos - username); username = pos + 1; } else { domain = NULL; } /* Get nothing on the first pass ... need to size the sid buffer */ rv = LookupAccountName(domain, username, domain, &sidlen, anydomain, &domlen, &sidtype); if (sidlen) { /* Give it back on the second pass */ *uid = apr_palloc(p, sidlen); domlen = sizeof(anydomain); rv = LookupAccountName(domain, username, *uid, &sidlen, anydomain, &domlen, &sidtype); } if (!sidlen || !rv) { return apr_get_os_error(); } /* There doesn't seem to be a simple way to retrieve the primary group sid */ *gid = NULL; return APR_SUCCESS; #endif }
DWORD GetPrincipalSID ( LPTSTR Principal, PSID *Sid) { DWORD sidSize; TCHAR refDomain [256]; DWORD refDomainSize; DWORD returnValue; SID_NAME_USE snu; sidSize = 0; refDomainSize = 255; LookupAccountName( NULL, Principal, *Sid, &sidSize, refDomain, &refDomainSize, &snu); returnValue = GetLastError(); if (returnValue != ERROR_INSUFFICIENT_BUFFER) { return returnValue; } *Sid = (PSID) malloc (sidSize); refDomainSize = 255; if (!LookupAccountName ( NULL, Principal, *Sid, &sidSize, refDomain, &refDomainSize, &snu)) { return GetLastError(); } return ERROR_SUCCESS; }
BOOL GetAccountSid(LPTSTR SystemName, LPTSTR AccountName, PSID *Sid) { LPTSTR ReferencedDomain = NULL; DWORD cbSid = 128; /* initial allocation attempt */ DWORD cbReferencedDomain = 16; /* initial allocation size */ SID_NAME_USE peUse; BOOL bSuccess = FALSE; /* assume this function will fail */ __try { /* * initial memory allocations */ if ((*Sid = HeapAlloc(GetProcessHeap(), 0, cbSid)) == NULL) __leave; if ((ReferencedDomain = (LPTSTR) HeapAlloc(GetProcessHeap(), 0, cbReferencedDomain)) == NULL) __leave; /* * Obtain the SID of the specified account on the specified system. */ while (!LookupAccountName(SystemName, AccountName, *Sid, &cbSid, ReferencedDomain, &cbReferencedDomain, &peUse)) { if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { /* reallocate memory */ if ((*Sid = HeapReAlloc(GetProcessHeap(), 0, *Sid, cbSid)) == NULL) __leave; if ((ReferencedDomain= (LPTSTR) HeapReAlloc( GetProcessHeap(), 0, ReferencedDomain, cbReferencedDomain)) == NULL) __leave; } else __leave; } bSuccess = TRUE; } /* finally */ __finally { /* Cleanup and indicate failure, if appropriate. */ HeapFree(GetProcessHeap(), 0, ReferencedDomain); if (!bSuccess) { if (*Sid != NULL) { HeapFree(GetProcessHeap(), 0, *Sid); *Sid = NULL; } } } return (bSuccess); }
static PSID x_GetAccountSidByName(const string& account, SID_NAME_USE type = (SID_NAME_USE)0) { PSID sid = NULL; DWORD sid_size = 0; TXChar* domain = NULL; DWORD domain_size = 0; SID_NAME_USE use; TXString name(_T_XSTRING(account)); // First call to LookupAccountName() to get the buffer sizes if ( !LookupAccountName(NULL, name.c_str(), sid, &sid_size, domain, &domain_size, &use) && GetLastError() != ERROR_INSUFFICIENT_BUFFER ) { CNcbiError::SetFromWindowsError(); return NULL; } try { // Allocate buffers sid = (PSID) LocalAlloc(LMEM_FIXED, sid_size); domain = (TXChar*) malloc(domain_size * sizeof(TXChar)); if ( !sid || !domain ) { throw(0); } // Second call to get the actual account info if ( !LookupAccountName(NULL, name.c_str(), sid, &sid_size, domain, &domain_size, &use) ) { CNcbiError::SetFromWindowsError(); throw(0); } // Check type of account if (type && type != use ) { CNcbiError::Set(CNcbiError::eUnknown); throw(0); } } catch (int) { LocalFree(sid); sid = NULL; } // Clean up if ( domain ) free(domain); return sid; }
void GetSid(PSID sid, LPDWORD pSidSize, LPCWSTR accountName) { SID_NAME_USE use; WCHAR referencedDomainName[1024]; DWORD cchReferencedDomainName = sizeof(referencedDomainName) / sizeof(WCHAR); if (!LookupAccountName(NULL, accountName, sid, pSidSize, referencedDomainName, &cchReferencedDomainName, &use)) { Win32Exception::ThrowFromLastError(); } }
bool SetOwnerInternal(const string& Object, const string& Owner) { bool Result = false; PSID Sid = nullptr; SCOPE_EXIT { LocalFree(Sid); }; if(!ConvertStringSidToSid(Owner.data(), &Sid)) { SID_NAME_USE Use; DWORD cSid=0, ReferencedDomain=0; LookupAccountName(nullptr, Owner.data(), nullptr, &cSid, nullptr, &ReferencedDomain, &Use); if(cSid) { Sid = LocalAlloc(LMEM_FIXED, cSid); if(Sid) { std::vector<wchar_t> ReferencedDomainName(ReferencedDomain); if(LookupAccountName(nullptr, Owner.data(), Sid, &cSid, ReferencedDomainName.data(), &ReferencedDomain, &Use)) { ; } } } } if(Sid) { SCOPED_ACTION(Privilege)(SE_TAKE_OWNERSHIP_NAME); SCOPED_ACTION(Privilege)(SE_RESTORE_NAME); DWORD dwResult = SetNamedSecurityInfo(const_cast<LPWSTR>(Object.data()), SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, Sid, nullptr, nullptr, nullptr); if(dwResult == ERROR_SUCCESS) { Result = true; } else { SetLastError(dwResult); } } return Result; }
/** * Does not closeHandle on the session handle, nor does it perform UnloadUserProfile * on the profile handle. The profile handle cannot be unloaded, that would unload * the registry keys that we just got the root to. These cleanup flaws are probably acceptable * for the Polarizer, which runs for a few minutes before shutting down. **/ RegKey getUserRegistryRoot(std::wstring accountName, std::wstring password) { HANDLE session; if (!LogonUser(accountName.c_str(), NULL, password.c_str(), LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, &session)) { DWORD error = GetLastError(); printf("LogonUser() failed: %d", error); logtools.log(L"LogonUser() failed", error); return RegKey::INVALID; } // Load the pet account's registry hive. wchar_t account[128] = {}; wcsncat(account, accountName.c_str(), 128); PROFILEINFO profile = { sizeof(PROFILEINFO), 0, account }; if (!LoadUserProfile(session, &profile)) { printf("LoadUserProfile() failed: %d", GetLastError()); logtools.log(L"LoadUserProfile() failed", GetLastError()); return RegKey::INVALID; } // now the pet hive is loaded, compute the SID so I // can get a name for the key that I can use to make a RegKey // Can't use the session handle I just got back because it // can't be converted to a regkey, either get the name or // give up on using our regkey abstraction. BYTE sid[10000]; DWORD sidSize = 10000; DWORD domainSize = 1000; wchar_t domain[1000]; SID_NAME_USE peUse; BOOL lookupWorked = LookupAccountName(NULL,accountName.c_str(), sid, &sidSize, domain, &domainSize, &peUse); if (lookupWorked) { LPTSTR sidNameChars; BOOL converted = ConvertSidToStringSidW(sid, &sidNameChars); if (converted) { std::wstring sidName = sidNameChars; RegKey key = RegKey::HKU.open(sidName); LocalFree(sidNameChars); return key; } else { logtools.log(L"convert sid to string failed", GetLastError()); return RegKey::INVALID; } } else { int err = GetLastError(); logtools.log(L"lookupAccountName failed", err); return RegKey::INVALID; } return RegKey::INVALID; }
static int __stringToSID(char *account, PSID *res, Int *sizeOfRes) { SID_NAME_USE snu; DWORD sizeDom = 0; char sDomain[120]; sizeDom = sizeof(sDomain); if (!LookupAccountName(NULL, account, res, sizeOfRes, sDomain, &sizeDom, &snu)) { return -1; } return 0; }
static char * ParseSid(TCHAR * trustee) { PSID pSid = NULL; TCHAR * strend = trustee + lstrlen(trustee) - 1; if ('(' == *trustee && ')' == *strend) { *strend = '\0'; ++trustee; //pSid = GetBinarySid(trustee); if (!ConvertStringSidToSid(trustee, &pSid)) pSid = NULL; } else { DWORD sidLen = 0; DWORD domLen = 0; TCHAR * domain = NULL; SID_NAME_USE use; if ((LookupAccountName(NULL, trustee, NULL, &sidLen, NULL, &domLen, &use) || ERROR_INSUFFICIENT_BUFFER == GetLastError()) && NULL != (domain = (TCHAR *)LocalAlloc(LPTR, domLen*sizeof(TCHAR))) && NULL != (pSid = (PSID)LocalAlloc(LPTR, sidLen))) { if (!LookupAccountName(NULL, trustee, pSid, &sidLen, domain, &domLen, &use)) { LocalFree(pSid); pSid = NULL; } } LocalFree(domain); } return (char *)pSid; }
MIKTEXINTERNALFUNC(bool) ReportMiKTeXEvent(unsigned short eventType, unsigned long eventId, ...) { #if ! REPORT_EVENTS UNUSED_ALWAYS(eventType); UNUSED_ALWAYS(eventId); return false; #else vector<const char *> vecStrings; va_list marker; va_start(marker, eventId); for (const char * lpsz = va_arg(marker, const char *); lpsz != nullptr; lpsz = va_arg(marker, const char *)) { vecStrings.push_back(lpsz); } va_end(marker); HANDLE hEventSource = RegisterEventSource(0, SOURCE); if (hEventSource == nullptr) { return false; } PSID pSid = 0; size_t bufSize = 8192; AutoMemoryPointer pBuf(malloc(bufSize)); if (pBuf.Get() == nullptr) { OUT_OF_MEMORY("malloc"); } char szAccountName[BufferSizes::MaxPath]; unsigned long n = BufferSizes::MaxPath; if (GetUserName(szAccountName, &n)) { unsigned long sidSize = static_cast<unsigned long>(bufSize); pSid = reinterpret_cast<PSID>(pBuf.Get()); char szDomainName[BufferSizes::MaxPath]; unsigned long domainNameSize = BufferSizes::MaxPath; SID_NAME_USE use; if (!LookupAccountName(0, szAccountName, pSid, &sidSize, szDomainName, &domainNameSize, &use)) { pSid = 0; } } BOOL done = ReportEvent(hEventSource, eventType, 0, eventId, pSid, static_cast<unsigned short>(vecStrings.size()), 0, &vecStrings[0], 0); DeregisterEventSource(hEventSource); return done ? true : false; #endif }
BOOL kull_m_token_getSidDomainFromName(PCWSTR pName, PSID * pSid, PWSTR * pDomain, PSID_NAME_USE pSidNameUse, LPCWSTR system) { BOOL result = FALSE; SID_NAME_USE sidNameUse; PSID_NAME_USE peUse = pSidNameUse ? pSidNameUse : &sidNameUse; DWORD cbSid = 0, cchReferencedDomainName = 0; if(!LookupAccountName(system, pName, NULL, &cbSid, NULL, &cchReferencedDomainName, peUse) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) { if(*pSid = (PSID) LocalAlloc(LPTR, cbSid * sizeof(wchar_t))) { if(*pDomain = (PWSTR) LocalAlloc(LPTR, cchReferencedDomainName * sizeof(wchar_t))) { result = LookupAccountName(system, pName, *pSid, &cbSid, *pDomain, &cchReferencedDomainName, peUse); if(!result) *pDomain = (PWSTR) LocalFree(*pDomain); } if(!result) *pSid = (PSID) LocalFree(*pSid); } } return result; }
PSID convert_jsstring_to_sid(JSContext * cx, JSString * curMemberString, DWORD * errorCode) { PSID curMember; if(!ConvertStringSidToSid((LPWSTR)JS_GetStringChars(curMemberString), &curMember)) { DWORD sidSize = 0, cbDomain; SID_NAME_USE peUse; *errorCode = GetLastError(); JS_YieldRequest(cx); if(!LookupAccountName(NULL, (LPWSTR)JS_GetStringChars(curMemberString), NULL, &sidSize, NULL, &cbDomain, &peUse) && GetLastError() != ERROR_INSUFFICIENT_BUFFER) { *errorCode = GetLastError(); return NULL; } curMember = (PSID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidSize); JS_YieldRequest(cx); LPTSTR domainName = (LPTSTR)HeapAlloc(GetProcessHeap(), 0, cbDomain * sizeof(TCHAR)); if(!LookupAccountName(NULL, (LPWSTR)JS_GetStringChars(curMemberString), curMember, &sidSize, domainName, &cbDomain, &peUse)) { *errorCode = GetLastError(); HeapFree(GetProcessHeap(), 0, curMember); HeapFree(GetProcessHeap(), 0, domainName); return NULL; } HeapFree(GetProcessHeap(), 0, domainName); *errorCode = ERROR_SUCCESS; } else { DWORD sidSize = GetLengthSid(curMember); PSID retMember = (PSID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidSize); CopySid(sidSize, retMember, curMember); LocalFree(curMember); curMember = retMember; } return curMember; }
//------------------------------------------------------------------------------ //local function part !!! //------------------------------------------------------------------------------ void GetSIDFromUser(char *user, char* rid, char *sid, unsigned int max_size) { BYTE BSid[MAX_PATH]; PSID psid = (PSID)BSid; DWORD sid_size = MAX_PATH; SID_NAME_USE TypeSid; char domain[MAX_PATH]; DWORD domain_size = MAX_PATH; if(LookupAccountName(NULL,(LPCTSTR)user,psid,(LPDWORD)&sid_size,(LPTSTR)domain,(LPDWORD)&domain_size,(PSID_NAME_USE)&TypeSid)) { if (IsValidSid(psid))SidtoUser(psid, user, rid, sid, max_size); } }
PSID name_to_PSID(char *name) { SID_NAME_USE snu; char *sidbuf, domainname[512]; DWORD sidlen, dnamelen; sidlen = 512; sidbuf = (char*)calloc(1, sidlen); dnamelen = sizeof(domainname); if ( FALSE==LookupAccountName(NULL, name, sidbuf, &sidlen, domainname, &dnamelen, &snu) ) { free(sidbuf); return NULL; } return (PSID) sidbuf; }
int LSAUserCommand::executeCommand(LSA_HANDLE handle) { CString accountName = CreateFormatted(L"%s", mySettings->getUserName()); const DWORD sz = 2044; PSID sid = (PSID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz + 1); TCHAR foundDomain[sz+1]; DWORD psz = sz; DWORD pdz = sz; SID_NAME_USE use = SidTypeUser; LOG.LogDebug(L"Call LookupAccountName"); if (0 == LookupAccountName(NULL, accountName, sid, &psz, foundDomain, &pdz, &use)) { LOG.LogErrorFormat(L"Failed to LookupAccountName. %s", LOG.GetLastError()); return 1; } foundDomain[pdz] = L'\0'; LOG.LogDebugFormat(L"LSA Policy opened: Domain %s", foundDomain); return executeCommand(handle, sid); }
static int iwin32_get_sid (const char *name, PSID *ext_sid) { char domain [BUFFER_SIZE]; DWORD domain_size = BUFFER_SIZE; DWORD sid_size = BUFFER_SIZE; SID *sid; SID_NAME_USE account_type; assert (name != NULL); assert (ext_sid != NULL); sid = malloc (sid_size); if (!sid) return 0; if (!LookupAccountName (NULL, name, sid, &sid_size, domain, &domain_size, &account_type)) return 0; *ext_sid = sid; return 1; }