From ce7626a3808ce5a047ab94fa0406d206a8b317c4 Mon Sep 17 00:00:00 2001
From: mrexodia <mr.exodia.tpodt@gmail.com>
Date: Sun, 20 Dec 2015 06:05:46 +0100
Subject: [PATCH] further implementation of the TitanEngine emulator

---
 TitanEngineEmulator/Emulator.h                | 272 +++++++++++
 TitanEngineEmulator/TitanEngineEmulator.cpp   | 450 ++++++++++--------
 .../TitanEngineEmulator.vcxproj               |   3 +
 .../TitanEngineEmulator.vcxproj.filters       |   3 +
 4 files changed, 517 insertions(+), 211 deletions(-)
 create mode 100644 TitanEngineEmulator/Emulator.h

diff --git a/TitanEngineEmulator/Emulator.h b/TitanEngineEmulator/Emulator.h
new file mode 100644
index 0000000..9b462f4
--- /dev/null
+++ b/TitanEngineEmulator/Emulator.h
@@ -0,0 +1,272 @@
+#include <GleeBug/Debugger.h>
+#include "TitanEngine.h"
+
+using namespace GleeBug;
+
+class Emulator : public Debugger
+{
+public:
+    //Debugger
+    PROCESS_INFORMATION* InitDebugW(const wchar_t* szFileName, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder)
+    {
+        if (!Init(szFileName, szCommandLine, szCurrentFolder))
+            return nullptr;
+        return &_mainProcess;
+    }
+
+    void SetNextDbgContinueStatus(DWORD SetDbgCode)
+    {
+        this->_continueStatus = SetDbgCode;
+    }
+
+    //Memory
+    bool MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesRead)
+    {
+        if (!_process)
+            return false;
+        return _process->MemReadSafe(ptr(lpBaseAddress), lpBuffer, nSize);
+    }
+
+    bool MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten)
+    {
+        if (!_process)
+            return false;
+        return _process->MemWriteSafe(ptr(lpBaseAddress), lpBuffer, nSize);
+    }
+
+    bool Fill(LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte)
+    {
+        if (!_process)
+            return false;
+        for (DWORD i = 0; i < MemorySize; i++)
+        {
+            if (!_process->MemWriteSafe(ptr(MemoryStart) + i, FillByte, 1))
+                return false;
+        }
+        return true;
+    }
+
+    //Engine
+    bool IsFileBeingDebugged()
+    {
+        return _isRunning;
+    }
+
+    DEBUG_EVENT* GetDebugData()
+    {
+        return &_debugEvent;
+    }
+
+    void SetCustomHandler(DWORD ExceptionId, PVOID CallBack)
+    {
+        switch (ExceptionId)
+        {
+        case UE_CH_CREATEPROCESS:
+            _cbCREATEPROCESS = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_EXITPROCESS:
+            _cbEXITPROCESS = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_CREATETHREAD:
+            _cbCREATETHREAD = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_EXITTHREAD:
+            _cbEXITTHREAD = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_SYSTEMBREAKPOINT:
+            _cbSYSTEMBREAKPOINT = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_LOADDLL:
+            _cbLOADDLL = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_UNLOADDLL:
+            _cbUNLOADDLL = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_OUTPUTDEBUGSTRING:
+            _cbOUTPUTDEBUGSTRING = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_UNHANDLEDEXCEPTION:
+            _cbUNHANDLEDEXCEPTION = (CUSTOMHANDLER)CallBack;
+            break;
+        case UE_CH_DEBUGEVENT:
+            _cbDEBUGEVENT = (CUSTOMHANDLER)CallBack;
+            break;
+        default:
+            break;
+        }
+    }
+
+    void SetEngineVariable(DWORD VariableId, bool VariableSet)
+    {
+        if (VariableId == UE_ENGINE_SET_DEBUG_PRIVILEGE)
+            _setDebugPrivilege = VariableSet;
+    }
+
+    //Misc
+    HANDLE TitanOpenProces(DWORD dwDesiredAccess, bool bInheritHandle, DWORD dwProcessId)
+    {
+        return OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);
+    }
+
+    //Stepping
+    void StepOver(LPVOID CallBack)
+    {
+        //TODO
+        StepInto(CallBack);
+    }
+
+    void SingleStep(DWORD StepCount, LPVOID CallBack)
+    {
+        if (!_thread || !CallBack)
+            return;
+        _thread->StepInto([this, StepCount, CallBack]()
+        {
+            if (!StepCount)
+                ((STEPCALLBACK)CallBack)();
+            else
+                SingleStep(StepCount - 1, CallBack);
+        });
+    }
+
+    void StepInto(LPVOID CallBack)
+    {
+        if (!_thread || !CallBack)
+            return;
+        _thread->StepInto([CallBack]()
+        {
+            ((STEPCALLBACK)CallBack)();
+        });
+    }
+
+    //Registers
+    ULONG_PTR GetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister)
+    {
+        if (!_thread)
+            return 0;
+        return _thread->registers.Get(registerFromDword(IndexOfRegister));
+    }
+
+protected:
+    void cbCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO & createProcess, const ProcessInfo & process) override
+    {
+        if (_cbCREATEPROCESS)
+            _cbCREATEPROCESS(&createProcess);
+    }
+
+    void cbExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO & exitProcess, const ProcessInfo & process) override
+    {
+        if (_cbEXITPROCESS)
+            _cbEXITPROCESS(&exitProcess);
+    }
+
+    void cbCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO & createThread, const ThreadInfo & thread) override
+    {
+        if (_cbCREATETHREAD)
+            _cbCREATETHREAD(&createThread);
+    }
+
+    void cbExitThreadEvent(const EXIT_THREAD_DEBUG_INFO & exitThread, const ThreadInfo & thread) override
+    {
+        if (_cbEXITTHREAD)
+            _cbEXITTHREAD(&exitThread);
+    }
+
+    void cbLoadDllEvent(const LOAD_DLL_DEBUG_INFO & loadDll, const DllInfo & dll) override
+    {
+        if (_cbLOADDLL)
+            _cbLOADDLL(&loadDll);
+    }
+
+    void cbUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO & unloadDll, const DllInfo & dll) override
+    {
+        if (_cbUNLOADDLL)
+            _cbUNLOADDLL(&unloadDll);
+    }
+
+    void cbUnhandledException(const EXCEPTION_RECORD & exceptionRecord, bool firstChance) override
+    {
+        if (_cbUNHANDLEDEXCEPTION)
+            _cbUNHANDLEDEXCEPTION(&_debugEvent.u.Exception);
+    }
+
+    void cbDebugStringEvent(const OUTPUT_DEBUG_STRING_INFO & debugString) override
+    {
+        if (_cbOUTPUTDEBUGSTRING)
+            _cbOUTPUTDEBUGSTRING(&debugString);
+    }
+
+    void cbPreDebugEvent(const DEBUG_EVENT & debugEvent) override
+    {
+        if (_cbDEBUGEVENT)
+            _cbDEBUGEVENT(&debugEvent);
+    }
+
+    void cbSystemBreakpoint() override
+    {
+        if (_cbSYSTEMBREAKPOINT)
+            _cbSYSTEMBREAKPOINT(&_debugEvent.u.Exception);
+    }
+
+private: //functions
+    Registers::R registerFromDword(DWORD IndexOfRegister)
+    {
+        switch (IndexOfRegister)
+        {
+        case UE_EAX: return Registers::R::EAX;
+        case UE_EBX: return Registers::R::EBX;
+        case UE_ECX: return Registers::R::ECX;
+        case UE_EDX: return Registers::R::EDX;
+        case UE_EDI: return Registers::R::EDI;
+        case UE_ESI: return Registers::R::ESI;
+        case UE_EBP: return Registers::R::EBP;
+        case UE_ESP: return Registers::R::ESP;
+        case UE_EIP: return Registers::R::EIP;
+        case UE_EFLAGS: return Registers::R::EFlags;
+        case UE_DR0: return Registers::R::DR0;
+        case UE_DR1: return Registers::R::DR1;
+        case UE_DR2: return Registers::R::DR2;
+        case UE_DR3: return Registers::R::DR3;
+        case UE_DR6: return Registers::R::DR6;
+        case UE_DR7: return Registers::R::DR7;
+#ifdef _WIN64
+        case UE_RAX: return Registers::R::RAX;
+        case UE_RBX: return Registers::R::RBX;
+        case UE_RCX: return Registers::R::RCX;
+        case UE_RDX: return Registers::R::RDX;
+        case UE_RDI: return Registers::R::RDI;
+        case UE_RSI: return Registers::R::RSI;
+        case UE_RBP: return Registers::R::RBP;
+        case UE_RSP: return Registers::R::RSP;
+        case UE_RIP: return Registers::R::RIP;
+        case UE_RFLAGS: return Registers::R::EFlags;
+        case UE_R8: return Registers::R::R8;
+        case UE_R9: return Registers::R::R9;
+        case UE_R10: return Registers::R::R10;
+        case UE_R11: return Registers::R::R11;
+        case UE_R12: return Registers::R::R12;
+        case UE_R13: return Registers::R::R13;
+        case UE_R14: return Registers::R::R14;
+        case UE_R15: return Registers::R::R15;
+#endif //_WIN64
+        case UE_CIP: return Registers::R::GIP;
+        case UE_CSP: return Registers::R::GSP;
+        default:
+            return Registers::R::EAX;
+        }
+    }
+
+private: //variables
+    bool _setDebugPrivilege = false;
+    typedef void(*CUSTOMHANDLER)(const void*);
+    typedef void(*STEPCALLBACK)();
+    CUSTOMHANDLER _cbCREATEPROCESS = nullptr;
+    CUSTOMHANDLER _cbEXITPROCESS = nullptr;
+    CUSTOMHANDLER _cbCREATETHREAD = nullptr;
+    CUSTOMHANDLER _cbEXITTHREAD = nullptr;
+    CUSTOMHANDLER _cbSYSTEMBREAKPOINT = nullptr;
+    CUSTOMHANDLER _cbLOADDLL = nullptr;
+    CUSTOMHANDLER _cbUNLOADDLL = nullptr;
+    CUSTOMHANDLER _cbOUTPUTDEBUGSTRING = nullptr;
+    CUSTOMHANDLER _cbUNHANDLEDEXCEPTION = nullptr;
+    CUSTOMHANDLER _cbDEBUGEVENT = nullptr;
+};
\ No newline at end of file
diff --git a/TitanEngineEmulator/TitanEngineEmulator.cpp b/TitanEngineEmulator/TitanEngineEmulator.cpp
index fc11199..505f20f 100644
--- a/TitanEngineEmulator/TitanEngineEmulator.cpp
+++ b/TitanEngineEmulator/TitanEngineEmulator.cpp
@@ -1,269 +1,297 @@
-#include <GleeBug/Debugger.h>
-#include "TitanEngine.h"
+#include <windows.h>
+#include "Emulator.h"
 
