#include <Windows.h>

#include "MemoryModule.h"

#include "nt.h"

#define SIZE (4096 / sizeof(char*))

typedef struct

{

void* headers;

unsigned char *codeBase;

void* modules;

int numModules;

BOOL initialized;

BOOL isDLL;

BOOL isRelocated;

void* loadLibrary;

void* getProcAddress;

void* freeLibrary;

void *userdata;

void* exeEntry;

DWORD pageSize;

int *CustomArgc;

char *** CustomArgv;

int *CustomWArgc;

wchar_t *** CustomWArgv;

} MEMORYMODULE, *PMEMORYMODULE;

HMODULE hVirtualModule = NULL;

char sVirtualModuleName[128];

char* strndup(char const* name, size_t len)

{

char *s = (char*)malloc(len + 1);

if (s != NULL)

{

memcpy(s, name, len);

s[len] = 0;

}

return s;

}

wchar_t* wcsndup(wchar_t* name, size_t len)

{

wchar_t *s = (wchar_t*)malloc((len + 1) * sizeof(wchar_t));

if (s != NULL)

{

memcpy(s, name, len*sizeof(wchar_t));

s[len] = 0;

}

return s;

}

int aadd(char* name)

{

char** _new;

if ((__argc % SIZE) == 0)

{

if (__argv == NULL)

_new = (char**)malloc(sizeof(char*) * (1 + SIZE));

else

_new = (char**)realloc(__argv, sizeof(char*) * (__argc + 1 + SIZE));

if (_new == NULL)

return -1;

__argv = _new;

}

__argv[__argc++] = name;

__argv[__argc] = NULL;

return 0;

}

int wadd(wchar_t* name)

{

wchar_t** _new;

if ((__argc % SIZE) == 0)

{

if (__wargv == NULL)

_new = (wchar_t**)malloc(sizeof(wchar_t*) * (1 + SIZE));

else

_new = (wchar_t**)realloc(__wargv, sizeof(wchar_t*) * (__argc + 1 + SIZE));

if (_new == NULL)

return -1;

__wargv = _new;

}

__wargv[__argc++] = name;

__wargv[__argc] = NULL;

return 0;

}

int aexpand(char* name, int expand_wildcards)

{

char* s;

WIN32_FIND_DATAA fd;

HANDLE hFile;

BOOLEAN first = TRUE;

char buffer[256];

uintptr_t pos;

if (expand_wildcards && (s = strpbrk(name, "*?")))

{

hFile = FindFirstFileA(name, &fd);

if (hFile != INVALID_HANDLE_VALUE)

{

while(s != name && *s != '/' && *s != '\\')

s--;

pos = s - name;

if (*s == '/' || *s == '\\')

pos++;

strncpy(buffer, name, pos);

do

{

if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))

{

strcpy(&buffer[pos], fd.cFileName);

if (aadd(_strdup(buffer)) < 0)

{

FindClose(hFile);

return -1;

}

first = FALSE;

}

}

while(FindNextFileA(hFile, &fd));

FindClose(hFile);

}

}

if (first)

{

if (aadd(name) < 0)

return -1;

}

else

free(name);

return 0;

}

int wexpand(wchar_t* name, int expand_wildcards)

{

wchar_t* s;

WIN32_FIND_DATAW fd;

HANDLE hFile;

BOOLEAN first = TRUE;

wchar_t buffer[256];

uintptr_t pos;

if (expand_wildcards && (s = wcspbrk(name, L"*?")))

{

hFile = FindFirstFileW(name, &fd);

if (hFile != INVALID_HANDLE_VALUE)

{

while(s != name && *s != L'/' && *s != L'\\')

s--;

pos = s - name;

if (*s == L'/' || *s == L'\\')

pos++;

wcsncpy(buffer, name, pos);

do

{

if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))

{

wcscpy(&buffer[pos], fd.cFileName);

if (wadd(_wcsdup(buffer)) < 0)

{

FindClose(hFile);

return -1;

}

first = FALSE;

}

}

while(FindNextFileW(hFile, &fd));

FindClose(hFile);

}

}

