1028 lines
39 KiB
C++
1028 lines
39 KiB
C++
/***
|
|
Copyright (C) 2023 J Reece Wilson (a/k/a "Reece"). All rights reserved.
|
|
|
|
File: AuProcAddresses.NT.cpp
|
|
Date: 2023-2-16
|
|
Author: Reece
|
|
***/
|
|
#include <AuroraEnvironment.h>
|
|
|
|
#if defined(AURORA_PLATFORM_WIN32)
|
|
#define _WIN32_WINNT 0x0602
|
|
#endif
|
|
|
|
#include <RuntimeInternal.hpp>
|
|
#include "Source/Threading/Primitives/AuConditionMutex.NT.hpp"
|
|
|
|
#define AURORA_HAS_LOAD_PGKD
|
|
#define AURORA_HAS_GET_PROC_NONWIN32
|
|
|
|
#if !defined(AURORA_RUNITIME_NO_PROFILE_SYMBOL)
|
|
extern "C"
|
|
{
|
|
// As much as I despise third-party drivers matching module names and pattern matching,
|
|
// we may as well provide some hint for:
|
|
// * Windows emulators
|
|
// * Future first party win32 compatibility layers
|
|
// * Drivers checking for the vintage
|
|
// * Non-standard PE linkers (Aurora::AddBlockedDLL(...) is valid)
|
|
AUKN_SYM int NT_APPLICATION_COMPAT_AURORA_RUNTIME_ALPHA;
|
|
AUKN_SYM int NT_APPLICATION_COMPAT_AURORA_RUNTIME;
|
|
}
|
|
#endif
|
|
|
|
namespace Aurora::Memory
|
|
{
|
|
AuUInt32 RoundPageUp(AuUInt32 value);
|
|
}
|
|
|
|
namespace Aurora
|
|
{
|
|
static bool gShouldResPathDoNothing {}; // always
|
|
static bool gShouldResPathDoNothing2 {}; // win11 singleshot
|
|
static ULONG gLastActualResolution {};
|
|
|
|
#if !defined(AURORA_PLATFORM_WIN32)
|
|
HMODULE UWPLibraryW(LPCWSTR lpLibFileName);
|
|
|
|
FARPROC UWPProcAddress(HMODULE hModule,
|
|
LPCSTR lpProcName);
|
|
|
|
HANDLE __stdcall UWPCreateFileMappingA(HANDLE hFile,
|
|
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
|
DWORD flProtect,
|
|
DWORD dwMaximumSizeHigh,
|
|
DWORD dwMaximumSizeLow,
|
|
LPCSTR lpName);
|
|
|
|
HANDLE __stdcall UWPOpenFileMappingA(DWORD dwDesiredAccess,
|
|
BOOL bInheritHandle,
|
|
LPCSTR lpName);
|
|
|
|
LPVOID __stdcall UWPMapViewOfFile(HANDLE hFileMappingObject,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwFileOffsetHigh,
|
|
DWORD dwFileOffsetLow,
|
|
SIZE_T dwNumberOfBytesToMap);
|
|
#endif
|
|
|
|
#if !defined(AURORA_DLL_BLACKLIST)
|
|
static AuUInt32 gBlockedDLLTable[128] {};
|
|
#else
|
|
static AuUInt32 gBlockedDLLTable[128] { AURORA_DLL_BLACKLIST };
|
|
#endif
|
|
|
|
AUKN_SYM bool AddBlockedDLL(const char *pString)
|
|
{
|
|
if (!pString)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto uHash = AuFnv1a32Runtime(pString, strlen(pString));
|
|
|
|
for (AU_ITERATE_N(i, AuArraySize(gBlockedDLLTable)))
|
|
{
|
|
if (gBlockedDLLTable[i])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
gBlockedDLLTable[i] = uHash;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool IsBlocked(const char *pString)
|
|
{
|
|
auto uHash = AuFnv1a32Runtime(pString, strlen(pString));
|
|
|
|
for (AU_ITERATE_N(i, AuArraySize(gBlockedDLLTable)))
|
|
{
|
|
auto uCurrent = gBlockedDLLTable[i];
|
|
|
|
if (uCurrent == uHash)
|
|
{
|
|
return true;
|
|
}
|
|
else if (uCurrent == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void InitNTAddressesForClock()
|
|
{
|
|
#if defined(AURORA_PLATFORM_WIN32)
|
|
// We just need a partial AuSwInfo pass to work in order to setup the clocks at TLS callback-time
|
|
// Why? rng isnt ready either. We need the fallback clock to work.
|
|
pLoadLibraryW = LoadLibraryW;
|
|
pGetProcAddress = GetProcAddress;
|
|
|
|
#define ADD_LOAD_LIB(name) \
|
|
HMODULE h ## name {}; \
|
|
h ## name = GetModuleHandleW(k## name ## DllName); \
|
|
if (!h ## name) \
|
|
{ \
|
|
h ## name = pLoadLibraryW(k## name ## DllName); \
|
|
} \
|
|
|
|
#define ADD_GET_PROC(name, proc) \
|
|
if (h ## name) \
|
|
{ \
|
|
p ## proc = AuReinterpretCast<decltype(p ## proc)>(pGetProcAddress(h ## name, #proc)); \
|
|
} \
|
|
|
|
ADD_LOAD_LIB(Kernel32);
|
|
#if 0
|
|
ADD_LOAD_LIB(AdvancedApi);
|
|
#endif
|
|
|
|
ADD_GET_PROC(Kernel32, VerifyVersionInfoW)
|
|
ADD_GET_PROC(Kernel32, VerSetConditionMask)
|
|
ADD_GET_PROC(Kernel32, QueryPerformanceCounter)
|
|
ADD_GET_PROC(Kernel32, QueryPerformanceFrequency)
|
|
|
|
#if 0
|
|
ADD_GET_PROC(AdvancedApi, RegSetValueExW)
|
|
ADD_GET_PROC(AdvancedApi, RegCloseKey)
|
|
ADD_GET_PROC(AdvancedApi, RegOpenKeyExW)
|
|
ADD_GET_PROC(AdvancedApi, RegQueryValueExW)
|
|
#endif
|
|
|
|
#undef ADD_GET_PROC
|
|
#undef ADD_LOAD_LIB
|
|
#else
|
|
InitNTAddresses();
|
|
#endif
|
|
}
|
|
|
|
void InitNTAddresses()
|
|
{
|
|
#if defined(AURORA_PLATFORM_WIN32)
|
|
pLoadLibraryW = LoadLibraryW;
|
|
pGetProcAddress = GetProcAddress;
|
|
|
|
#define ADD_LOAD_LIB(name) \
|
|
\
|
|
HMODULE h ## name {}; \
|
|
if (!IsBlocked(#name)) \
|
|
{ \
|
|
h ## name = GetModuleHandleW(k## name ## DllName); \
|
|
if (!h ## name) \
|
|
{ \
|
|
h ## name = pLoadLibraryW(k## name ## DllName); \
|
|
} \
|
|
}
|
|
|
|
ADD_LOAD_LIB(Kernel32);
|
|
ADD_LOAD_LIB(Nt);
|
|
ADD_LOAD_LIB(KernelBase);
|
|
ADD_LOAD_LIB(Sync);
|
|
ADD_LOAD_LIB(WS2);
|
|
ADD_LOAD_LIB(AdvancedApi);
|
|
ADD_LOAD_LIB(BCrypt);
|
|
ADD_LOAD_LIB(Theme);
|
|
ADD_LOAD_LIB(Shell);
|
|
ADD_LOAD_LIB(PSAPILegacy);
|
|
ADD_LOAD_LIB(DbgHelper);
|
|
ADD_LOAD_LIB(WinTrust);
|
|
ADD_LOAD_LIB(IPHelper);
|
|
ADD_LOAD_LIB(COM);
|
|
ADD_LOAD_LIB(User32);
|
|
ADD_LOAD_LIB(SetupAPI);
|
|
ADD_LOAD_LIB(Router);
|
|
ADD_LOAD_LIB(CredUI);
|
|
|
|
#define ADD_GET_PROC(name, proc) \
|
|
if (!IsBlocked(#proc)) \
|
|
{ \
|
|
if (h ## name) \
|
|
{ \
|
|
p ## proc = AuReinterpretCast<decltype(p ## proc)>(pGetProcAddress(h ## name, #proc)); \
|
|
} \
|
|
}
|
|
|
|
#define ADD_GET_PROC_BI(name, name2, proc) \
|
|
if (!IsBlocked(#proc)) \
|
|
{ \
|
|
p ## proc = nullptr; \
|
|
if (h ## name) \
|
|
{ \
|
|
p ## proc = AuReinterpretCast<decltype(p ## proc)>(pGetProcAddress(h ## name, #proc)); \
|
|
} \
|
|
if (!p ## proc) \
|
|
{ \
|
|
if (h ## name2) \
|
|
{ \
|
|
p ## proc = AuReinterpretCast<decltype(p ## proc)>(pGetProcAddress(h ## name2, #proc));\
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define ADD_GET_PROC_BI2(name, name2, proc, proc2) \
|
|
if (!IsBlocked(#proc)) \
|
|
{ \
|
|
p ## proc2 = nullptr; \
|
|
if (h ## name) \
|
|
{ \
|
|
p ## proc2 = AuReinterpretCast<decltype(p ## proc2)>(pGetProcAddress(h ## name, #proc)); \
|
|
} \
|
|
if (!p ## proc2) \
|
|
{ \
|
|
if (h ## name2) \
|
|
{ \
|
|
p ## proc2 = AuReinterpretCast<decltype(p ## proc2)>(pGetProcAddress(h ## name2, #proc2)); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define ADD_GET_PROC_INTERNAL_MAP(name, proc, symbol) \
|
|
if (!IsBlocked(#proc)) \
|
|
{ \
|
|
if (h ## name) \
|
|
{ \
|
|
p ## proc = AuReinterpretCast<decltype(p ## proc)>(pGetProcAddress(h ## name, #symbol)); \
|
|
} \
|
|
}
|
|
|
|
if (pRtlGetVersion)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ADD_GET_PROC(Nt, RtlGetVersion)
|
|
ADD_GET_PROC(Nt, NtDelayExecution)
|
|
ADD_GET_PROC(Nt, NtWaitForKeyedEvent)
|
|
ADD_GET_PROC(Nt, NtReleaseKeyedEvent)
|
|
ADD_GET_PROC(Nt, NtOpenKeyedEvent)
|
|
ADD_GET_PROC(Nt, NtCreateKeyedEvent)
|
|
ADD_GET_PROC(Nt, RtlWaitOnAddress)
|
|
ADD_GET_PROC(Nt, RtlWakeByAddressAll)
|
|
ADD_GET_PROC(Nt, RtlWakeAddressSingle)
|
|
ADD_GET_PROC(Nt, ZwSetTimerResolution)
|
|
ADD_GET_PROC(Nt, ZwQueryTimerResolution)
|
|
ADD_GET_PROC(Nt, NtQueryInformationProcess)
|
|
ADD_GET_PROC(Nt, NtNotifyChangeDirectoryFile)
|
|
ADD_GET_PROC(Nt, NtTerminateProcess)
|
|
ADD_GET_PROC(Nt, NtQuerySymbolicLinkObject)
|
|
ADD_GET_PROC(Nt, NtOpenSymbolicLinkObject)
|
|
ADD_GET_PROC(Nt, NtWaitForMultipleObjects)
|
|
ADD_GET_PROC(Nt, NtQuerySystemInformation)
|
|
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, VirtualAlloc2)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, MapViewOfFile)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, MapViewOfFile3)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, UnmapViewOfFile2)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, CreateFileW)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, CreateFile2W)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, GetTempPathW)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, CreateFileMappingA)
|
|
ADD_GET_PROC_BI(Kernel32, KernelBase, OpenFileMappingA)
|
|
|
|
ADD_GET_PROC(Kernel32, GetSystemCpuSetInformation)
|
|
ADD_GET_PROC(Kernel32, GetLogicalProcessorInformation)
|
|
ADD_GET_PROC(Kernel32, SetThreadDescription)
|
|
ADD_GET_PROC(Kernel32, SetThreadInformation)
|
|
ADD_GET_PROC(Kernel32, SetThreadSelectedCpuSets)
|
|
ADD_GET_PROC(Kernel32, PrefetchVirtualMemory)
|
|
ADD_GET_PROC(Kernel32, SetThreadGroupAffinity)
|
|
ADD_GET_PROC(Kernel32, FindFirstStreamW)
|
|
ADD_GET_PROC(Kernel32, FindNextStreamW)
|
|
ADD_GET_PROC(Kernel32, FindClose)
|
|
ADD_GET_PROC(Kernel32, CancelIoEx)
|
|
ADD_GET_PROC(Kernel32, CancelSynchronousIo)
|
|
ADD_GET_PROC(Kernel32, SetFileInformationByHandle)
|
|
ADD_GET_PROC(Kernel32, GetLocaleInfoEx)
|
|
ADD_GET_PROC(Kernel32, LCIDToLocaleName)
|
|
ADD_GET_PROC(Kernel32, GetLocaleInfoW)
|
|
ADD_GET_PROC(Kernel32, GetThreadId)
|
|
ADD_GET_PROC(Kernel32, VerifyVersionInfoW)
|
|
ADD_GET_PROC(Kernel32, VerSetConditionMask)
|
|
ADD_GET_PROC(Kernel32, QueryPerformanceCounter)
|
|
ADD_GET_PROC(Kernel32, QueryPerformanceFrequency)
|
|
ADD_GET_PROC(Kernel32, RemoveDllDirectory)
|
|
ADD_GET_PROC(Kernel32, AddDllDirectory)
|
|
ADD_GET_PROC(Kernel32, SetProcessInformation)
|
|
ADD_GET_PROC(Kernel32, GetNamedPipeClientProcessId)
|
|
ADD_GET_PROC(Kernel32, Module32FirstW)
|
|
ADD_GET_PROC(Kernel32, Module32NextW)
|
|
ADD_GET_PROC(Kernel32, CreateJobObjectW)
|
|
ADD_GET_PROC(Kernel32, CreateWaitableTimerExW)
|
|
|
|
ADD_GET_PROC(Kernel32, GetConsoleScreenBufferInfo)
|
|
ADD_GET_PROC(Kernel32, SetConsoleScreenBufferSize)
|
|
ADD_GET_PROC(Kernel32, SetConsoleWindowInfo)
|
|
ADD_GET_PROC(Kernel32, CreateConsoleScreenBuffer)
|
|
ADD_GET_PROC(Kernel32, SetConsoleCursorPosition)
|
|
ADD_GET_PROC(Kernel32, FillConsoleOutputCharacterW)
|
|
ADD_GET_PROC(Kernel32, FillConsoleOutputAttribute)
|
|
ADD_GET_PROC(Kernel32, SetConsoleTextAttribute)
|
|
ADD_GET_PROC(Kernel32, SetConsoleActiveScreenBuffer)
|
|
ADD_GET_PROC(Kernel32, ScrollConsoleScreenBufferW)
|
|
ADD_GET_PROC(Kernel32, WriteConsoleInputW)
|
|
ADD_GET_PROC(Kernel32, WriteConsoleW)
|
|
ADD_GET_PROC(Kernel32, ReadConsoleInputW)
|
|
ADD_GET_PROC(Kernel32, GetNumberOfConsoleInputEvents)
|
|
|
|
ADD_GET_PROC_BI2(Kernel32, PSAPILegacy, K32GetProcessMemoryInfo, GetProcessMemoryInfo)
|
|
|
|
ADD_GET_PROC(Sync, WaitOnAddress)
|
|
ADD_GET_PROC(Sync, WakeByAddressSingle)
|
|
ADD_GET_PROC(Sync, WakeByAddressAll)
|
|
|
|
ADD_GET_PROC(DbgHelper, UnDecorateSymbolName)
|
|
ADD_GET_PROC(DbgHelper, MiniDumpWriteDump)
|
|
ADD_GET_PROC(DbgHelper, SymInitialize)
|
|
ADD_GET_PROC(DbgHelper, SymGetModuleBase64)
|
|
ADD_GET_PROC(DbgHelper, SymGetLineFromAddr64)
|
|
ADD_GET_PROC(DbgHelper, SymFunctionTableAccess64)
|
|
ADD_GET_PROC(DbgHelper, StackWalk64)
|
|
|
|
ADD_GET_PROC(WS2, GetAddrInfoExW)
|
|
ADD_GET_PROC(WS2, GetAddrInfoExCancel)
|
|
ADD_GET_PROC(WS2, FreeAddrInfoExW)
|
|
ADD_GET_PROC(WS2, getaddrinfo)
|
|
ADD_GET_PROC(WS2, freeaddrinfo)
|
|
ADD_GET_PROC(WS2, listen)
|
|
ADD_GET_PROC(WS2, bind)
|
|
ADD_GET_PROC(WS2, closesocket)
|
|
ADD_GET_PROC(WS2, shutdown)
|
|
ADD_GET_PROC(WS2, getpeername)
|
|
ADD_GET_PROC(WS2, getsockname)
|
|
ADD_GET_PROC(WS2, ioctlsocket)
|
|
ADD_GET_PROC(WS2, setsockopt)
|
|
ADD_GET_PROC(WS2, WSAStartup)
|
|
ADD_GET_PROC(WS2, WSAIoctl)
|
|
ADD_GET_PROC(WS2, WSAGetLastError)
|
|
ADD_GET_PROC(WS2, WSASocketW)
|
|
ADD_GET_PROC(WS2, WSARecvFrom)
|
|
ADD_GET_PROC(WS2, WSARecv)
|
|
ADD_GET_PROC(WS2, WSASendTo)
|
|
ADD_GET_PROC(WS2, WSASend)
|
|
ADD_GET_PROC(WS2, WSAStringToAddressA)
|
|
|
|
ADD_GET_PROC(WinTrust, WinVerifyTrust)
|
|
|
|
ADD_GET_PROC(IPHelper, GetAdaptersAddresses)
|
|
ADD_GET_PROC(IPHelper, GetAdaptersInfo)
|
|
|
|
ADD_GET_PROC(AdvancedApi, CryptAcquireContextW)
|
|
ADD_GET_PROC(AdvancedApi, CryptReleaseContext)
|
|
ADD_GET_PROC(AdvancedApi, CryptGenRandom)
|
|
|
|
ADD_GET_PROC(AdvancedApi, RegSetValueExW)
|
|
ADD_GET_PROC(AdvancedApi, RegCloseKey)
|
|
ADD_GET_PROC(AdvancedApi, RegOpenKeyExW)
|
|
ADD_GET_PROC(AdvancedApi, RegQueryValueExW)
|
|
|
|
ADD_GET_PROC(AdvancedApi, DeregisterEventSource)
|
|
ADD_GET_PROC(AdvancedApi, RegisterEventSourceW)
|
|
ADD_GET_PROC(AdvancedApi, ReportEventW)
|
|
|
|
ADD_GET_PROC(AdvancedApi, SetEntriesInAclA)
|
|
ADD_GET_PROC(AdvancedApi, AllocateAndInitializeSid)
|
|
ADD_GET_PROC(AdvancedApi, SetNamedSecurityInfoW)
|
|
ADD_GET_PROC(AdvancedApi, FreeSid)
|
|
|
|
// privilege escalation
|
|
ADD_GET_PROC(AdvancedApi, CreateProcessWithLogonW);
|
|
ADD_GET_PROC(AdvancedApi, CreateProcessAsUserW);
|
|
ADD_GET_PROC(AdvancedApi, AdjustTokenPrivileges);
|
|
ADD_GET_PROC(AdvancedApi, RevertToSelf);
|
|
ADD_GET_PROC(AdvancedApi, SetTokenInformation);
|
|
ADD_GET_PROC(AdvancedApi, GetSidSubAuthorityCount);
|
|
ADD_GET_PROC(AdvancedApi, GetSidSubAuthority);
|
|
ADD_GET_PROC(AdvancedApi, LogonUserW);
|
|
ADD_GET_PROC(AdvancedApi, OpenProcessToken);
|
|
ADD_GET_PROC(AdvancedApi, SetThreadToken);
|
|
ADD_GET_PROC(AdvancedApi, SetSecurityInfo);
|
|
ADD_GET_PROC(AdvancedApi, GetUserNameW);
|
|
ADD_GET_PROC(AdvancedApi, DuplicateTokenEx);
|
|
ADD_GET_PROC(AdvancedApi, LookupAccountSidW);
|
|
ADD_GET_PROC(AdvancedApi, GetTokenInformation);
|
|
ADD_GET_PROC(AdvancedApi, SetSecurityDescriptorDacl);
|
|
ADD_GET_PROC(AdvancedApi, InitializeSecurityDescriptor);
|
|
ADD_GET_PROC(AdvancedApi, LookupAccountNameW);
|
|
ADD_GET_PROC(AdvancedApi, LookupPrivilegeValueA);
|
|
ADD_GET_PROC(AdvancedApi, LsaOpenPolicy);
|
|
ADD_GET_PROC(AdvancedApi, LsaClose);
|
|
ADD_GET_PROC(AdvancedApi, LsaAddAccountRights);
|
|
|
|
ADD_GET_PROC_INTERNAL_MAP(AdvancedApi, RtlGenRandom, SystemFunction036)
|
|
|
|
ADD_GET_PROC(BCrypt, BCryptGenRandom)
|
|
|
|
ADD_GET_PROC(Theme, SetWindowTheme)
|
|
|
|
ADD_GET_PROC(COM, CoInitializeEx)
|
|
ADD_GET_PROC(COM, CoUninitialize)
|
|
ADD_GET_PROC(COM, CoTaskMemFree)
|
|
|
|
ADD_GET_PROC(Shell, SHGetKnownFolderPath)
|
|
ADD_GET_PROC(Shell, SHGetFolderPathA)
|
|
ADD_GET_PROC(Shell, CommandLineToArgvW)
|
|
ADD_GET_PROC(Shell, ShellExecuteW)
|
|
ADD_GET_PROC(Shell, ILCreateFromPathW)
|
|
ADD_GET_PROC(Shell, ILFree)
|
|
ADD_GET_PROC(Shell, SHOpenFolderAndSelectItems)
|
|
|
|
ADD_GET_PROC(User32, GetClipboardData);
|
|
ADD_GET_PROC(User32, MapVirtualKeyA);
|
|
ADD_GET_PROC(User32, CloseClipboard);
|
|
ADD_GET_PROC(User32, GetWindowThreadProcessId);
|
|
ADD_GET_PROC(User32, SendMessageA);
|
|
ADD_GET_PROC(User32, EnumThreadWindows);
|
|
ADD_GET_PROC(User32, DispatchMessageW);
|
|
ADD_GET_PROC(User32, TranslateMessage);
|
|
ADD_GET_PROC(User32, MsgWaitForMultipleObjectsEx);
|
|
ADD_GET_PROC(User32, MsgWaitForMultipleObjects);
|
|
ADD_GET_PROC(User32, PeekMessageW);
|
|
ADD_GET_PROC(User32, SetPropW);
|
|
ADD_GET_PROC(User32, OpenClipboard);
|
|
|
|
ADD_GET_PROC(SetupAPI, SetupDiEnumDeviceInterfaces);
|
|
ADD_GET_PROC(SetupAPI, SetupDiDestroyDeviceInfoList);
|
|
ADD_GET_PROC(SetupAPI, SetupDiGetClassDevsW);
|
|
ADD_GET_PROC(SetupAPI, SetupDiGetDeviceRegistryPropertyA);
|
|
ADD_GET_PROC(SetupAPI, SetupDiGetDeviceInterfaceDetailW);
|
|
|
|
ADD_GET_PROC(Router, WNetCloseEnum);
|
|
ADD_GET_PROC(Router, WNetEnumResourceW);
|
|
ADD_GET_PROC(Router, WNetOpenEnumW);
|
|
ADD_GET_PROC(Router, WNetGetUniversalNameW);
|
|
|
|
ADD_GET_PROC(CredUI, CredUIPromptForWindowsCredentialsW);
|
|
ADD_GET_PROC(CredUI, CredUnPackAuthenticationBufferW);
|
|
|
|
if (pNtCreateKeyedEvent &&
|
|
Threading::Primitives::gKeyedEventHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
if (!gUseNativeWaitCondvar)
|
|
{
|
|
SysAssert(pNtCreateKeyedEvent);
|
|
pNtCreateKeyedEvent(&Threading::Primitives::gKeyedEventHandle, -1, NULL, 0);
|
|
}
|
|
}
|
|
|
|
#else
|
|
pLoadLibraryW = UWPLibraryW;
|
|
pGetProcAddress = UWPProcAddress;
|
|
|
|
pCreateFile2W = CreateFile2FromAppW;
|
|
pCreateFileMappingFromApp = CreateFileMappingFromApp;
|
|
pOpenFileMappingFromApp = OpenFileMappingFromApp;
|
|
pMapViewOfFileFromApp = MapViewOfFileFromApp;
|
|
pCreateFileMappingA = UWPCreateFileMappingA;
|
|
pOpenFileMappingA = UWPOpenFileMappingA;
|
|
pMapViewOfFile = UWPMapViewOfFile;
|
|
|
|
pWaitOnAddress = WaitOnAddress;
|
|
pWakeByAddressSingle = WakeByAddressSingle;
|
|
pWakeByAddressAll = WakeByAddressAll;
|
|
pVirtualAlloc2 = VirtualAlloc2FromApp;
|
|
pMapViewOfFile3 = MapViewOfFile3FromApp;
|
|
|
|
pCancelIoEx = CancelIoEx;
|
|
pCancelSynchronousIo = CancelSynchronousIo;
|
|
|
|
pGetLocaleInfoEx = GetLocaleInfoEx;
|
|
|
|
pLCIDToLocaleName = LCIDToLocaleName;
|
|
|
|
pSetFileInformationByHandle = SetFileInformationByHandle;
|
|
|
|
pFindClose = FindClose;
|
|
|
|
pGetTempPathW = GetTempPath2W;
|
|
|
|
pGetSystemCpuSetInformation = GetSystemCpuSetInformation;
|
|
pGetLogicalProcessorInformation = GetLogicalProcessorInformation;
|
|
|
|
pSetThreadInformation = SetThreadInformation;
|
|
pSetThreadDescription = SetThreadDescription;
|
|
pSetThreadSelectedCpuSets = SetThreadSelectedCpuSets;
|
|
|
|
pGetAddrInfoExCancel = GetAddrInfoExCancel;
|
|
|
|
pPrefetchVirtualMemory = PrefetchVirtualMemory;
|
|
|
|
pQueryPerformanceCounter = decltype(pQueryPerformanceCounter)(QueryPerformanceCounter);
|
|
pQueryPerformanceFrequency = decltype(pQueryPerformanceFrequency)(QueryPerformanceFrequency);
|
|
|
|
// https://github.com/LWJGL/lwjgl3/blob/master/modules/lwjgl/remotery/src/main/c/Remotery.c#L1188
|
|
// Xbox main SDK has a better API we should use
|
|
// So...
|
|
// TODO: Xbox One and later: https://github.com/microsoft/Xbox-ATG-Samples/blob/main/XDKSamples/Graphics/AdvancedESRAM12/PageAllocator.cpp#L193-L206
|
|
// Require AuProcess for that given target
|
|
|
|
pUnmapViewOfFile2 = UnmapViewOfFile2; // < isn't portable but
|
|
// "This topic lists the Win32 APIs that are part of the Universal Windows Platform (UWP) and that are implemented by all Windows 10 devices."
|
|
// UnmapViewOfFile2 -> Introduced into api-ms-win-core-memory-l1-1-5.dll in 10.0.17134.
|
|
|
|
pNtDelayExecution = nullptr /* ... (you dont need it, but it'll help a ton for SleepNs) */;
|
|
|
|
pGetAddrInfoExW = GetAddrInfoExW;
|
|
pGetAddrInfoExCancel = GetAddrInfoExCancel;
|
|
pFreeAddrInfoExW = FreeAddrInfoExW;
|
|
pgetaddrinfo = getaddrinfo;
|
|
pfreeaddrinfo = freeaddrinfo;
|
|
plisten = listen;
|
|
pbind = bind;
|
|
pclosesocket = closesocket;
|
|
pshutdown = shutdown;
|
|
pgetpeername = getpeername;
|
|
pgetsockname = getsockname;
|
|
pioctlsocket = ioctlsocket;
|
|
psetsockopt = setsockopt;
|
|
pWSAStartup = WSAStartup;
|
|
pWSAIoctl = WSAIoctl;
|
|
pWSAGetLastError = WSAGetLastError;
|
|
pWSASocketW = WSASocketW;
|
|
pWSARecvFrom = WSARecvFrom;
|
|
pWSARecv = WSARecv;
|
|
pWSASendTo = WSASendTo;
|
|
pWSASend = WSASend;
|
|
pWSAStringToAddressA = WSAStringToAddressA;
|
|
|
|
#endif
|
|
|
|
gUseNativeWaitMutex = (pWaitOnAddress &&
|
|
!gRuntimeConfig.threadingConfig.bPreferNt51XpMutexesOver8 &&
|
|
(pRtlWaitOnAddress || AuBuild::kCurrentPlatform != AuBuild::EPlatform::ePlatformWin32)) ||
|
|
!pNtWaitForKeyedEvent;
|
|
|
|
gUseNativeWaitCondvar = (pWaitOnAddress &&
|
|
!gRuntimeConfig.threadingConfig.bPreferNt51XpCondvarsOver8 &&
|
|
(pRtlWaitOnAddress || AuBuild::kCurrentPlatform != AuBuild::EPlatform::ePlatformWin32)) ||
|
|
!pNtWaitForKeyedEvent;
|
|
|
|
gUseNativeWaitSemapahore = bool(pWaitOnAddress);
|
|
}
|
|
|
|
static bool IsNetbookXpOrWin7Laptop()
|
|
{
|
|
return bool(GetEnvironmentVariableW(L"AURORA_IS_NETBOOK", nullptr, 0));
|
|
}
|
|
|
|
void Win32DropSchedulerResolutionNow();
|
|
|
|
void Win32DropInit()
|
|
{
|
|
gShouldResPathDoNothing =
|
|
(AuBuild::kCurrentPlatform != AuBuild::EPlatform::ePlatformWin32) ||
|
|
(!gRuntimeConfig.threadingConfig.bEnableAggressiveScheduling &&
|
|
AuSwInfo::IsWindows10OrGreater()) ||
|
|
IsNetbookXpOrWin7Laptop();
|
|
|
|
gUseFastFail = AuSwInfo::IsWindows8Point1OrGreater()
|
|
#if defined(PF_FASTFAIL_AVAILABLE)
|
|
&& ::IsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE)
|
|
#endif
|
|
;
|
|
|
|
gShouldResPathDoNothing2 = gShouldResPathDoNothing;
|
|
|
|
if (gShouldResPathDoNothing)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#if defined(PROCESS_POWER_THROTTLING_CURRENT_VERSION)
|
|
if (pSetProcessInformation &&
|
|
AuSwInfo::IsWindows10OrGreater())
|
|
{
|
|
static AuInitOnceSmall gInitOnce;
|
|
|
|
if (AuThreading::InitOnceLocker::TryLock(&gInitOnce))
|
|
{
|
|
PROCESS_POWER_THROTTLING_STATE powerThrottling {};
|
|
|
|
powerThrottling.Version = PROCESS_POWER_THROTTLING_CURRENT_VERSION;
|
|
powerThrottling.ControlMask = PROCESS_POWER_THROTTLING_EXECUTION_SPEED;
|
|
powerThrottling.StateMask = 0;
|
|
|
|
gShouldResPathDoNothing2 = bool(pSetProcessInformation(GetCurrentProcess(),
|
|
ProcessPowerThrottling,
|
|
&powerThrottling,
|
|
sizeof(powerThrottling)));
|
|
|
|
powerThrottling.ControlMask = PROCESS_POWER_THROTTLING_IGNORE_TIMER_RESOLUTION;
|
|
powerThrottling.StateMask = 0;
|
|
gShouldResPathDoNothing2 &= bool(pSetProcessInformation(GetCurrentProcess(),
|
|
ProcessPowerThrottling,
|
|
&powerThrottling,
|
|
sizeof(powerThrottling)));
|
|
|
|
if (!gShouldResPathDoNothing2 &&
|
|
(AuSWInfo::IsWindows11OrGreater() || AuSwInfo::IsWindows10Milestone20H1OrGreater()))
|
|
{
|
|
Win32DropSchedulerResolutionNow();
|
|
}
|
|
else
|
|
{
|
|
gShouldResPathDoNothing2 = false;
|
|
}
|
|
|
|
AuThreading::InitOnceLocker::Finish(&gInitOnce);
|
|
} /* else no-wait. intentionally nop*/
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Win32DropSchedulerResolutionForced()
|
|
{
|
|
ULONG ullActualResolution {};
|
|
|
|
if (!gShouldResPathDoNothing)
|
|
{
|
|
Win32DropSchedulerResolution();
|
|
return;
|
|
}
|
|
|
|
if (pZwQueryTimerResolution)
|
|
{
|
|
static AuInitOnce gInitOnce;
|
|
gInitOnce.Call([]()
|
|
{
|
|
ULONG IDC[2];
|
|
pZwQueryTimerResolution(&IDC[0], &IDC[1], &gLastActualResolution);
|
|
});
|
|
}
|
|
}
|
|
|
|
void Win32DropSchedulerResolutionNow()
|
|
{
|
|
ULONG ullActualResolution {};
|
|
|
|
if (!pZwSetTimerResolution)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto uRet = pZwSetTimerResolution(1, true, &ullActualResolution);
|
|
|
|
if (uRet == 0)
|
|
{
|
|
return;
|
|
}
|
|
else if (uRet == 0xC0000245)
|
|
{
|
|
if ((uRet = pZwSetTimerResolution(5'000, true, &ullActualResolution)) == 0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Win32DropSchedulerResolutionForcedUndo()
|
|
{
|
|
ULONG ullActualResolution {};
|
|
|
|
if (!gShouldResPathDoNothing ||
|
|
!pZwSetTimerResolution ||
|
|
!gLastActualResolution)
|
|
{
|
|
return;
|
|
}
|
|
|
|
(void)pZwSetTimerResolution(gLastActualResolution, true, &ullActualResolution);
|
|
}
|
|
|
|
void Win32DropSchedulerResolution()
|
|
{
|
|
ULONG ullActualResolution {};
|
|
|
|
if (gShouldResPathDoNothing2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (gRuntimeConfig.threadingConfig.bEnableAgrSchedulingRatelimit)
|
|
{
|
|
static Aurora::Utility::RateLimiter limiter;
|
|
if (!limiter.nsTimeStep)
|
|
{
|
|
limiter.SetNextStep(AuMSToNS<AuUInt64>(gRuntimeConfig.threadingConfig.bWinXpThrough7BlazeOptimizerPower));
|
|
}
|
|
else if (!limiter.CheckExchangePass())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
Win32DropSchedulerResolutionNow();
|
|
}
|
|
|
|
HANDLE UWPCreateFileMappingA(HANDLE hFile,
|
|
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
|
DWORD flProtect,
|
|
DWORD dwMaximumSizeHigh,
|
|
DWORD dwMaximumSizeLow,
|
|
LPCSTR lpName)
|
|
{
|
|
auto uSize = AuUInt64(AuUInt64(dwMaximumSizeHigh) << 32ull) |
|
|
AuUInt64(dwMaximumSizeLow);
|
|
if (!uSize && SysHandleIsNonZero(AuUInt(hFile)))
|
|
{
|
|
uSize = SysGetFileLength(AuUInt(hFile));
|
|
}
|
|
|
|
if (!pCreateFileMappingFromApp)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return pCreateFileMappingFromApp(hFile,
|
|
lpFileMappingAttributes,
|
|
flProtect,
|
|
uSize,
|
|
lpName ? AuLocale::ConvertFromUTF8(lpName).c_str() : nullptr);
|
|
}
|
|
|
|
HANDLE UWPOpenFileMappingA(DWORD dwDesiredAccess,
|
|
BOOL bInheritHandle,
|
|
LPCSTR lpName)
|
|
{
|
|
if (!pOpenFileMappingFromApp)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return pOpenFileMappingFromApp(dwDesiredAccess,
|
|
bInheritHandle,
|
|
lpName ? AuLocale::ConvertFromUTF8(lpName).c_str() : nullptr);
|
|
}
|
|
|
|
LPVOID UWPMapViewOfFile(HANDLE hFileMappingObject,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwFileOffsetHigh,
|
|
DWORD dwFileOffsetLow,
|
|
SIZE_T dwNumberOfBytesToMap)
|
|
{
|
|
if (!pMapViewOfFileFromApp)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return pMapViewOfFileFromApp(hFileMappingObject,
|
|
dwDesiredAccess,
|
|
AuUInt64(AuUInt64(dwFileOffsetHigh) << 32ull) | AuUInt64(dwFileOffsetLow),
|
|
dwNumberOfBytesToMap);
|
|
}
|
|
|
|
void Win32Terminate()
|
|
{
|
|
if (gUseFastFail)
|
|
{
|
|
__fastfail('fokd');
|
|
}
|
|
else
|
|
{
|
|
if (pNtTerminateProcess)
|
|
{
|
|
pNtTerminateProcess((HANDLE)-1, 0x0);
|
|
}
|
|
|
|
::TerminateProcess(::GetCurrentProcess(), 0);
|
|
}
|
|
}
|
|
|
|
HANDLE Win32Open(LPCWSTR lpFileName,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
bool bInherit,
|
|
DWORD dwCreationDisposition,
|
|
DWORD dwFlags,
|
|
DWORD dwAttributes
|
|
)
|
|
{
|
|
SECURITY_ATTRIBUTES attrs {};
|
|
attrs.nLength = sizeof(attrs);
|
|
attrs.bInheritHandle = bInherit ? TRUE : FALSE;
|
|
return Win32Open2(lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
&attrs,
|
|
dwCreationDisposition,
|
|
dwFlags,
|
|
dwAttributes);
|
|
}
|
|
|
|
HANDLE Win32Open2(LPCWSTR lpFileName,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition,
|
|
DWORD dwFlags,
|
|
DWORD dwAttributes)
|
|
{
|
|
bool bSpecialFlags = (dwFlags & 0x4ffff7);
|
|
bool bSpecialAttrs = (dwAttributes & 0xFFB00008);
|
|
|
|
if (!pCreateFile2W)
|
|
{
|
|
if (bSpecialFlags)
|
|
{
|
|
SysPushErrorFeatureMissing("Do not use Windows8+ attributes/flags under Win32Open");
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (bSpecialAttrs)
|
|
{
|
|
SysPushErrorFeatureMissing("Do not use Windows8+ attributes/flags under Win32Open");
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
if (!dwAttributes)
|
|
{
|
|
dwAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
}
|
|
|
|
if (pCreateFileW &&
|
|
!bSpecialFlags &&
|
|
!bSpecialAttrs)
|
|
{
|
|
return pCreateFileW(lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
lpSecurityAttributes,
|
|
dwCreationDisposition,
|
|
dwFlags | dwAttributes,
|
|
NULL);
|
|
}
|
|
|
|
if (pCreateFile2W)
|
|
{
|
|
_CREATEFILE2_EXTENDED_PARAMETERS params {};
|
|
bool bRead {};
|
|
HANDLE hHandle {};
|
|
|
|
params.dwSize = sizeof(_CREATEFILE2_EXTENDED_PARAMETERS);
|
|
params.dwFileFlags = dwFlags;
|
|
params.dwFileAttributes = dwAttributes;
|
|
params.lpSecurityAttributes = lpSecurityAttributes;
|
|
|
|
if ((bRead = (::wcscmp(lpFileName, L"CONIN$") == 0)) ||
|
|
(::wcscmp(lpFileName, L"CONOUT$") == 0) ||
|
|
(::wcscmp(lpFileName, L"CONERR$") == 0))
|
|
{
|
|
if (!bRead)
|
|
{
|
|
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
|
|
}
|
|
else
|
|
{
|
|
dwDesiredAccess = GENERIC_READ;
|
|
}
|
|
|
|
if ((hHandle = pCreateFile2W(lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
dwCreationDisposition,
|
|
¶ms)) != INVALID_HANDLE_VALUE)
|
|
{
|
|
return hHandle;
|
|
}
|
|
|
|
lpFileName = L"CON";
|
|
}
|
|
|
|
return pCreateFile2W(lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
dwCreationDisposition,
|
|
¶ms);
|
|
}
|
|
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
#if !defined(AURORA_PLATFORM_WIN32)
|
|
HMODULE UWPLibraryW(LPCWSTR lpLibFileName)
|
|
{
|
|
auto pos = std::basic_string_view<wchar_t>(lpLibFileName).find_last_of('/');
|
|
if (pos == std::basic_string_view<wchar_t>::npos)
|
|
{
|
|
pos = std::basic_string_view<wchar_t>(lpLibFileName).find_last_of('\\');
|
|
}
|
|
|
|
if (pos == std::basic_string_view<wchar_t>::npos)
|
|
{
|
|
#if defined(AURORA_HAS_LOAD_PGKD)
|
|
return (HMODULE)::LoadPackagedLibrary(lpLibFileName, 0);
|
|
#else
|
|
return (HMODULE)lpLibFileName;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
auto pString = &lpLibFileName[pos + 1];
|
|
#if defined(AURORA_HAS_LOAD_PGKD)
|
|
return (HMODULE)::LoadPackagedLibrary(pString, 0);
|
|
#else
|
|
return (HMODULE)pString;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
FARPROC UWPProcAddress(HMODULE hModule,
|
|
LPCSTR lpProcName)
|
|
{
|
|
if (!hModule)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
#if defined(AURORA_HAS_GET_PROC_NONWIN32)
|
|
return GetProcAddress(hModule, lpProcName);
|
|
#endif
|
|
|
|
return nullptr;
|
|
}
|
|
#endif
|
|
|
|
bool SysNativeWaitOnAddressFutexSupported()
|
|
{
|
|
return bool(pWaitOnAddress) || bool(pRtlWaitOnAddress);
|
|
}
|
|
|
|
bool SysWaitOnAddressTimed(const void *pTargetAddress,
|
|
const void *pCompareAddress,
|
|
AuUInt8 uWordSize,
|
|
AuUInt64 uAbsTimeSteadyClock,
|
|
AuUInt64 uRelativeNanoseconds,
|
|
AuOptional<AuUInt64> uAbsTimeAltClock,
|
|
bool bSpun)
|
|
{
|
|
// Wont move out of AuWakeOnAddress.cpp because it's so long and bloated in order to force nanosecond-scale yields on UWP.
|
|
SysUnreachable();
|
|
}
|
|
|
|
void NTWriteEoS(HANDLE hHandle)
|
|
{
|
|
SetEndOfFile(hHandle);
|
|
}
|
|
|
|
void SysWriteEoS(AuUInt uOSHandle)
|
|
{
|
|
NTWriteEoS((HANDLE)uOSHandle);
|
|
}
|
|
|
|
void SysCloseHandle(AuUInt uOSHandle)
|
|
{
|
|
auto pHandle = (void *)uOSHandle;
|
|
AuWin32CloseHandle(pHandle);
|
|
}
|
|
|
|
bool SysHandleIsNonZero(AuUInt uOSHandle)
|
|
{
|
|
return uOSHandle && (void *)uOSHandle != INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
void SysFlushHandle(AuUInt uOSHandle)
|
|
{
|
|
auto pHandle = (void *)uOSHandle;
|
|
FlushFileBuffers(pHandle);
|
|
}
|
|
|
|
AuUInt64 SysGetFileLength(AuUInt uOSHandle)
|
|
{
|
|
LARGE_INTEGER length;
|
|
|
|
if (!::GetFileSizeEx((HANDLE)uOSHandle, &length))
|
|
{
|
|
SysPushErrorIO();
|
|
return 0;
|
|
}
|
|
|
|
return length.QuadPart;
|
|
}
|
|
|
|
void *SysAllocateLarge(AuUInt uLength)
|
|
{
|
|
uLength = AuMemory::RoundPageUp(uLength);
|
|
return VirtualAlloc(nullptr, uLength, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
|
|
}
|
|
|
|
void SysAllocateFree(void *pBuffer, AuUInt uLength)
|
|
{
|
|
VirtualFree(pBuffer, 0, MEM_RELEASE);
|
|
}
|
|
|
|
bool SysMemoryLockPages(const void *pVoid, AuUInt uLength)
|
|
{
|
|
return VirtualLock((void *)pVoid, uLength);
|
|
}
|
|
|
|
bool SysMemoryUnlockPages(const void *pVoid, AuUInt uLength)
|
|
{
|
|
return VirtualUnlock((void *)pVoid, uLength);
|
|
}
|
|
} |