-__declspec(dllexport) bool TITCALL IsJumpGoingToExecuteEx(HANDLE hProcess, HANDLE hThread, ULONG_PTR InstructionAddress, ULONG_PTR RegFlags)
-{
-    return false;
-}
-
-__declspec(dllexport) void TITCALL GetMMXRegisters(uint64_t mmx[8], TITAN_ENGINE_CONTEXT_t* titcontext)
-{
-    
-}
-
-__declspec(dllexport) void TITCALL Getx87FPURegisters(x87FPURegister_t x87FPURegisters[8], TITAN_ENGINE_CONTEXT_t* titcontext)
-{
-    
-}
-
-__declspec(dllexport) bool TITCALL EngineCheckStructAlignment(DWORD StructureType, ULONG_PTR StructureSize)
-{
-    return true;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType)
-{
-    return 0;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType)
-{
-    return 0;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL GetPE32DataFromMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData)
-{
-    return 0;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL ImporterGetRemoteAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress)
-{
-    return 0;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL GetPE32DataW(const wchar_t* szFileName, DWORD WhichSection, DWORD WhichData)
-{
-    return 0;
-}
-
-__declspec(dllexport) bool TITCALL IsFileDLLW(const wchar_t* szFileName, ULONG_PTR FileMapVA)
-{
-    return false;
-}
-
-__declspec(dllexport) void* TITCALL GetPEBLocation(HANDLE hProcess)
-{
-    return nullptr;
-}
+Emulator emu;
 
+//Debugger basics
 __declspec(dllexport) void* TITCALL InitDebugW(const wchar_t* szFileName, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder)
 {
-    return nullptr;
+    return emu.InitDebugW(szFileName, szCommandLine, szCurrentFolder);
 }
 
 __declspec(dllexport) void* TITCALL InitDLLDebugW(const wchar_t* szFileName, bool ReserveModuleBase, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder, LPVOID EntryCallBack)
 {
+    //TODO
     return nullptr;
 }
 
 __declspec(dllexport) bool TITCALL StopDebug()
 {
+    return emu.Stop();
+}
+
+__declspec(dllexport) bool TITCALL AttachDebugger(DWORD ProcessId, bool KillOnExit, LPVOID DebugInfo, LPVOID CallBack)
+{
+    //TODO
     return false;
 }
 
-__declspec(dllexport) bool TITCALL SetBPX(ULONG_PTR bpxAddress, DWORD bpxType, LPVOID bpxCallBack)
+__declspec(dllexport) bool TITCALL DetachDebuggerEx(DWORD ProcessId)
 {
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL DeleteBPX(ULONG_PTR bpxAddress)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL SetMemoryBPXEx(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, DWORD BreakPointType, bool RestoreOnHit, LPVOID bpxCallBack)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL RemoveMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory)
-{
-    return false;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL GetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister)
-{
-    return 0;
-}
-
-__declspec(dllexport) ULONG_PTR TITCALL GetContextData(DWORD IndexOfRegister)
-{
-    return 0;
-}
-
-__declspec(dllexport) bool TITCALL IsFileBeingDebugged()
-{
-    return false;
-}
-
-__declspec(dllexport) void* TITCALL GetDebugData()
-{
-    return nullptr;
-}
-
-__declspec(dllexport) void TITCALL SetCustomHandler(DWORD ExceptionId, LPVOID CallBack)
-{
-    
-}
-
-__declspec(dllexport) void TITCALL StepOver(LPVOID traceCallBack)
-{
-
-}
-
-__declspec(dllexport) bool TITCALL GetUnusedHardwareBreakPointRegister(LPDWORD RegisterIndex)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesRead)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL StaticFileUnloadW(const wchar_t* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL StaticFileLoadW(const wchar_t* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL LibrarianRemoveBreakPoint(const char* szLibraryName, DWORD bpxType)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL LibrarianSetBreakPoint(const char* szLibraryName, DWORD bpxType, bool SingleShoot, LPVOID bpxCallBack)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL SetHardwareBreakPoint(ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL DeleteHardwareBreakPoint(DWORD IndexOfRegister)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL RemoveAllBreakPoints(DWORD RemoveOption)
-{
-    return false;
-}
-
-__declspec(dllexport) void TITCALL SingleStep(DWORD StepCount, LPVOID StepCallBack)
-{
-    
-}
-
-__declspec(dllexport) void TITCALL StepInto(LPVOID traceCallBack)
-{
-    
-}
-
-__declspec(dllexport) bool TITCALL Fill(LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL GetFullContextDataEx(HANDLE hActiveThread, TITAN_ENGINE_CONTEXT_t* titcontext)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL SetFullContextDataEx(HANDLE hActiveThread, TITAN_ENGINE_CONTEXT_t* titcontext)
-{
-    return false;
-}
-
-__declspec(dllexport) bool TITCALL IsBPXEnabled(ULONG_PTR bpxAddress)
-{
-    return false;
-}
-
-__declspec(dllexport) void TITCALL SetBPXOptions(long DefaultBreakPointType)
-{
-    
-}
-
-__declspec(dllexport) bool TITCALL HideDebugger(HANDLE hProcess, DWORD PatchAPILevel)
-{
-    return false;
+    return emu.Detach();
 }
 
 __declspec(dllexport) void TITCALL DebugLoop()
 {
-    
+    emu.Start();
+}
+
+__declspec(dllexport) void TITCALL SetNextDbgContinueStatus(DWORD SetDbgCode)
+{
+    emu.SetNextDbgContinueStatus(SetDbgCode);
+}
+
+//Memory
+__declspec(dllexport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesRead)
+{
+    return emu.MemoryReadSafe(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead);
+}
+
+__declspec(dllexport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten)
+{
+    return emu.MemoryWriteSafe(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten);
+}
+
+__declspec(dllexport) bool TITCALL Fill(LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte)
+{
+    return emu.Fill(MemoryStart, MemorySize, FillByte);
+}
+
+//Engine
+__declspec(dllexport) bool TITCALL EngineCheckStructAlignment(DWORD StructureType, ULONG_PTR StructureSize)
+{
+    return true;
+}
+
+__declspec(dllexport) bool TITCALL IsFileBeingDebugged()
+{
+    return emu.IsFileBeingDebugged();
+}
+
+__declspec(dllexport) void* TITCALL GetDebugData()
+{
+    return emu.GetDebugData();
+}
+
+__declspec(dllexport) void TITCALL SetCustomHandler(DWORD ExceptionId, LPVOID CallBack)
+{
+    emu.SetCustomHandler(ExceptionId, CallBack);
 }
 
 __declspec(dllexport) void TITCALL SetEngineVariable(DWORD VariableId, bool VariableSet)
 {
-    
+    emu.SetEngineVariable(VariableId, VariableSet);
 }
 
-__declspec(dllexport) long TITCALL GetPE32SectionNumberFromVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert)
+//Misc
+__declspec(dllexport) bool TITCALL IsJumpGoingToExecuteEx(HANDLE hProcess, HANDLE hThread, ULONG_PTR InstructionAddress, ULONG_PTR RegFlags)
 {
-    return 0;
+    //TODO
+    return false;
 }
 
-__declspec(dllexport) bool TITCALL TLSGrabCallBackDataW(const wchar_t* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks)
+__declspec(dllexport) void* TITCALL GetPEBLocation(HANDLE hProcess)
 {
+    //TODO
+    return nullptr;
+}
+
+__declspec(dllexport) bool TITCALL HideDebugger(HANDLE hProcess, DWORD PatchAPILevel)
+{
+    //TODO
     return false;
 }
 
 __declspec(dllexport) HANDLE TITCALL TitanOpenProcess(DWORD dwDesiredAccess, bool bInheritHandle, DWORD dwProcessId)
 {
+    //TODO
     return 0;
 }
 
-__declspec(dllexport) bool TITCALL DetachDebuggerEx(DWORD ProcessId)
+__declspec(dllexport) ULONG_PTR TITCALL ImporterGetRemoteAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress)
 {
-    return false;
+    //TODO
+    return 0;
 }
 
-__declspec(dllexport) bool TITCALL AttachDebugger(DWORD ProcessId, bool KillOnExit, LPVOID DebugInfo, LPVOID CallBack)
+//Registers
+__declspec(dllexport) ULONG_PTR TITCALL GetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister)
 {
-    return false;
+    return emu.GetContextDataEx(hActiveThread, IndexOfRegister);
 }
 
 __declspec(dllexport) bool TITCALL SetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister, ULONG_PTR NewRegisterValue)
 {
+    //TODO
     return false;
 }
 
