MinHook - The Minimalistic x86/x64 API Hooking Library

• Removed boost dependency (jarredholman).
• Fixed a small bug in the GetRelativeBranchDestination function (pillbug99).
• Added the MH_RemoveHook function, which removes a hook created with the MH_CreateHook function.
• Added the following functions to enable or disable multiple hooks in one go: MH_EnableAllHooks, MH_DisableAllHooks, MH_EnableMultipleHooks, MH_DisableMultipleHooks. This is the preferred way of handling multiple hooks as every call to MH_EnableHook or MH_DisableHook suspends and resumes all threads.
• If the target function is too small to be patched with a jump, MinHook tries to place the jump above the function. If that fails as well, the MH_CreateHook function returns MH_ERROR_UNSUPPORTED_FUNCTION. This fixes an issue of hooking the LoadLibraryExW function on Windows 7 x64 (reported by Obble).

diff -urw MinHook_110_src.original/MinHook/libMinHook/src/buffer.cpp MinHook_110_src/MinHook/libMinHook/src/buffer.cpp
--- MinHook_110_src.original/MinHook/libMinHook/src/buffer.cpp	2009-11-25 06:42:50.000000000 +0000
+++ MinHook_110_src/MinHook/libMinHook/src/buffer.cpp	2012-04-19 11:26:47.960409100 +0100
@@ -29,7 +29,6 @@
 #include <cassert>
 #include <vector>
 #include <algorithm>
-#include <boost/foreach.hpp>
 #include <Windows.h>
 
 #include "buffer.h"
@@ -77,9 +76,10 @@
 
 	void UninitializeBuffer()
 	{
-		BOOST_FOREACH (MEMORY_BLOCK& block, gMemoryBlocks)
+		for (std::vector<MEMORY_BLOCK>::iterator block = gMemoryBlocks.begin();
+			block != gMemoryBlocks.end(); block++)
 		{
-			VirtualFree(block.pAddress, 0, MEM_RELEASE);
+			VirtualFree(block->pAddress, 0, MEM_RELEASE);
 		}
 
 		std::vector<MEMORY_BLOCK> v;
@@ -102,25 +102,27 @@
 
 	void RollbackBuffer()
 	{
-		BOOST_FOREACH (MEMORY_BLOCK& block, gMemoryBlocks)
+		for (std::vector<MEMORY_BLOCK>::iterator block = gMemoryBlocks.begin();
+			block != gMemoryBlocks.end(); block++)
 		{
-			block.usedSize = block.fixedSize;
+			block->usedSize = block->fixedSize;
 		}
 	}
 
 	void CommitBuffer()
 	{
-		BOOST_FOREACH (MEMORY_BLOCK& block, gMemoryBlocks)
+		for (std::vector<MEMORY_BLOCK>::iterator block = gMemoryBlocks.begin();
+			block != gMemoryBlocks.end(); block++)
 		{
-			if (block.usedSize == block.fixedSize)
+			if (block->usedSize == block->fixedSize)
 			{
 				continue;
 			}
 
-			void* pBuffer = reinterpret_cast<char*>(block.pAddress) + block.fixedSize;
-			size_t size = block.usedSize - block.fixedSize;
+			void* pBuffer = reinterpret_cast<char*>(block->pAddress) + block->fixedSize;
+			size_t size = block->usedSize - block->fixedSize;
 			DWORD op;
-			VirtualProtect(pBuffer, size, block.protect, &op);
+			VirtualProtect(pBuffer, size, block->protect, &op);
 		}
 	}
 }
diff -urw MinHook_110_src.original/MinHook/libMinHook/src/hook.cpp MinHook_110_src/MinHook/libMinHook/src/hook.cpp
--- MinHook_110_src.original/MinHook/libMinHook/src/hook.cpp	2009-11-25 06:47:02.000000000 +0000
+++ MinHook_110_src/MinHook/libMinHook/src/hook.cpp	2012-04-19 11:26:47.963409300 +0100
@@ -30,8 +30,6 @@
 #include <vector>
 #include <algorithm>
 #include <functional>
-#include <boost/scope_exit.hpp>
-#include <boost/foreach.hpp>
 #include <Windows.h>
 #include "pstdint.h"
 
@@ -116,14 +114,15 @@
 		}
 
 		// ‚·‚ׂẴtƒbƒN‚ð‰ðœ