if (first)

{

if (wadd(name) < 0)

return -1;

}

else

free(name);

return 0;

}

void __getmainargs(int* argc, char*** argv, char*** env, int expand_wildcards, int* new_mode, char* _acmdln)

{

int i, afterlastspace, ignorespace, doexpand;

size_t len;

char* aNewCmdln;

/* missing threading init */

i = 0;

afterlastspace = 0;

ignorespace = 0;

doexpand = expand_wildcards;

if (__argv && _environ)

{

*argv = __argv;

*env = _environ;

*argc = __argc;

return;

}

__argc = 0;

len = strlen(_acmdln);

/* Allocate a temporary buffer to be used instead of the original _acmdln parameter. */

aNewCmdln = strndup(_acmdln, len);

while (aNewCmdln[i])

{

if (aNewCmdln[i] == '"')

{

if(ignorespace)

{

ignorespace = 0;

}

else

{

ignorespace = 1;

doexpand = 0;

}

memmove(aNewCmdln + i, aNewCmdln + i + 1, len - i);

len--;

continue;

}

if (aNewCmdln[i] == ' ' && !ignorespace)

{

aexpand(strndup(aNewCmdln + afterlastspace, i - afterlastspace), doexpand);

i++;

while (aNewCmdln[i] == ' ')

i++;

afterlastspace=i;

doexpand = expand_wildcards;

}

else

{

i++;

}

}

if (aNewCmdln[afterlastspace] != 0)

{

aexpand(strndup(aNewCmdln + afterlastspace, i - afterlastspace), doexpand);

}

/* Free the temporary buffer. */

free(aNewCmdln);

HeapValidate(GetProcessHeap(), 0, NULL);

*argc = __argc;

if (__argv == NULL)

{

__argv = (char**)malloc(sizeof(char*));

__argv[0] = 0;

}

*argv = __argv;

*env = _environ;

_pgmptr = _strdup(__argv[0]);

}

void __wgetmainargs(int* argc, wchar_t*** wargv, wchar_t*** wenv,

int expand_wildcards, int* new_mode, wchar_t*_wcmdln)

{

int i, afterlastspace, ignorespace, doexpand;

size_t len;

wchar_t* wNewCmdln;

/* missing threading init */

i = 0;

afterlastspace = 0;

ignorespace = 0;

doexpand = expand_wildcards;

if (__wargv && _wenviron)

{

*wargv = __wargv;

*wenv = _wenviron;

*argc = __argc;

return;

}

__argc = 0;

len = wcslen(_wcmdln);

/* Allocate a temporary buffer to be used instead of the original _wcmdln parameter. */

wNewCmdln = wcsndup(_wcmdln, len);

while (wNewCmdln[i])

{

if (wNewCmdln[i] == L'"')

{

if(ignorespace)

{

ignorespace = 0;

}

else

{

ignorespace = 1;

doexpand = 0;

}

memmove(wNewCmdln + i, wNewCmdln + i + 1, (len - i) * sizeof(wchar_t));

len--;

continue;

}

if (wNewCmdln[i] == L' ' && !ignorespace)

{

wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand);

i++;

while (wNewCmdln[i] == L' ')

i++;

afterlastspace=i;

doexpand = expand_wildcards;

}

else

{

i++;

}

}

if (wNewCmdln[afterlastspace] != 0)

{

wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand);

}

/* Free the temporary buffer. */

free(wNewCmdln);

HeapValidate(GetProcessHeap(), 0, NULL);

*argc = __argc;

if (__wargv == NULL)

{

__wargv = (wchar_t**)malloc(sizeof(wchar_t*));

__wargv[0] = 0;

}

*wargv = __wargv;

*wenv = _wenviron;

_wpgmptr = _wcsdup(__wargv[0]);

}