-__declspec(dllexport) void TITCALL SetNextDbgContinueStatus(DWORD SetDbgCode)
+__declspec(dllexport) bool TITCALL GetFullContextDataEx(HANDLE hActiveThread, TITAN_ENGINE_CONTEXT_t* titcontext)
 {
-
+    memset(titcontext, 0, sizeof(TITAN_ENGINE_CONTEXT_t));
+    //TODO
+    return false;
 }
 
-static void initializeEmulator(HINSTANCE hInst)
+__declspec(dllexport) bool TITCALL SetFullContextDataEx(HANDLE hActiveThread, TITAN_ENGINE_CONTEXT_t* titcontext)
 {
-    
+    //TODO
+    return false;
 }
 
-BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+__declspec(dllexport) void TITCALL GetMMXRegisters(uint64_t mmx[8], TITAN_ENGINE_CONTEXT_t* titcontext)
 {
-    if (fdwReason == DLL_PROCESS_ATTACH)
-        initializeEmulator(hinstDLL);
-    return TRUE;
+    //TODO
+}
+
+__declspec(dllexport) void TITCALL Getx87FPURegisters(x87FPURegister_t x87FPURegisters[8], TITAN_ENGINE_CONTEXT_t* titcontext)
+{
+    //TODO
+}
+
+//PE
+__declspec(dllexport) bool TITCALL StaticFileLoadW(const wchar_t* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL StaticFileUnloadW(const wchar_t* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) ULONG_PTR TITCALL ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType)
+{
+    //TODO
+    return 0;
+}
+
+__declspec(dllexport) ULONG_PTR TITCALL ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType)
+{
+    //TODO
+    return 0;
+}
+
+__declspec(dllexport) ULONG_PTR TITCALL GetPE32DataFromMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData)
+{
+    //TODO
+    return 0;
+}
+
+__declspec(dllexport) ULONG_PTR TITCALL GetPE32DataW(const wchar_t* szFileName, DWORD WhichSection, DWORD WhichData)
+{
+    //TODO
+    return 0;
+}
+
+__declspec(dllexport) bool TITCALL IsFileDLLW(const wchar_t* szFileName, ULONG_PTR FileMapVA)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) long TITCALL GetPE32SectionNumberFromVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert)
+{
+    //TODO
+    return 0;
+}
+
+__declspec(dllexport) bool TITCALL TLSGrabCallBackDataW(const wchar_t* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks)
+{
+    //TODO
+    return false;
+}
+
+//Software Breakpoints
+__declspec(dllexport) bool TITCALL SetBPX(ULONG_PTR bpxAddress, DWORD bpxType, LPVOID bpxCallBack)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL DeleteBPX(ULONG_PTR bpxAddress)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL IsBPXEnabled(ULONG_PTR bpxAddress)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) void TITCALL SetBPXOptions(long DefaultBreakPointType)
+{
+    //TODO
+}
+
+//Memory Breakpoints
+__declspec(dllexport) bool TITCALL SetMemoryBPXEx(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, DWORD BreakPointType, bool RestoreOnHit, LPVOID bpxCallBack)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL RemoveMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory)
+{
+    //TODO
+    return false;
+}
+
+//Hardwre Breakpoints
+__declspec(dllexport) bool TITCALL SetHardwareBreakPoint(ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL DeleteHardwareBreakPoint(DWORD IndexOfRegister)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL GetUnusedHardwareBreakPointRegister(LPDWORD RegisterIndex)
+{
+    //TODO
+    return false;
+}
+
+//Librarian Breakpoints
+__declspec(dllexport) bool TITCALL LibrarianSetBreakPoint(const char* szLibraryName, DWORD bpxType, bool SingleShoot, LPVOID bpxCallBack)
+{
+    //TODO
+    return false;
+}
+
+__declspec(dllexport) bool TITCALL LibrarianRemoveBreakPoint(const char* szLibraryName, DWORD bpxType)
+{
+    //TODO
+    return false;
+}
+
+//Generic Breakpoints
+__declspec(dllexport) bool TITCALL RemoveAllBreakPoints(DWORD RemoveOption)
+{
+    //TODO
+    return false;
+}
+
+//Stepping
+__declspec(dllexport) void TITCALL StepOver(LPVOID traceCallBack)
+{
+    //TODO
+}
+
+__declspec(dllexport) void TITCALL SingleStep(DWORD StepCount, LPVOID StepCallBack)
+{
+    //TODO
+}
+
+__declspec(dllexport) void TITCALL StepInto(LPVOID traceCallBack)
+{
+    //TODO
 }
\ No newline at end of file
diff --git a/TitanEngineEmulator/TitanEngineEmulator.vcxproj b/TitanEngineEmulator/TitanEngineEmulator.vcxproj
index f84fdd2..1912371 100644
--- a/TitanEngineEmulator/TitanEngineEmulator.vcxproj
+++ b/TitanEngineEmulator/TitanEngineEmulator.vcxproj
@@ -118,6 +118,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -133,6 +134,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -145,6 +147,7 @@
     <ClCompile Include="TitanEngineEmulator.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="Emulator.h" />
     <ClInclude Include="TitanEngine.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
diff --git a/TitanEngineEmulator/TitanEngineEmulator.vcxproj.filters b/TitanEngineEmulator/TitanEngineEmulator.vcxproj.filters
index 467f7e8..522d6e8 100644
--- a/TitanEngineEmulator/TitanEngineEmulator.vcxproj.filters
+++ b/TitanEngineEmulator/TitanEngineEmulator.vcxproj.filters
@@ -23,5 +23,8 @@
     <ClInclude Include="TitanEngine.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Emulator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file