-		BOOST_FOREACH (const HOOK_ENTRY& hook, gHooks)
+		for (std::vector<HOOK_ENTRY>::const_iterator hook = gHooks.begin();
+			hook != gHooks.end(); hook++)
 		{
-			if (!hook.isEnabled)
+			if (!hook->isEnabled)
 			{
 				continue;
 			}
 			
-			MH_STATUS status = DisableHook(hook.pTarget);
+			MH_STATUS status = DisableHook(hook->pTarget);
 			if (status != MH_OK)
 			{
 				return status;
@@ -162,33 +161,26 @@
 
 		if (pHook == NULL)
 		{
-			bool committed = false;
-			BOOST_SCOPE_EXIT((&committed))
-			{
-				if (!committed)
-				{
-					RollbackBuffer();
-				}
-			}
-			BOOST_SCOPE_EXIT_END;
-
 			// ƒgƒ‰ƒ“ƒ|ƒŠƒ“ŠÖ”‚ðì¬‚·‚é
 			CREATE_TREMPOLINE_T ct = { 0 };
 			ct.pTarget = pTarget;
 			if (!CreateTrampolineFunction(ct))
 			{
+				RollbackBuffer();
 				return MH_ERROR_UNSUPPORTED_FUNCTION;
 			}
 
 			void* pTrampoline = AllocateCodeBuffer(pTarget, ct.trampoline.size());
 			if (pTrampoline == NULL)
 			{
+				RollbackBuffer();
 				return MH_ERROR_MEMORY_ALLOC;
 			}
 #if defined _M_X64
 			void* pTable = AllocateDataBuffer(pTrampoline, (ct.table.size() + 1) * sizeof(uintptr_t));
 			if (pTable == NULL)
 			{
+				RollbackBuffer();
 				return MH_ERROR_MEMORY_ALLOC;
 			}
 #endif
@@ -199,6 +191,7 @@
 #endif
 			if (!ResolveTemporaryAddresses(ct))
 			{
+				RollbackBuffer();
 				return MH_ERROR_UNSUPPORTED_FUNCTION;
 			}
 
@@ -214,6 +207,7 @@
 			void* pBackup = AllocateDataBuffer(NULL, sizeof(JMP_REL));
 			if (pBackup == NULL)
 			{
+				RollbackBuffer();
 				return MH_ERROR_MEMORY_ALLOC;
 			}
 
@@ -224,13 +218,13 @@
 			void* pRelay = AllocateCodeBuffer(pTarget, sizeof(JMP_ABS));
 			if (pRelay == NULL)
 			{
+				RollbackBuffer();
 				return MH_ERROR_MEMORY_ALLOC;
 			}
 
 			WriteAbsoluteJump(pRelay, pDetour, reinterpret_cast<uintptr_t*>(pTable) + ct.table.size());
 #endif
 			CommitBuffer();
-			committed = true;
 
 			// ƒtƒbƒNî•ñ‚Ì“o˜^
 			HOOK_ENTRY hook = { 0 };
diff -urw MinHook_110_src.original/MinHook/libMinHook/src/thread.cpp MinHook_110_src/MinHook/libMinHook/src/thread.cpp
--- MinHook_110_src.original/MinHook/libMinHook/src/thread.cpp	2009-11-21 00:29:02.000000000 +0000
+++ MinHook_110_src/MinHook/libMinHook/src/thread.cpp	2012-04-19 11:26:47.965409400 +0100
@@ -29,7 +29,6 @@
 #include <cassert>
 #include <vector>
 #include <algorithm>
-#include <boost/foreach.hpp>
 #include <windows.h>
 #include <TlHelp32.h>
 
@@ -38,7 +37,7 @@
 namespace MinHook { namespace
 {
 	// Ž©“®“I‚ÉCloseHandle‚³‚ê‚éWindowsƒnƒ“ƒhƒ‹
-	class ScopedHandle : boost::noncopyable
+	class ScopedHandle
 	{
 	private:
 		HANDLE handle_;
@@ -57,6 +56,9 @@
 		{
 			return handle_;
 		}
+	private:			
+		ScopedHandle(const ScopedHandle&);
+		const ScopedHandle& operator=(const ScopedHandle&);
 	};
 
 }}
@@ -143,9 +145,10 @@
 		static const DWORD ThreadAccess 
 			= THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION | THREAD_SET_CONTEXT;
 		
-		BOOST_FOREACH (const DWORD& tid, threads)
+		for (std::vector<DWORD>::const_iterator tid = threads.begin();
+			tid != threads.end(); tid++)
 		{
-			ScopedHandle hThread = OpenThread(ThreadAccess, FALSE, tid);
+			ScopedHandle hThread = OpenThread(ThreadAccess, FALSE, *tid);
 			SuspendThread(hThread);
 
 			// ‘‚«Š·‚¦”͈͓à‚ŃXƒŒƒbƒh‚ª’âŽ~‚µ‚½ê‡‚́Aƒgƒ‰ƒ“ƒ|ƒŠƒ“ŠÖ”‚ɐ§Œä‚ðˆÚ‚·
@@ -176,9 +179,10 @@
 
 	void ScopedThreadExclusive::Unfreeze(const std::vector<DWORD>& threads)
 	{
-		BOOST_FOREACH (const DWORD& tid, threads)
+		for (std::vector<DWORD>::const_iterator tid = threads.begin();
+			tid != threads.end(); tid++)
 		{
-			ScopedHandle hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid);
+			ScopedHandle hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, *tid);
 			ResumeThread(hThread);
 		}
 	}
diff -urw MinHook_110_src.original/MinHook/libMinHook/src/thread.h MinHook_110_src/MinHook/libMinHook/src/thread.h
--- MinHook_110_src.original/MinHook/libMinHook/src/thread.h	2009-11-17 22:48:38.000000000 +0000
+++ MinHook_110_src/MinHook/libMinHook/src/thread.h	2012-04-19 11:26:47.967409500 +0100
@@ -29,7 +29,6 @@
 #pragma once
 
 #include <vector>
-#include <boost/utility.hpp>
 #include <windows.h>
 
 #include "trampoline.h"
@@ -37,16 +36,19 @@
 namespace MinHook
 {
 	// ScopedLock •t‚«ƒNƒŠƒeƒBƒJƒ‹ƒZƒNƒVƒ‡ƒ“
-	class CriticalSection : boost::noncopyable
+	class CriticalSection
 	{
 	public:
-		class ScopedLock : boost::noncopyable
+		class ScopedLock
 		{
 		private:
 			CriticalSection& cs_;
 		public:
 			ScopedLock(CriticalSection& cs);
 			~ScopedLock();
+		private:			
+			ScopedLock(const ScopedLock&);
+			const ScopedLock& operator=(const ScopedLock&);
 		};
 
 	private:
@@ -56,6 +58,9 @@
 		~CriticalSection();
 		void enter();
 		void leave();
+	private:			
+		CriticalSection(const CriticalSection&);
+		const CriticalSection& operator=(const CriticalSection&);
 	};
 
 	// “¯ˆêƒvƒƒZƒX“à‚Ì‘¼‚̃XƒŒƒbƒh‚ð‚·‚×‚Ä’âŽ~
diff -urw MinHook_110_src.original/MinHook/libMinHook/src/trampoline.cpp MinHook_110_src/MinHook/libMinHook/src/trampoline.cpp
--- MinHook_110_src.original/MinHook/libMinHook/src/trampoline.cpp	2009-11-25 06:40:56.000000000 +0000
+++ MinHook_110_src/MinHook/libMinHook/src/trampoline.cpp	2012-04-19 11:26:47.971409700 +0100
@@ -28,7 +28,6 @@
 
 #include <cassert>
 #include <vector>
-#include <boost/foreach.hpp>
 #include "pstdint.h"
 
 #if defined _M_X64
@@ -229,9 +228,10 @@
 #if defined _M_X64
 		uintptr_t* pt = reinterpret_cast<uintptr_t*>(ct.pTable); 
 #endif
-		BOOST_FOREACH (const TEMP_ADDR& ta, ct.tempAddr)
+		for (std::vector<TEMP_ADDR>::iterator ta = ct.tempAddr.begin();
+			ta != ct.tempAddr.end(); ta++)
 		{
-			if (ta.position > ct.trampoline.size() - sizeof(uint32_t))
+			if (ta->position > ct.trampoline.size() - sizeof(uint32_t))
 			{
 				return false;
 			}
@@ -245,11 +245,11 @@
 			else
 #endif
 			{
-				addr = ta.address;
+				addr = ta->address;
 			}
 
-			*reinterpret_cast<uint32_t*>(&ct.trampoline[ ta.position ]) 
-				= static_cast<uint32_t>(addr - (reinterpret_cast<uintptr_t>(ct.pTrampoline) + ta.pc));
+			*reinterpret_cast<uint32_t*>(&ct.trampoline[ ta->position ]) 
+				= static_cast<uint32_t>(addr - (reinterpret_cast<uintptr_t>(ct.pTrampoline) + ta->pc));
 		}
 
 		for (size_t i = 0; i < ct.oldIPs.size(); ++i)
@@ -266,7 +266,20 @@
 {
 	inline uintptr_t GetRelativeBranchDestination(uint8_t* pInst, const hde_t& hs)
 	{
-		return reinterpret_cast<uintptr_t>(pInst) + hs.len + static_cast<int32_t>(hs.imm.imm32);
+		int32_t imm;
+
+		if (hs.opcode == 0xEB || // JMP short
+			(hs.opcode & 0xF0) == 0x70 || // Jcc short
+			hs.opcode == 0xE3) // JECXZ short
+		{
+			imm = (int32_t)(int8_t)hs.imm.imm8;
+		}
+		else
+		{
+			imm = (int32_t)hs.imm.imm32;
+		}
+
+		return (uintptr_t)pInst + hs.len + imm;
 	}
 	
 	inline bool IsInternalJump(void* pTarget, uintptr_t dest)