BOOL __stdcall Virtual_GetModuleHandleEx(DWORD dwFlags, void* pModuleName, HMODULE *hModuleRet)

{

if(pModuleName == NULL)

{

*hModuleRet = NULL;

return true;

}

return GetModuleHandleEx(dwFlags, (LPCWSTR)pModuleName, hModuleRet);

}

HMODULE __stdcall Virtual_GetModuleHandle(void* pModuleName)

{

if(pModuleName == NULL) return hVirtualModule;

return GetModuleHandle((LPCWSTR)pModuleName);

}

char* __stdcall Virtual_GetCommandLineA()

{

PEB32 *tPeb = (PEB32*)GetThreadPEB();

RTL_USER_PROCESS_PARAMETERS_MEMMODULE *ProcessParams = (RTL_USER_PROCESS_PARAMETERS_MEMMODULE*)tPeb->ProcessParameters;

if(ProcessParams->ExSign != 0xFFFFACAC)

{

return GetCommandLineA();

}

return GetCommandLineA(); //

}

wchar_t* __stdcall Virtual_GetCommandLineW()

{

PEB32 *tPeb = (PEB32*)GetThreadPEB();

RTL_USER_PROCESS_PARAMETERS_MEMMODULE *ProcessParams = (RTL_USER_PROCESS_PARAMETERS_MEMMODULE*)tPeb->ProcessParameters;

if(ProcessParams->ExSign != 0xFFFFACAC)

{

return GetCommandLineW();

}

return GetCommandLineW(); //

}

int Virtual_getmainargs(int * _Argc, char *** _Argv, char *** _Env, int _DoWildCard, void * _StartInfo) // msvcrt

{

PEB32 *tPeb = (PEB32*)GetThreadPEB();

RTL_USER_PROCESS_PARAMETERS_MEMMODULE *ProcessParams = (RTL_USER_PROCESS_PARAMETERS_MEMMODULE*)tPeb->ProcessParameters;

if(ProcessParams->ExSign != 0xFFFFACAC)

{

__getmainargs(_Argc, _Argv, _Env, _DoWildCard, (int*)_StartInfo, GetCommandLineA());

return 0;

}

char* cLine = new char[ProcessParams->CommandLine.MaximumLength];

memset(cLine, 0x00, ProcessParams->CommandLine.MaximumLength);

WideCharToMultiByte(CP_UTF8, 0, ProcessParams->CommandLine.Buffer, lstrlenW(ProcessParams->CommandLine.Buffer), cLine, ProcessParams->CommandLine.MaximumLength, NULL, NULL);

__getmainargs(_Argc, _Argv, _Env, _DoWildCard, (int*)_StartInfo, cLine);

MEMORYMODULE *hMemoryModule = (MEMORYMODULE*)ProcessParams->MemModule;

hMemoryModule->CustomArgc = (int*)_Argc;

hMemoryModule->CustomArgv = (char***)_Argv;

return 0;

}

int Virtual_wgetmainargs(int *_Argc, wchar_t ***_Argv, wchar_t ***_Env, int _DoWildCard, void * _StartInfo) // msvcrt

{

PEB32 *tPeb = (PEB32*)GetThreadPEB();

RTL_USER_PROCESS_PARAMETERS_MEMMODULE *ProcessParams = (RTL_USER_PROCESS_PARAMETERS_MEMMODULE*)tPeb->ProcessParameters;

if(ProcessParams->ExSign != 0xFFFFACAC)

{

__wgetmainargs(_Argc, _Argv, _Env, _DoWildCard, (int*)_StartInfo, GetCommandLineW());

return 0;

}

__wgetmainargs(_Argc, _Argv, _Env, _DoWildCard, (int*)_StartInfo, ProcessParams->CommandLine.Buffer);

MEMORYMODULE *hMemoryModule = (MEMORYMODULE*)ProcessParams->MemModule;

hMemoryModule->CustomWArgc = (int*)_Argc;

hMemoryModule->CustomWArgv = (wchar_t***)_Argv;

return 0;

}