FreeRDP/winpr/libwinpr/utils/sam.c

367 lines
7.1 KiB
C
Raw Normal View History

2012-06-03 07:31:15 +04:00
/**
* WinPR: Windows Portable Runtime
* Security Accounts Manager (SAM)
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* 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.
*/
2022-02-16 12:08:00 +03:00
#include <winpr/config.h>
2012-06-03 07:31:15 +04:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winpr/wtypes.h>
2012-06-03 07:31:15 +04:00
#include <winpr/crt.h>
#include <winpr/sam.h>
#include <winpr/print.h>
#include <winpr/file.h>
2012-06-03 07:31:15 +04:00
2014-08-19 20:24:58 +04:00
#include "../log.h"
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef _WIN32
2019-11-06 17:24:51 +03:00
#define WINPR_SAM_FILE "C:\\SAM"
#else
2019-11-06 17:24:51 +03:00
#define WINPR_SAM_FILE "/etc/winpr/SAM"
#endif
2014-08-19 20:24:58 +04:00
#define TAG WINPR_TAG("utils")
2012-06-03 07:31:15 +04:00
struct winpr_sam
{
FILE* fp;
char* line;
char* buffer;
char* context;
BOOL readOnly;
};
2021-04-16 16:30:54 +03:00
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;
2023-01-11 23:07:59 +03:00
if (User && (UserLength > 0))
entry->User = _strdup(User);
2021-04-16 16:30:54 +03:00
entry->UserLength = UserLength;
2023-01-11 23:07:59 +03:00
if (Domain && (DomainLength > 0))
entry->Domain = _strdup(Domain);
2021-04-16 16:30:54 +03:00
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)
2012-06-03 07:31:15 +04:00
{
FILE* fp = NULL;
WINPR_SAM* sam = NULL;
2012-06-03 07:31:15 +04:00
if (!filename)
filename = WINPR_SAM_FILE;
if (readOnly)
fp = winpr_fopen(filename, "r");
else
{
fp = winpr_fopen(filename, "r+");
2012-06-03 07:31:15 +04:00
if (!fp)
fp = winpr_fopen(filename, "w+");
}
if (fp)
{
2021-04-16 16:30:54 +03:00
sam = (WINPR_SAM*)calloc(1, sizeof(WINPR_SAM));
if (!sam)
{
fclose(fp);
return NULL;
}
sam->readOnly = readOnly;
sam->fp = fp;
2012-06-03 07:31:15 +04:00
}
else
{
WLog_DBG(TAG, "Could not open SAM file!");
return NULL;
}
2012-06-03 07:31:15 +04:00
return sam;
}
static BOOL SamLookupStart(WINPR_SAM* sam)
2012-06-03 07:31:15 +04:00
{
size_t readSize;
INT64 fileSize;
if (!sam || !sam->fp)
return FALSE;
_fseeki64(sam->fp, 0, SEEK_END);
fileSize = _ftelli64(sam->fp);
_fseeki64(sam->fp, 0, SEEK_SET);
2012-06-03 07:31:15 +04:00
if (fileSize < 1)
return FALSE;
2012-06-03 07:31:15 +04:00
sam->context = NULL;
2021-06-16 15:43:07 +03:00
sam->buffer = (char*)calloc((size_t)fileSize + 2, 1);
if (!sam->buffer)
return FALSE;
2021-06-16 15:43:07 +03:00
readSize = fread(sam->buffer, (size_t)fileSize, 1, sam->fp);
if (!readSize)
{
if (!ferror(sam->fp))
2021-06-16 15:43:07 +03:00
readSize = (size_t)fileSize;
}
if (readSize < 1)
2012-06-03 07:31:15 +04:00
{
free(sam->buffer);
sam->buffer = NULL;
return FALSE;
2012-06-03 07:31:15 +04:00
}
sam->buffer[fileSize] = '\n';
sam->buffer[fileSize + 1] = '\0';
sam->line = strtok_s(sam->buffer, "\n", &sam->context);
return TRUE;
2012-06-03 07:31:15 +04:00
}
static void SamLookupFinish(WINPR_SAM* sam)
2012-06-03 07:31:15 +04:00
{
free(sam->buffer);
sam->buffer = NULL;
sam->line = NULL;
}
2019-11-20 13:30:14 +03:00
static BOOL SamReadEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry)
2012-06-03 07:31:15 +04:00
{
char* p[5];
size_t LmHashLength;
size_t NtHashLength;
size_t count = 0;
char* cur;
if (!sam || !entry || !sam->line)
return FALSE;
cur = sam->line;
while ((cur = strchr(cur, ':')) != NULL)
{
count++;
cur++;
}
if (count < 4)
return FALSE;
2012-06-03 07:31:15 +04:00
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;
2014-08-19 20:24:58 +04:00
entry->UserLength = (UINT32)(p[1] - p[0] - 1);
2019-11-06 17:24:51 +03:00
entry->User = (LPSTR)malloc(entry->UserLength + 1);
if (!entry->User)
return FALSE;
entry->User[entry->UserLength] = '\0';
2014-08-19 20:24:58 +04:00
entry->DomainLength = (UINT32)(p[2] - p[1] - 1);
2012-06-03 07:31:15 +04:00
memcpy(entry->User, p[0], entry->UserLength);
if (entry->DomainLength > 0)
{
2019-11-06 17:24:51 +03:00
entry->Domain = (LPSTR)malloc(entry->DomainLength + 1);
if (!entry->Domain)
{
free(entry->User);
entry->User = NULL;
return FALSE;
}
2012-06-03 07:31:15 +04:00
memcpy(entry->Domain, p[1], entry->DomainLength);
entry->Domain[entry->DomainLength] = '\0';
}
else
entry->Domain = NULL;
2012-06-03 07:31:15 +04:00
if (LmHashLength == 32)
winpr_HexStringToBinBuffer(p[2], LmHashLength, entry->LmHash, sizeof(entry->LmHash));
2012-06-03 07:31:15 +04:00
if (NtHashLength == 32)
winpr_HexStringToBinBuffer(p[3], NtHashLength, (BYTE*)entry->NtHash, sizeof(entry->NtHash));
2012-06-04 00:30:15 +04:00
return TRUE;
2012-06-03 07:31:15 +04:00
}
void SamFreeEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry)
{
2012-06-04 00:30:15 +04:00
if (entry)
{
if (entry->UserLength > 0)
free(entry->User);
2012-06-03 07:31:15 +04:00
2012-06-04 00:30:15 +04:00
if (entry->DomainLength > 0)
free(entry->Domain);
2012-06-03 07:31:15 +04:00
2012-06-04 00:30:15 +04:00
free(entry);
}
2012-06-03 07:31:15 +04:00
}
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));
}
2020-11-18 09:51:45 +03:00
WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPCSTR User, UINT32 UserLength, LPCSTR Domain,
UINT32 DomainLength)
2012-06-03 07:31:15 +04:00
{
size_t length;
BOOL found = FALSE;
2021-04-16 16:30:54 +03:00
WINPR_SAM_ENTRY* search = SamEntryFromDataA(User, UserLength, Domain, DomainLength);
WINPR_SAM_ENTRY* entry = (WINPR_SAM_ENTRY*)calloc(1, sizeof(WINPR_SAM_ENTRY));
2021-04-16 16:30:54 +03:00
if (!entry || !search)
goto fail;
if (!SamLookupStart(sam))
2021-04-16 16:30:54 +03:00
goto fail;
2012-06-03 07:31:15 +04:00
while (sam->line != NULL)
{
length = strlen(sam->line);
2012-06-03 07:31:15 +04:00
if (length > 1)
{
if (sam->line[0] != '#')
{
if (!SamReadEntry(sam, entry))
{
goto out_fail;
}
2012-06-03 07:31:15 +04:00
2021-04-16 16:30:54 +03:00
if (SamAreEntriesEqual(entry, search))
2012-06-03 07:31:15 +04:00
{
found = 1;
break;
}
}
}
SamResetEntry(entry);
2020-05-19 09:01:48 +03:00
sam->line = strtok_s(NULL, "\n", &sam->context);
2012-06-03 07:31:15 +04:00
}
out_fail:
2012-06-03 07:31:15 +04:00
SamLookupFinish(sam);
2021-04-16 16:30:54 +03:00
fail:
SamFreeEntry(sam, search);
2012-06-03 07:31:15 +04:00
if (!found)
{
2021-04-16 16:30:54 +03:00
SamFreeEntry(sam, entry);
2012-06-03 07:31:15 +04:00
return NULL;
}
return entry;
}
2020-11-18 09:51:45 +03:00
WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPCWSTR User, UINT32 UserLength, LPCWSTR Domain,
UINT32 DomainLength)
2012-06-03 07:31:15 +04:00
{
2021-04-16 16:30:54 +03:00
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)
2021-04-16 16:30:54 +03:00
goto fail;
if (DomainLength > 0)
{
utfDomain = ConvertWCharNToUtf8Alloc(Domain, DomainLength / sizeof(WCHAR), &domainCharLen);
if (!utfDomain)
goto fail;
}
entry = SamLookupUserA(sam, utfUser, userCharLen, utfDomain, domainCharLen);
2021-04-16 16:30:54 +03:00
fail:
free(utfUser);
free(utfDomain);
2012-06-03 07:31:15 +04:00
return entry;
}
void SamClose(WINPR_SAM* sam)
{
if (sam != NULL)
{
if (sam->fp)
fclose(sam->fp);
2012-06-03 07:31:15 +04:00
free(sam);
}
}