welcome back Download Manager, fucking std::async doesn't send messages to dll mains, i hate bill, this shit might prevent deadlocking download threads when exiting during download

Author: Broihon

GH Injector Library/Download Manager.cpp

@@ -0,0 +1,115 @@
+#include "pch.h"
+
+#include "Download Manager.h"
+
+DownloadManager::DownloadManager()
+{
+    m_hInterruptEvent = nullptr;
+}
+
+DownloadManager::~DownloadManager()
+{
+    if (m_hInterruptEvent)
+    {
+        CloseHandle(m_hInterruptEvent);
+    }
+}
+
+HRESULT __stdcall DownloadManager::QueryInterface(const IID & riid, void ** ppvObject)
+{
+    UNREFERENCED_PARAMETER(riid);
+    UNREFERENCED_PARAMETER(ppvObject);
+
+    return E_NOINTERFACE;
+}
+
+ULONG __stdcall DownloadManager::AddRef(void)
+{
+    return 1;
+}
+
+ULONG __stdcall DownloadManager::Release(void)
+{
+    return 1;
+}
+
+HRESULT __stdcall DownloadManager::OnStartBinding(DWORD dwReserved, IBinding * pib)
+{
+    UNREFERENCED_PARAMETER(dwReserved);
+    UNREFERENCED_PARAMETER(pib);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::GetPriority(LONG * pnPriority)
+{
+    UNREFERENCED_PARAMETER(pnPriority);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::OnLowResource(DWORD reserved)
+{
+    UNREFERENCED_PARAMETER(reserved);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::OnStopBinding(HRESULT hresult, LPCWSTR szError)
+{
+    UNREFERENCED_PARAMETER(hresult);
+    UNREFERENCED_PARAMETER(szError);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::GetBindInfo(DWORD * grfBINDF, BINDINFO *pbindinfo)
+{
+    UNREFERENCED_PARAMETER(grfBINDF);
+    UNREFERENCED_PARAMETER(pbindinfo);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::OnDataAvailable(DWORD grfBSCF, DWORD dwSize, FORMATETC * pformatetc, STGMEDIUM * pstgmed)
+{
+    UNREFERENCED_PARAMETER(grfBSCF);
+    UNREFERENCED_PARAMETER(dwSize);
+    UNREFERENCED_PARAMETER(pformatetc);
+    UNREFERENCED_PARAMETER(pstgmed);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::OnObjectAvailable(const IID & riid, IUnknown * punk)
+{
+    UNREFERENCED_PARAMETER(riid);
+    UNREFERENCED_PARAMETER(punk);
+
+    return S_OK;
+}
+
+HRESULT __stdcall DownloadManager::OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
+{
+    UNREFERENCED_PARAMETER(ulProgress);
+    UNREFERENCED_PARAMETER(ulProgressMax);
+    UNREFERENCED_PARAMETER(ulStatusCode);
+    UNREFERENCED_PARAMETER(szStatusText);
+
+    if (m_hInterruptEvent && WaitForSingleObject(m_hInterruptEvent, 0) == WAIT_OBJECT_0)
+    {
+        return E_ABORT;
+    }
+
+    return S_OK;
+}
+
+BOOL DownloadManager::SetInterruptEvent(HANDLE hInterrupt)
+{
+    if (m_hInterruptEvent)
+    {
+        CloseHandle(m_hInterruptEvent);
+    }
+
+    return DuplicateHandle(GetCurrentProcess(), hInterrupt, GetCurrentProcess(), &m_hInterruptEvent, NULL, FALSE, DUPLICATE_SAME_ACCESS);
+}

GH Injector Library/Download Manager.h

@@ -0,0 +1,42 @@
+//Stolen from here:
+//https://stackoverflow.com/a/5292277
+//by User Hans Passant
+
+#pragma once
+
+#include <windows.h>
+
+class DownloadManager : public IBindStatusCallback
+{
+    HANDLE m_hInterruptEvent;
+
+public:
+
+    DownloadManager();
+
+    ~DownloadManager();
+
+    HRESULT __stdcall QueryInterface(const IID & riid, void ** ppvObject);
+
+    ULONG STDMETHODCALLTYPE AddRef(void);
+
+    ULONG STDMETHODCALLTYPE Release(void);
+
+    virtual HRESULT STDMETHODCALLTYPE OnStartBinding(DWORD dwReserved, IBinding * pib);
+
+    virtual HRESULT STDMETHODCALLTYPE GetPriority(LONG * pnPriority);
+
+    virtual HRESULT STDMETHODCALLTYPE OnLowResource(DWORD reserved);
+
+    virtual HRESULT STDMETHODCALLTYPE OnStopBinding(HRESULT hresult, LPCWSTR szError);
+
+    virtual HRESULT STDMETHODCALLTYPE GetBindInfo(DWORD * grfBINDF, BINDINFO *pbindinfo);
+
+    virtual HRESULT STDMETHODCALLTYPE OnDataAvailable(DWORD grfBSCF, DWORD dwSize, FORMATETC * pformatetc, STGMEDIUM * pstgmed);
+
+    virtual HRESULT STDMETHODCALLTYPE OnObjectAvailable(const IID & riid, IUnknown * punk);
+
+    HRESULT __stdcall OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText);
+
+    BOOL SetInterruptEvent(HANDLE hInterrupt);
+};

GH Injector Library/Error.h

@@ -249,6 +249,7 @@
 #define SYMBOL_ERR_SYMBOL_SEARCH_FAILED			0x40000013	//SymFromName				:	couldn't find szSymbolName in the specified pdb
 #define SYMBOL_CANT_OPEN_PROCESS				0x40000014	//OpenProcess				:	can't get PROCESS_QUERY_LIMITED_INFORMATION handle to current process
 #define SYMBOL_ERR_COPYFILE_FAILED				0x40000015	//CopyFileA					:	copying the file from the cache directory failed
+#define SYMBOL_ERR_INTERRUPT					0x40000016	//internal error			:	download has been interrupted
 
 
 

GH Injector Library/GH Injector Library.vcxproj

@@ -164,6 +164,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="Download Manager.h" />
     <ClInclude Include="Eject.h" />
     <ClInclude Include="Error.h" />
     <ClInclude Include="Handle Hijacking.h" />
@@ -181,6 +182,7 @@
     <ClInclude Include="WOW64 Shells.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="Download Manager.cpp" />
     <ClCompile Include="Eject.cpp" />
     <ClCompile Include="Handle Hijacking.cpp" />
     <ClCompile Include="Hook Scanner WOW64.cpp" />

GH Injector Library/GH Injector Library.vcxproj.filters

@@ -81,6 +81,9 @@
     <ClInclude Include="WOW64 Shells.h">
       <Filter>Quelldateien\wow64\Injection Methods</Filter>
     </ClInclude>
+    <ClInclude Include="Download Manager.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Handle Hijacking.cpp">
@@ -161,5 +164,8 @@
     <ClCompile Include="Injection Generic WOW64.cpp">
       <Filter>Quelldateien\wow64\Injection Methods</Filter>
     </ClCompile>
+    <ClCompile Include="Download Manager.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

GH Injector Library/Import Handler WOW64.cpp

@@ -94,7 +94,7 @@ DWORD LoadNtSymbolWOW64(T & Function, const char * szFunction)
 	DWORD sym_ret = sym_ntdll_wow64.GetSymbolAddress(szFunction, RVA);
 	if (sym_ret != SYMBOL_ERR_SUCCESS)
 	{
-		printf("Failed to load WOW64 function: %s\n", szFunction);
+		LOG("Failed to load WOW64 function: %s\n", szFunction);
 		return 0;
 	}
 

GH Injector Library/Symbol Parser.cpp

@@ -7,13 +7,20 @@ SYMBOL_PARSER::SYMBOL_PARSER()
 	m_Initialized	= false;
 	m_Ready			= false;
 	m_SymbolTable	= 0;
-	m_Filesize		= 0;
 	m_hPdbFile		= nullptr;
 	m_hProcess		= nullptr;
+
+	m_bInterruptEvent	= false;
+	m_hInterruptEvent	= CreateEvent(nullptr, FALSE, FALSE, nullptr);
 }
 
 SYMBOL_PARSER::~SYMBOL_PARSER()
 {
+	if (m_hInterruptEvent)
+	{
+		CloseHandle(m_hInterruptEvent);
+	}
+
 	if (m_Initialized)
 	{
 		if (m_SymbolTable)
@@ -336,13 +343,24 @@ DWORD SYMBOL_PARSER::Initialize(const std::string szModulePath, const std::strin
 		{
 			while (InternetCheckConnectionA("https://msdl.microsoft.com", FLAG_ICC_FORCE_CONNECTION, NULL) == FALSE)
 			{
-				Sleep(10);
+				Sleep(50);
+
+				if (m_bInterruptEvent)
+				{
+					VirtualFree(pLocalImageBase, 0, MEM_RELEASE);
+
+					delete[] pRawData;
+
+					return SYMBOL_ERR_INTERRUPT;
+				}
 			}
 		}
 
 		char szCacheFile[MAX_PATH]{ 0 };
+		DownloadManager dlmgr;
+		dlmgr.SetInterruptEvent(m_hInterruptEvent);
 
-		if (FAILED(URLDownloadToCacheFileA(nullptr, url.c_str(), szCacheFile, MAX_PATH , NULL, nullptr)))
+		if (FAILED(URLDownloadToCacheFileA(nullptr, url.c_str(), szCacheFile, MAX_PATH , NULL, &dlmgr)))
 		{
 			VirtualFree(pLocalImageBase, 0, MEM_RELEASE);
 
@@ -444,8 +462,14 @@ DWORD SYMBOL_PARSER::GetSymbolAddress(const char * szSymbolName, DWORD & RvaOut)
 	return SYMBOL_ERR_SUCCESS;
 }
 
-void SYMBOL_PARSER::InterruptCleanup()
+void SYMBOL_PARSER::Interrupt()
 {
+	if (m_hInterruptEvent)
+	{
+		SetEvent(m_hInterruptEvent);
+		CloseHandle(m_hInterruptEvent);
+	}
+
 	if (m_Initialized)
 	{
 		if (m_SymbolTable)
@@ -469,7 +493,9 @@ void SYMBOL_PARSER::InterruptCleanup()
 	m_Initialized	= false;
 	m_Ready			= false;
 	m_SymbolTable	= 0;
-	m_Filesize		= 0;
 	m_hPdbFile		= nullptr;
 	m_hProcess		= nullptr;
+
+	m_bInterruptEvent = false;
+	m_hInterruptEvent = nullptr;
 }

GH Injector Library/Symbol Parser.h

@@ -3,20 +3,24 @@
 #include "pch.h"
 
 #include "Error.h"
+#include "Download Manager.h"
+
 class SYMBOL_PARSER
 {
 	HANDLE m_hProcess;
 
 	HANDLE		m_hPdbFile;
 	std::string	m_szPdbPath;
-	DWORD		m_Filesize;
 	DWORD64		m_SymbolTable;
 
 	std::string m_szModulePath;
 
 	bool m_Initialized;
 	bool m_Ready;
 
+	HANDLE	m_hInterruptEvent;
+	bool	m_bInterruptEvent;
+
 	bool VerifyExistingPdb(const GUID & guid);
 
 public:
@@ -27,7 +31,7 @@ class SYMBOL_PARSER
 	DWORD Initialize(const std::string szModulePath, const std::string path, std::string * pdb_path_out, bool Redownload, bool WaitForConnection = false);
 	DWORD GetSymbolAddress(const char * szSymbolName, DWORD & RvaOut);
 
-	void InterruptCleanup();
+	void Interrupt();
 };
 
 struct PdbInfo
@@ -68,7 +72,9 @@ struct GUID_StreamData
 #ifdef  _WIN64
 inline SYMBOL_PARSER				sym_ntdll_wow64;
 inline std::shared_future<DWORD>	sym_ntdll_wow64_ret;
+inline DWORD						sym_ntdll_wow64_thread_id;
 #endif
 
 inline SYMBOL_PARSER				sym_ntdll_native;
-inline std::shared_future<DWORD>	sym_ntdll_native_ret;
+inline std::shared_future<DWORD>	sym_ntdll_native_ret;
+inline DWORD						sym_ntdll_native_thread_id;

GH Injector Library/main.cpp

@@ -30,8 +30,6 @@ BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, void * pReserved)
 
 		LOG("GH Injector V%ls attached at %p\n", GH_INJ_VERSION, hDll);
 
-		DisableThreadLibraryCalls(hDll);
-
 		g_hInjMod = hDll;
 
 		char	szRootPathA[MAX_PATH]{ 0 };
@@ -68,26 +66,42 @@ BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, void * pReserved)
 
 		LOG("Rootpath is %s\n", szRootPathA);
 
+		std::string szNtDllNative = szWindowsDir;
+		szNtDllNative += "\\System32\\ntdll.dll";
+
+		sym_ntdll_native_ret = std::async(std::launch::async, &SYMBOL_PARSER::Initialize, &sym_ntdll_native, szNtDllNative, g_RootPathA, nullptr, false, true);
+
 #ifdef _WIN64
 		std::string szNtDllWOW64 = szWindowsDir;
 		szNtDllWOW64 += "\\SysWOW64\\ntdll.dll";
 
-		sym_ntdll_wow64_ret	= std::async(std::launch::async, &SYMBOL_PARSER::Initialize, &sym_ntdll_wow64, szNtDllWOW64, g_RootPathA, nullptr, false, true);
+		sym_ntdll_wow64_ret = std::async(std::launch::async, &SYMBOL_PARSER::Initialize, &sym_ntdll_wow64, szNtDllWOW64, g_RootPathA, nullptr, false, true);
 #endif
 
-		std::string szNtDllNative = szWindowsDir;
-		szNtDllNative += "\\System32\\ntdll.dll";
-
-		sym_ntdll_native_ret = std::async(std::launch::async, &SYMBOL_PARSER::Initialize, &sym_ntdll_native, szNtDllNative, g_RootPathA, nullptr, false, true);
-
 		delete[] szWindowsDir;
 	}
 	else if (dwReason == DLL_PROCESS_DETACH)
 	{
-		sym_ntdll_native.InterruptCleanup();
+		LOG("GH Injector V%ls detaching\n", GH_INJ_VERSION);
+
+		if (sym_ntdll_native_ret.wait_for(std::chrono::microseconds(0)) != std::future_status::ready)
+		{
+			sym_ntdll_native.Interrupt();
+			if (sym_ntdll_native_ret.wait_for(std::chrono::microseconds(25)) != std::future_status::timeout)
+			{
+				LOG("Native ntdll pdb download thread didn't exit properly.\n");
+			}
+		}
 
 #ifdef _WIN64
-		sym_ntdll_wow64.InterruptCleanup();
+		if (sym_ntdll_wow64_ret.wait_for(std::chrono::microseconds(0)) != std::future_status::ready)
+		{
+			sym_ntdll_wow64.Interrupt();
+			if (sym_ntdll_wow64_ret.wait_for(std::chrono::microseconds(25)) != std::future_status::timeout)
+			{
+				LOG("Wow64 ntdll pdb download thread didn't exit properly.\n");
+			}
+		}
 #endif
 
 		LOG("GH Injector V%ls detached\n", GH_INJ_VERSION);