From a9bcc81f821d7c66f623779fa5147e728eb3c388 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 4 May 2024 03:24:41 +0200 Subject: Adding upstream version 3.3.0+dfsg1. Signed-off-by: Daniel Baumann --- winpr/libwinpr/utils/sam.c | 366 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 366 insertions(+) create mode 100644 winpr/libwinpr/utils/sam.c (limited to 'winpr/libwinpr/utils/sam.c') diff --git a/winpr/libwinpr/utils/sam.c b/winpr/libwinpr/utils/sam.c new file mode 100644 index 0000000..31163d9 --- /dev/null +++ b/winpr/libwinpr/utils/sam.c @@ -0,0 +1,366 @@ +/** + * WinPR: Windows Portable Runtime + * Security Accounts Manager (SAM) + * + * Copyright 2012 Marc-Andre Moreau + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "../log.h" + +#ifdef WINPR_HAVE_UNISTD_H +#include +#endif + +#ifdef _WIN32 +#define WINPR_SAM_FILE "C:\\SAM" +#else +#define WINPR_SAM_FILE "/etc/winpr/SAM" +#endif +#define TAG WINPR_TAG("utils") + +struct winpr_sam +{ + FILE* fp; + char* line; + char* buffer; + char* context; + BOOL readOnly; +}; + +static WINPR_SAM_ENTRY* SamEntryFromDataA(LPCSTR User, DWORD UserLength, LPCSTR Domain, + DWORD DomainLength) +{ + WINPR_SAM_ENTRY* entry = calloc(1, sizeof(WINPR_SAM_ENTRY)); + if (!entry) + return NULL; + if (User && (UserLength > 0)) + entry->User = _strdup(User); + entry->UserLength = UserLength; + if (Domain && (DomainLength > 0)) + entry->Domain = _strdup(Domain); + entry->DomainLength = DomainLength; + return entry; +} + +static BOOL SamAreEntriesEqual(const WINPR_SAM_ENTRY* a, const WINPR_SAM_ENTRY* b) +{ + if (!a || !b) + return FALSE; + if (a->UserLength != b->UserLength) + return FALSE; + if (a->DomainLength != b->DomainLength) + return FALSE; + if (strncmp(a->User, b->User, a->UserLength) != 0) + return FALSE; + if (strncmp(a->Domain, b->Domain, a->DomainLength) != 0) + return FALSE; + return TRUE; +} + +WINPR_SAM* SamOpen(const char* filename, BOOL readOnly) +{ + FILE* fp = NULL; + WINPR_SAM* sam = NULL; + + if (!filename) + filename = WINPR_SAM_FILE; + + if (readOnly) + fp = winpr_fopen(filename, "r"); + else + { + fp = winpr_fopen(filename, "r+"); + + if (!fp) + fp = winpr_fopen(filename, "w+"); + } + + if (fp) + { + sam = (WINPR_SAM*)calloc(1, sizeof(WINPR_SAM)); + + if (!sam) + { + fclose(fp); + return NULL; + } + + sam->readOnly = readOnly; + sam->fp = fp; + } + else + { + WLog_DBG(TAG, "Could not open SAM file!"); + return NULL; + } + + return sam; +} + +static BOOL SamLookupStart(WINPR_SAM* sam) +{ + size_t readSize = 0; + INT64 fileSize = 0; + + if (!sam || !sam->fp) + return FALSE; + + _fseeki64(sam->fp, 0, SEEK_END); + fileSize = _ftelli64(sam->fp); + _fseeki64(sam->fp, 0, SEEK_SET); + + if (fileSize < 1) + return FALSE; + + sam->context = NULL; + sam->buffer = (char*)calloc((size_t)fileSize + 2, 1); + + if (!sam->buffer) + return FALSE; + + readSize = fread(sam->buffer, (size_t)fileSize, 1, sam->fp); + + if (!readSize) + { + if (!ferror(sam->fp)) + readSize = (size_t)fileSize; + } + + if (readSize < 1) + { + free(sam->buffer); + sam->buffer = NULL; + return FALSE; + } + + sam->buffer[fileSize] = '\n'; + sam->buffer[fileSize + 1] = '\0'; + sam->line = strtok_s(sam->buffer, "\n", &sam->context); + return TRUE; +} + +static void SamLookupFinish(WINPR_SAM* sam) +{ + free(sam->buffer); + sam->buffer = NULL; + sam->line = NULL; +} + +static BOOL SamReadEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry) +{ + char* p[5]; + size_t LmHashLength = 0; + size_t NtHashLength = 0; + size_t count = 0; + char* cur = NULL; + + if (!sam || !entry || !sam->line) + return FALSE; + + cur = sam->line; + + while ((cur = strchr(cur, ':')) != NULL) + { + count++; + cur++; + } + + if (count < 4) + return FALSE; + + p[0] = sam->line; + p[1] = strchr(p[0], ':') + 1; + p[2] = strchr(p[1], ':') + 1; + p[3] = strchr(p[2], ':') + 1; + p[4] = strchr(p[3], ':') + 1; + LmHashLength = (p[3] - p[2] - 1); + NtHashLength = (p[4] - p[3] - 1); + + if ((LmHashLength != 0) && (LmHashLength != 32)) + return FALSE; + + if ((NtHashLength != 0) && (NtHashLength != 32)) + return FALSE; + + entry->UserLength = (UINT32)(p[1] - p[0] - 1); + entry->User = (LPSTR)malloc(entry->UserLength + 1); + + if (!entry->User) + return FALSE; + + entry->User[entry->UserLength] = '\0'; + entry->DomainLength = (UINT32)(p[2] - p[1] - 1); + memcpy(entry->User, p[0], entry->UserLength); + + if (entry->DomainLength > 0) + { + entry->Domain = (LPSTR)malloc(entry->DomainLength + 1); + + if (!entry->Domain) + { + free(entry->User); + entry->User = NULL; + return FALSE; + } + + memcpy(entry->Domain, p[1], entry->DomainLength); + entry->Domain[entry->DomainLength] = '\0'; + } + else + entry->Domain = NULL; + + if (LmHashLength == 32) + winpr_HexStringToBinBuffer(p[2], LmHashLength, entry->LmHash, sizeof(entry->LmHash)); + + if (NtHashLength == 32) + winpr_HexStringToBinBuffer(p[3], NtHashLength, (BYTE*)entry->NtHash, sizeof(entry->NtHash)); + + return TRUE; +} + +void SamFreeEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry) +{ + if (entry) + { + if (entry->UserLength > 0) + free(entry->User); + + if (entry->DomainLength > 0) + free(entry->Domain); + + free(entry); + } +} + +void SamResetEntry(WINPR_SAM_ENTRY* entry) +{ + if (!entry) + return; + + if (entry->UserLength) + { + free(entry->User); + entry->User = NULL; + } + + if (entry->DomainLength) + { + free(entry->Domain); + entry->Domain = NULL; + } + + ZeroMemory(entry->LmHash, sizeof(entry->LmHash)); + ZeroMemory(entry->NtHash, sizeof(entry->NtHash)); +} + +WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPCSTR User, UINT32 UserLength, LPCSTR Domain, + UINT32 DomainLength) +{ + size_t length = 0; + BOOL found = FALSE; + WINPR_SAM_ENTRY* search = SamEntryFromDataA(User, UserLength, Domain, DomainLength); + WINPR_SAM_ENTRY* entry = (WINPR_SAM_ENTRY*)calloc(1, sizeof(WINPR_SAM_ENTRY)); + + if (!entry || !search) + goto fail; + + if (!SamLookupStart(sam)) + goto fail; + + while (sam->line != NULL) + { + length = strlen(sam->line); + + if (length > 1) + { + if (sam->line[0] != '#') + { + if (!SamReadEntry(sam, entry)) + { + goto out_fail; + } + + if (SamAreEntriesEqual(entry, search)) + { + found = 1; + break; + } + } + } + + SamResetEntry(entry); + sam->line = strtok_s(NULL, "\n", &sam->context); + } + +out_fail: + SamLookupFinish(sam); +fail: + SamFreeEntry(sam, search); + + if (!found) + { + SamFreeEntry(sam, entry); + return NULL; + } + + return entry; +} + +WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPCWSTR User, UINT32 UserLength, LPCWSTR Domain, + UINT32 DomainLength) +{ + WINPR_SAM_ENTRY* entry = NULL; + char* utfUser = NULL; + char* utfDomain = NULL; + size_t userCharLen = 0; + size_t domainCharLen = 0; + + utfUser = ConvertWCharNToUtf8Alloc(User, UserLength / sizeof(WCHAR), &userCharLen); + if (!utfUser) + goto fail; + if (DomainLength > 0) + { + utfDomain = ConvertWCharNToUtf8Alloc(Domain, DomainLength / sizeof(WCHAR), &domainCharLen); + if (!utfDomain) + goto fail; + } + entry = SamLookupUserA(sam, utfUser, (UINT32)userCharLen, utfDomain, (UINT32)domainCharLen); +fail: + free(utfUser); + free(utfDomain); + return entry; +} + +void SamClose(WINPR_SAM* sam) +{ + if (sam != NULL) + { + if (sam->fp) + fclose(sam->fp); + free(sam); + } +} -- cgit v1.2.3