utils.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Logon GINA DLL msgina.dll
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Miscellaneous utility functions.
 * COPYRIGHT:   Copyright 2006 Hervé Poussineau <hpoussin@reactos.org>
 *              Copyright 2014 Eric Kohl <eric.kohl@reactos.org>
 *              Copyright 2025 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
 */
 
#include "msgina.h"
 
LONG
RegOpenLoggedOnHKCU(
    _In_opt_ HANDLE hUserToken,
    _In_ REGSAM samDesired,
    _Out_ PHKEY phkResult)
{
    LONG rc;
 
    /* Impersonate the logged-on user if necessary */
    if (hUserToken && !ImpersonateLoggedOnUser(hUserToken))
    {
        rc = GetLastError();
        ERR("ImpersonateLoggedOnUser() failed with error %ld\n", rc);
        return rc;
    }
 
    /* Open the logged-on user HKCU key */
    rc = RegOpenCurrentUser(samDesired, phkResult);
 
    /* Revert the impersonation */
    if (hUserToken)
        RevertToSelf();
 
    return rc;
}
 
LONG
ReadRegSzValue(
    _In_ HKEY hKey,
    _In_ PCWSTR pszValue,
    _Out_ PWSTR* pValue)
{
    LONG rc;
    DWORD dwType;
    DWORD cbData = 0;
    PWSTR Value;
 
    *pValue = NULL;
    rc = RegQueryValueExW(hKey, pszValue, NULL, &dwType, NULL, &cbData);
    if (rc != ERROR_SUCCESS)
        return rc;
    if (dwType != REG_SZ)
        return ERROR_UNSUPPORTED_TYPE;
    Value = HeapAlloc(GetProcessHeap(), 0, cbData + sizeof(WCHAR));
    if (!Value)
        return ERROR_NOT_ENOUGH_MEMORY;
    rc = RegQueryValueExW(hKey, pszValue, NULL, NULL, (PBYTE)Value, &cbData);
    if (rc != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, Value);
        return rc;
    }
    /* NULL-terminate the string */
    Value[cbData / sizeof(WCHAR)] = UNICODE_NULL;
 
    *pValue = Value;
    return ERROR_SUCCESS;
}
 
LONG
ReadRegDwordValue(
    _In_ HKEY hKey,
    _In_ PCWSTR pszValue,
    _Out_ PDWORD pValue)
{
    LONG rc;
    DWORD dwValue, dwType, cbData;
    /* Buffer big enough to hold the NULL-terminated string L"4294967295",
     * corresponding to the literal 0xFFFFFFFF (MAXULONG) in decimal. */
    WCHAR Buffer[sizeof("4294967295")];
    C_ASSERT(sizeof(Buffer) >= sizeof(DWORD));
 
    cbData = sizeof(Buffer);
    rc = RegQueryValueExW(hKey, pszValue, NULL, &dwType, (PBYTE)&Buffer, &cbData);
    if (rc != ERROR_SUCCESS)
        return rc;
 
    if (dwType == REG_DWORD)
    {
        if (cbData != sizeof(dwValue))
            return ERROR_INVALID_DATA; // ERROR_DATATYPE_MISMATCH;
        dwValue = *(PDWORD)Buffer;
    }
    else if (dwType == REG_SZ)
    {
        PWCHAR pEnd = NULL;
        Buffer[cbData / sizeof(WCHAR) - 1] = UNICODE_NULL;
        dwValue = wcstoul(Buffer, &pEnd, 0);
        if (*pEnd) // Don't consider REG_SZ to be supported in this case!
            return ERROR_UNSUPPORTED_TYPE;
    }
    else
    {
        return ERROR_UNSUPPORTED_TYPE;
    }
 
    *pValue = dwValue;
    return ERROR_SUCCESS;
}
 
BOOL
TestTokenPrivilege(
    _In_opt_ HANDLE hToken,
    _In_ ULONG Privilege)
{
    LUID PrivilegeLuid = {Privilege, 0};
    HANDLE hNewToken = NULL;
    PTOKEN_PRIVILEGES pTokenPriv;
    DWORD dwLength;
    BOOL ret = FALSE;
 
    if (!hToken)
    {
        /* Open effective token */
        ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hNewToken);
        if (!ret && (GetLastError() == ERROR_NO_TOKEN))
            ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hNewToken);
        if (!ret || !hNewToken)
            return FALSE;
        hToken = hNewToken;
    }
 
    dwLength = 0;
    ret = GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwLength);
    if (!ret && (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
        goto Quit;
 
    ret = FALSE;
    pTokenPriv = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR, dwLength);
    if (!pTokenPriv)
        goto Quit;
 
    if (GetTokenInformation(hToken, TokenPrivileges, pTokenPriv, dwLength, &dwLength))
    {
        DWORD i, cPrivs = pTokenPriv->PrivilegeCount;
        for (i = 0; !ret && i < cPrivs; ++i)
        {
            ret = RtlEqualLuid(&PrivilegeLuid, &pTokenPriv->Privileges[i].Luid);
        }
    }
 
    LocalFree(pTokenPriv);
 
Quit:
    if (hToken == hNewToken)
        CloseHandle(hNewToken);
    return ret;
}
 
PWSTR
DuplicateString(
    _In_opt_ PCWSTR Str)
{
    PWSTR NewStr;
    SIZE_T cb;
 
    if (!Str)
        return NULL;
 
    cb = (wcslen(Str) + 1) * sizeof(WCHAR);
    if ((NewStr = LocalAlloc(LMEM_FIXED, cb)))
        memcpy(NewStr, Str, cb);
    return NewStr;
}