From 91292f2660e6b212999d506ea9b12ef7d8fccefb Mon Sep 17 00:00:00 2001 From: cypherpunk Date: Wed, 12 Mar 2014 19:55:38 +0100 Subject: [PATCH] titanscriptgui --- TitanEngine.sln | 8 + TitanScriptGui/AssemblyInfo.cpp | 40 + TitanScriptGui/Form1.h | 268 +++++ TitanScriptGui/Form1.resX | 123 +++ TitanScriptGui/ReadMe.txt | 45 + TitanScriptGui/TitanEngine.h | 934 ++++++++++++++++++ TitanScriptGui/TitanEngine.lib | Bin 0 -> 101964 bytes TitanScriptGui/TitanScript.h | 26 + TitanScriptGui/TitanScriptGui.cpp | 22 + TitanScriptGui/TitanScriptGui.vcxproj | 120 +++ TitanScriptGui/TitanScriptGui.vcxproj.filters | 61 ++ TitanScriptGui/app.ico | Bin 0 -> 1078 bytes TitanScriptGui/app.rc | Bin 0 -> 2626 bytes TitanScriptGui/resource.h | 3 + TitanScriptGui/stdafx.cpp | 7 + TitanScriptGui/stdafx.h | 6 + TitanUnitTest/TitanEngine.h | 18 +- TitanUnitTest/TitanUnitTest.vcxproj | 2 - 18 files changed, 1675 insertions(+), 8 deletions(-) create mode 100644 TitanScriptGui/AssemblyInfo.cpp create mode 100644 TitanScriptGui/Form1.h create mode 100644 TitanScriptGui/Form1.resX create mode 100644 TitanScriptGui/ReadMe.txt create mode 100644 TitanScriptGui/TitanEngine.h create mode 100644 TitanScriptGui/TitanEngine.lib create mode 100644 TitanScriptGui/TitanScript.h create mode 100644 TitanScriptGui/TitanScriptGui.cpp create mode 100644 TitanScriptGui/TitanScriptGui.vcxproj create mode 100644 TitanScriptGui/TitanScriptGui.vcxproj.filters create mode 100644 TitanScriptGui/app.ico create mode 100644 TitanScriptGui/app.rc create mode 100644 TitanScriptGui/resource.h create mode 100644 TitanScriptGui/stdafx.cpp create mode 100644 TitanScriptGui/stdafx.h diff --git a/TitanEngine.sln b/TitanEngine.sln index b19ed88..afab9a5 100644 --- a/TitanEngine.sln +++ b/TitanEngine.sln @@ -5,6 +5,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TitanEngine", "TitanEngine\ EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TitanUnitTest", "TitanUnitTest\TitanUnitTest.vcxproj", "{5B5AB3CD-4D32-43B0-8840-E05C9483381D}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TitanScriptGui", "TitanScriptGui\TitanScriptGui.vcxproj", "{864AC964-6CC4-4738-A811-61C216C1A36D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -27,6 +29,12 @@ Global {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|Win32.ActiveCfg = Release|Win32 {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|Win32.Build.0 = Release|Win32 {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|x64.ActiveCfg = Release|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Debug|Win32.ActiveCfg = Debug|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Debug|Win32.Build.0 = Debug|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Debug|x64.ActiveCfg = Debug|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Release|Win32.ActiveCfg = Release|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Release|Win32.Build.0 = Release|Win32 + {864AC964-6CC4-4738-A811-61C216C1A36D}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/TitanScriptGui/AssemblyInfo.cpp b/TitanScriptGui/AssemblyInfo.cpp new file mode 100644 index 0000000..a1e7ee5 --- /dev/null +++ b/TitanScriptGui/AssemblyInfo.cpp @@ -0,0 +1,40 @@ +#include "stdafx.h" + +using namespace System; +using namespace System::Reflection; +using namespace System::Runtime::CompilerServices; +using namespace System::Runtime::InteropServices; +using namespace System::Security::Permissions; + +// +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +// +[assembly:AssemblyTitleAttribute("TitanScriptGui")]; +[assembly:AssemblyDescriptionAttribute("")]; +[assembly:AssemblyConfigurationAttribute("")]; +[assembly:AssemblyCompanyAttribute("")]; +[assembly:AssemblyProductAttribute("TitanScriptGui")]; +[assembly:AssemblyCopyrightAttribute("Copyright (c) 2014")]; +[assembly:AssemblyTrademarkAttribute("")]; +[assembly:AssemblyCultureAttribute("")]; + +// +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder für die Revisions- und Buildnummer den Standard +// übernehmen, indem Sie "*" eingeben: + +[assembly:AssemblyVersionAttribute("1.0.*")]; + +[assembly:ComVisible(false)]; + +[assembly:CLSCompliantAttribute(true)]; + +[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)]; diff --git a/TitanScriptGui/Form1.h b/TitanScriptGui/Form1.h new file mode 100644 index 0000000..9d228b4 --- /dev/null +++ b/TitanScriptGui/Form1.h @@ -0,0 +1,268 @@ +#pragma once + +#include "TitanEngine.h" +#include "TitanScript.h" + +namespace TitanScriptGui { + +using namespace System; +using namespace System::ComponentModel; +using namespace System::Collections; +using namespace System::Windows::Forms; +using namespace System::Data; +using namespace System::Drawing; +using namespace System::Runtime::InteropServices; + +public delegate void log_callback_delegate( const char* str, eLogType log_type ); +/// +/// Zusammenfassung für Form1 +/// +public ref class Form1 : public System::Windows::Forms::Form +{ +public: + Form1(void) + { + InitializeComponent(); + InitializeTitanScript(); + } + +protected: + /// + /// Verwendete Ressourcen bereinigen. + /// + ~Form1() + { + if (components) + { + delete components; + } + } +private: + System::Windows::Forms::TextBox^ textBox_targetPath; +protected: +private: + +protected: +private: + System::Windows::Forms::Label^ label1; +private: + System::Windows::Forms::Button^ openTarget; +private: + +private: + +private: + System::Windows::Forms::Label^ label2; +private: + System::Windows::Forms::TextBox^ textBox_scriptPath; +private: + System::Windows::Forms::Button^ openScript; +private: + +private: + +private: + +private: + System::Windows::Forms::GroupBox^ groupBox1; +private: + System::Windows::Forms::TextBox^ logBox; +private: + +private: + System::Windows::Forms::Button^ run; +private: + +private: + System::Windows::Forms::OpenFileDialog^ openFileDialog1; + +private: + tScripterLoadFileA load_file; + tScripterExecuteWithTitanMistA exec; + tScripterSetLogCallback set_log_callback; + + log_callback_delegate^ logdelegate; + +private: + /// + /// Erforderliche Designervariable. + /// + System::ComponentModel::Container ^components; + + #pragma region Windows Form Designer generated code + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + void InitializeComponent(void) + { + this->textBox_targetPath = (gcnew System::Windows::Forms::TextBox()); + this->label1 = (gcnew System::Windows::Forms::Label()); + this->openTarget = (gcnew System::Windows::Forms::Button()); + this->label2 = (gcnew System::Windows::Forms::Label()); + this->textBox_scriptPath = (gcnew System::Windows::Forms::TextBox()); + this->openScript = (gcnew System::Windows::Forms::Button()); + this->groupBox1 = (gcnew System::Windows::Forms::GroupBox()); + this->logBox = (gcnew System::Windows::Forms::TextBox()); + this->run = (gcnew System::Windows::Forms::Button()); + this->openFileDialog1 = (gcnew System::Windows::Forms::OpenFileDialog()); + this->groupBox1->SuspendLayout(); + this->SuspendLayout(); + // + // textBox_targetPath + // + this->textBox_targetPath->Location = System::Drawing::Point(60, 12); + this->textBox_targetPath->Name = L"textBox_targetPath"; + this->textBox_targetPath->Size = System::Drawing::Size(168, 20); + this->textBox_targetPath->TabIndex = 0; + // + // label1 + // + this->label1->AutoSize = true; + this->label1->Location = System::Drawing::Point(10, 12); + this->label1->Name = L"label1"; + this->label1->Size = System::Drawing::Size(44, 13); + this->label1->TabIndex = 1; + this->label1->Text = L"[Target]"; + // + // openTarget + // + this->openTarget->Location = System::Drawing::Point(234, 12); + this->openTarget->Name = L"openTarget"; + this->openTarget->Size = System::Drawing::Size(75, 23); + this->openTarget->TabIndex = 2; + this->openTarget->Text = L"[Open...]"; + this->openTarget->UseVisualStyleBackColor = true; + this->openTarget->Click += gcnew System::EventHandler(this, &Form1::openTarget_Click); + // + // label2 + // + this->label2->AutoSize = true; + this->label2->Location = System::Drawing::Point(10, 44); + this->label2->Name = L"label2"; + this->label2->Size = System::Drawing::Size(40, 13); + this->label2->TabIndex = 3; + this->label2->Text = L"[Script]"; + // + // textBox_scriptPath + // + this->textBox_scriptPath->Location = System::Drawing::Point(60, 44); + this->textBox_scriptPath->Name = L"textBox_scriptPath"; + this->textBox_scriptPath->Size = System::Drawing::Size(168, 20); + this->textBox_scriptPath->TabIndex = 4; + // + // openScript + // + this->openScript->Location = System::Drawing::Point(234, 44); + this->openScript->Name = L"openScript"; + this->openScript->Size = System::Drawing::Size(75, 23); + this->openScript->TabIndex = 5; + this->openScript->Text = L"[Open...]"; + this->openScript->UseVisualStyleBackColor = true; + this->openScript->Click += gcnew System::EventHandler(this, &Form1::openScript_Click); + // + // groupBox1 + // + this->groupBox1->Controls->Add(this->logBox); + this->groupBox1->Location = System::Drawing::Point(13, 70); + this->groupBox1->Name = L"groupBox1"; + this->groupBox1->Size = System::Drawing::Size(294, 285); + this->groupBox1->TabIndex = 6; + this->groupBox1->TabStop = false; + this->groupBox1->Text = L"[Log]"; + // + // logBox + // + this->logBox->Location = System::Drawing::Point(6, 19); + this->logBox->Multiline = true; + this->logBox->Name = L"logBox"; + this->logBox->Size = System::Drawing::Size(282, 260); + this->logBox->TabIndex = 0; + // + // run + // + this->run->Location = System::Drawing::Point(122, 361); + this->run->Name = L"run"; + this->run->Size = System::Drawing::Size(75, 23); + this->run->TabIndex = 7; + this->run->Text = L"[Run]"; + this->run->UseVisualStyleBackColor = true; + this->run->Click += gcnew System::EventHandler(this, &Form1::run_Click); + // + // openFileDialog1 + // + this->openFileDialog1->FileName = L"openFileDialog1"; + // + // Form1 + // + this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); + this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; + this->ClientSize = System::Drawing::Size(319, 389); + this->Controls->Add(this->run); + this->Controls->Add(this->groupBox1); + this->Controls->Add(this->openScript); + this->Controls->Add(this->textBox_scriptPath); + this->Controls->Add(this->label2); + this->Controls->Add(this->openTarget); + this->Controls->Add(this->label1); + this->Controls->Add(this->textBox_targetPath); + this->Name = L"Form1"; + this->Text = L"TitanScriptGUI"; + this->groupBox1->ResumeLayout(false); + this->groupBox1->PerformLayout(); + this->ResumeLayout(false); + this->PerformLayout(); + + } + #pragma endregion + + void InitializeTitanScript(void) { + load_file = GetTSFunctionPointer( LoadFileA ); + exec = GetTSFunctionPointer( ExecuteWithTitanMistA ); + set_log_callback = GetTSFunctionPointer( SetLogCallback ); + + //register log callback + logdelegate = gcnew log_callback_delegate(this, &Form1::log_callback); + IntPtr thunk = System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(logdelegate); + set_log_callback((fLogCallback)(void*)thunk); + } + +private: + System::Void openTarget_Click(System::Object^ sender, System::EventArgs^ e) { + if(openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK) { + textBox_targetPath->Text = openFileDialog1->FileName; + } + } +private: + System::Void openScript_Click(System::Object^ sender, System::EventArgs^ e) { + if(openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK) { + textBox_scriptPath->Text = openFileDialog1->FileName; + } + } +private: + System::Void run_Click(System::Object^ sender, System::EventArgs^ e) { + logBox->Clear(); + + const char* scriptPath = (const char*)(void*) Marshal::StringToHGlobalAnsi(textBox_scriptPath->Text); + const char* targetPath = (const char*)(void*) Marshal::StringToHGlobalAnsi(textBox_targetPath->Text); + + if(!load_file(scriptPath)) { + logBox->AppendText("[Error] Couldnt load the script"); + } + + bool ret = exec(targetPath, "dump.exe"); + + Marshal::FreeHGlobal(IntPtr((void*)scriptPath)); + Marshal::FreeHGlobal(IntPtr((void*)targetPath)); + } + +private: + void log_callback( const char* str, eLogType log_type ) { + logBox->AppendText(gcnew String(str)); + } + +}; + + +} + diff --git a/TitanScriptGui/Form1.resX b/TitanScriptGui/Form1.resX new file mode 100644 index 0000000..753eb0c --- /dev/null +++ b/TitanScriptGui/Form1.resX @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 7, 12 + + \ No newline at end of file diff --git a/TitanScriptGui/ReadMe.txt b/TitanScriptGui/ReadMe.txt new file mode 100644 index 0000000..9be8edb --- /dev/null +++ b/TitanScriptGui/ReadMe.txt @@ -0,0 +1,45 @@ +======================================================================== + ANWENDUNG: TitanScriptGui-Projektübersicht +======================================================================== + +Diese TitanScriptGui-Anwendung wurde vom Anwendungs-Assistenten +für Sie erstellt. + +Diese Datei bietet eine Ãœbersicht über den Inhalt der einzelnen Dateien, +aus denen Ihre TitanScriptGui-Anwendung besteht. + +TitanScriptGui.vcxproj + Dies ist die Hauptprojektdatei für VC++-Projekte, die mit dem + Anwendungs-Assistenten generiert werden. + Sie enthält Informationen über die Version von Visual C++, mit der die + Datei generiert wurde, sowie über die Plattformen, Konfigurationen und + Projektfunktionen, die im Anwendungs-Assistenten ausgewählt wurden. + +TitanScriptGui.vcxproj.filters + Dies ist die Filterdatei für VC++-Projekte, die mithilfe eines + Anwendungs-Assistenten erstellt werden. + Sie enthält Informationen über die Zuordnung zwischen den Dateien im + Projekt und den Filtern. Diese Zuordnung wird in der IDE zur Darstellung + der Gruppierung von Dateien mit ähnlichen Erweiterungen unter einem + bestimmten Knoten verwendet (z. B. sind CPP-Dateien dem Filter + "Quelldateien" zugeordnet). + +TitanScriptGui.cpp + Dies ist die Hauptquelldatei der Anwendung. + Enthält den Code zum Anzeigen des Formulars. + +Form1.h + Enthält die Implementierung der Formularklasse und der InitializeComponent()-Funktion. + +AssemblyInfo.cpp + Enthält benutzerdefinierte Attribute zum Ändern von Assemblymetadaten. + +///////////////////////////////////////////////////////////////////////////// +Andere Standarddateien: + +StdAfx.h, StdAfx.cpp + Diese Dateien werden verwendet, um eine vorkompilierte Headerdatei + (PCH-Datei) mit dem Namen "TitanScriptGui.pch und eine + vorkompilierte Typendatei mit dem Namen "StdAfx.obj" zu erstellen. + +///////////////////////////////////////////////////////////////////////////// diff --git a/TitanScriptGui/TitanEngine.h b/TitanScriptGui/TitanEngine.h new file mode 100644 index 0000000..03b8667 --- /dev/null +++ b/TitanScriptGui/TitanEngine.h @@ -0,0 +1,934 @@ +#ifndef TITANENGINE +#define TITANENGINE + +#define TITCALL __cdecl + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +#pragma pack(push, 1) + +// Global.Constant.Structure.Declaration: +// Engine.External: +const BYTE UE_ACCESS_READ = 0; +const BYTE UE_ACCESS_WRITE = 1; +const BYTE UE_ACCESS_ALL = 2; + +const BYTE UE_HIDE_PEBONLY = 0; +const BYTE UE_HIDE_BASIC = 1; + +const BYTE UE_PLUGIN_CALL_REASON_PREDEBUG = 1; +const BYTE UE_PLUGIN_CALL_REASON_EXCEPTION = 2; +const BYTE UE_PLUGIN_CALL_REASON_POSTDEBUG = 3; +const BYTE UE_PLUGIN_CALL_REASON_UNHANDLEDEXCEPTION = 4; + +const BYTE TEE_HOOK_NRM_JUMP = 1; +const BYTE TEE_HOOK_NRM_CALL = 3; +const BYTE TEE_HOOK_IAT = 5; + +const BYTE UE_ENGINE_ALOW_MODULE_LOADING = 1; +const BYTE UE_ENGINE_AUTOFIX_FORWARDERS = 2; +const BYTE UE_ENGINE_PASS_ALL_EXCEPTIONS = 3; +const BYTE UE_ENGINE_NO_CONSOLE_WINDOW = 4; +const BYTE UE_ENGINE_BACKUP_FOR_CRITICAL_FUNCTIONS = 5; +const BYTE UE_ENGINE_CALL_PLUGIN_CALLBACK = 6; +const BYTE UE_ENGINE_RESET_CUSTOM_HANDLER = 7; +const BYTE UE_ENGINE_CALL_PLUGIN_DEBUG_CALLBACK = 8; + +const BYTE UE_OPTION_REMOVEALL = 1; +const BYTE UE_OPTION_DISABLEALL = 2; +const BYTE UE_OPTION_REMOVEALLDISABLED = 3; +const BYTE UE_OPTION_REMOVEALLENABLED = 4; + +const BYTE UE_STATIC_DECRYPTOR_XOR = 1; +const BYTE UE_STATIC_DECRYPTOR_SUB = 2; +const BYTE UE_STATIC_DECRYPTOR_ADD = 3; + +const BYTE UE_STATIC_DECRYPTOR_FOREWARD = 1; +const BYTE UE_STATIC_DECRYPTOR_BACKWARD = 2; + +const BYTE UE_STATIC_KEY_SIZE_1 = 1; +const BYTE UE_STATIC_KEY_SIZE_2 = 2; +const BYTE UE_STATIC_KEY_SIZE_4 = 4; +const BYTE UE_STATIC_KEY_SIZE_8 = 8; + +const BYTE UE_STATIC_APLIB = 1; +const BYTE UE_STATIC_APLIB_DEPACK = 2; +const BYTE UE_STATIC_LZMA = 3; + +const BYTE UE_STATIC_HASH_MD5 = 1; +const BYTE UE_STATIC_HASH_SHA1 = 2; +const BYTE UE_STATIC_HASH_CRC32 = 3; + +const DWORD UE_RESOURCE_LANGUAGE_ANY = -1; + +const BYTE UE_PE_OFFSET = 0; +const BYTE UE_IMAGEBASE = 1; +const BYTE UE_OEP = 2; +const BYTE UE_SIZEOFIMAGE = 3; +const BYTE UE_SIZEOFHEADERS = 4; +const BYTE UE_SIZEOFOPTIONALHEADER = 5; +const BYTE UE_SECTIONALIGNMENT = 6; +const BYTE UE_IMPORTTABLEADDRESS = 7; +const BYTE UE_IMPORTTABLESIZE = 8; +const BYTE UE_RESOURCETABLEADDRESS = 9; +const BYTE UE_RESOURCETABLESIZE = 10; +const BYTE UE_EXPORTTABLEADDRESS = 11; +const BYTE UE_EXPORTTABLESIZE = 12; +const BYTE UE_TLSTABLEADDRESS = 13; +const BYTE UE_TLSTABLESIZE = 14; +const BYTE UE_RELOCATIONTABLEADDRESS = 15; +const BYTE UE_RELOCATIONTABLESIZE = 16; +const BYTE UE_TIMEDATESTAMP = 17; +const BYTE UE_SECTIONNUMBER = 18; +const BYTE UE_CHECKSUM = 19; +const BYTE UE_SUBSYSTEM = 20; +const BYTE UE_CHARACTERISTICS = 21; +const BYTE UE_NUMBEROFRVAANDSIZES = 22; +const BYTE UE_BASEOFCODE = 23; +const BYTE UE_BASEOFDATA = 24; +//leaving some enum space here for future additions +const BYTE UE_SECTIONNAME = 40; +const BYTE UE_SECTIONVIRTUALOFFSET = 41; +const BYTE UE_SECTIONVIRTUALSIZE = 42; +const BYTE UE_SECTIONRAWOFFSET = 43; +const BYTE UE_SECTIONRAWSIZE = 44; +const BYTE UE_SECTIONFLAGS = 45; + +const long UE_VANOTFOUND = -2; + +const BYTE UE_CH_BREAKPOINT = 1; +const BYTE UE_CH_SINGLESTEP = 2; +const BYTE UE_CH_ACCESSVIOLATION = 3; +const BYTE UE_CH_ILLEGALINSTRUCTION = 4; +const BYTE UE_CH_NONCONTINUABLEEXCEPTION = 5; +const BYTE UE_CH_ARRAYBOUNDSEXCEPTION = 6; +const BYTE UE_CH_FLOATDENORMALOPERAND = 7; +const BYTE UE_CH_FLOATDEVIDEBYZERO = 8; +const BYTE UE_CH_INTEGERDEVIDEBYZERO = 9; +const BYTE UE_CH_INTEGEROVERFLOW = 10; +const BYTE UE_CH_PRIVILEGEDINSTRUCTION = 11; +const BYTE UE_CH_PAGEGUARD = 12; +const BYTE UE_CH_EVERYTHINGELSE = 13; +const BYTE UE_CH_CREATETHREAD = 14; +const BYTE UE_CH_EXITTHREAD = 15; +const BYTE UE_CH_CREATEPROCESS = 16; +const BYTE UE_CH_EXITPROCESS = 17; +const BYTE UE_CH_LOADDLL = 18; +const BYTE UE_CH_UNLOADDLL = 19; +const BYTE UE_CH_OUTPUTDEBUGSTRING = 20; +const BYTE UE_CH_AFTEREXCEPTIONPROCESSING = 21; +const BYTE UE_CH_ALLEVENTS = 22; +const BYTE UE_CH_SYSTEMBREAKPOINT = 23; +const BYTE UE_CH_UNHANDLEDEXCEPTION = 24; +const BYTE UE_CH_RIPEVENT = 25; + +const BYTE UE_OPTION_HANDLER_RETURN_HANDLECOUNT = 1; +const BYTE UE_OPTION_HANDLER_RETURN_ACCESS = 2; +const BYTE UE_OPTION_HANDLER_RETURN_FLAGS = 3; +const BYTE UE_OPTION_HANDLER_RETURN_TYPENAME = 4; + +const BYTE UE_BREAKPOINT_INT3 = 1; +const BYTE UE_BREAKPOINT_LONG_INT3 = 2; +const BYTE UE_BREAKPOINT_UD2 = 3; + +const BYTE UE_BPXREMOVED = 0; +const BYTE UE_BPXACTIVE = 1; +const BYTE UE_BPXINACTIVE = 2; + +const BYTE UE_BREAKPOINT = 0; +const BYTE UE_SINGLESHOOT = 1; +const BYTE UE_HARDWARE = 2; +const BYTE UE_MEMORY = 3; +const BYTE UE_MEMORY_READ = 4; +const BYTE UE_MEMORY_WRITE = 5; +const BYTE UE_MEMORY_EXECUTE = 6; +const DWORD UE_BREAKPOINT_TYPE_INT3 = 0x10000000; +const DWORD UE_BREAKPOINT_TYPE_LONG_INT3 = 0x20000000; +const DWORD UE_BREAKPOINT_TYPE_UD2 = 0x30000000; + +const BYTE UE_HARDWARE_EXECUTE = 4; +const BYTE UE_HARDWARE_WRITE = 5; +const BYTE UE_HARDWARE_READWRITE = 6; + +const BYTE UE_HARDWARE_SIZE_1 = 7; +const BYTE UE_HARDWARE_SIZE_2 = 8; +const BYTE UE_HARDWARE_SIZE_4 = 9; +const BYTE UE_HARDWARE_SIZE_8 = 10; + +const BYTE UE_ON_LIB_LOAD = 1; +const BYTE UE_ON_LIB_UNLOAD = 2; +const BYTE UE_ON_LIB_ALL = 3; + +const BYTE UE_APISTART = 0; +const BYTE UE_APIEND = 1; + +const BYTE UE_PLATFORM_x86 = 1; +const BYTE UE_PLATFORM_x64 = 2; +const BYTE UE_PLATFORM_ALL = 3; + +const BYTE UE_FUNCTION_STDCALL = 1; +const BYTE UE_FUNCTION_CCALL = 2; +const BYTE UE_FUNCTION_FASTCALL = 3; +const BYTE UE_FUNCTION_STDCALL_RET = 4; +const BYTE UE_FUNCTION_CCALL_RET = 5; +const BYTE UE_FUNCTION_FASTCALL_RET = 6; +const BYTE UE_FUNCTION_STDCALL_CALL = 7; +const BYTE UE_FUNCTION_CCALL_CALL = 8; +const BYTE UE_FUNCTION_FASTCALL_CALL = 9; +const BYTE UE_PARAMETER_BYTE = 0; +const BYTE UE_PARAMETER_WORD = 1; +const BYTE UE_PARAMETER_DWORD = 2; +const BYTE UE_PARAMETER_QWORD = 3; +const BYTE UE_PARAMETER_PTR_BYTE = 4; +const BYTE UE_PARAMETER_PTR_WORD = 5; +const BYTE UE_PARAMETER_PTR_DWORD = 6; +const BYTE UE_PARAMETER_PTR_QWORD = 7; +const BYTE UE_PARAMETER_STRING = 8; +const BYTE UE_PARAMETER_UNICODE = 9; + +const BYTE UE_EAX = 1; +const BYTE UE_EBX = 2; +const BYTE UE_ECX = 3; +const BYTE UE_EDX = 4; +const BYTE UE_EDI = 5; +const BYTE UE_ESI = 6; +const BYTE UE_EBP = 7; +const BYTE UE_ESP = 8; +const BYTE UE_EIP = 9; +const BYTE UE_EFLAGS = 10; +const BYTE UE_DR0 = 11; +const BYTE UE_DR1 = 12; +const BYTE UE_DR2 = 13; +const BYTE UE_DR3 = 14; +const BYTE UE_DR6 = 15; +const BYTE UE_DR7 = 16; +const BYTE UE_RAX = 17; +const BYTE UE_RBX = 18; +const BYTE UE_RCX = 19; +const BYTE UE_RDX = 20; +const BYTE UE_RDI = 21; +const BYTE UE_RSI = 22; +const BYTE UE_RBP = 23; +const BYTE UE_RSP = 24; +const BYTE UE_RIP = 25; +const BYTE UE_RFLAGS = 26; +const BYTE UE_R8 = 27; +const BYTE UE_R9 = 28; +const BYTE UE_R10 = 29; +const BYTE UE_R11 = 30; +const BYTE UE_R12 = 31; +const BYTE UE_R13 = 32; +const BYTE UE_R14 = 33; +const BYTE UE_R15 = 34; +const BYTE UE_CIP = 35; +const BYTE UE_CSP = 36; +#ifdef _WIN64 +const BYTE UE_CFLAGS = UE_RFLAGS; +#else +const BYTE UE_CFLAGS = UE_EFLAGS; +#endif +const BYTE UE_SEG_GS = 37; +const BYTE UE_SEG_FS = 38; +const BYTE UE_SEG_ES = 39; +const BYTE UE_SEG_DS = 40; +const BYTE UE_SEG_CS = 41; +const BYTE UE_SEG_SS = 42; + +typedef struct +{ + DWORD PE32Offset; + DWORD ImageBase; + DWORD OriginalEntryPoint; + DWORD BaseOfCode; + DWORD BaseOfData; + DWORD NtSizeOfImage; + DWORD NtSizeOfHeaders; + WORD SizeOfOptionalHeaders; + DWORD FileAlignment; + DWORD SectionAligment; + DWORD ImportTableAddress; + DWORD ImportTableSize; + DWORD ResourceTableAddress; + DWORD ResourceTableSize; + DWORD ExportTableAddress; + DWORD ExportTableSize; + DWORD TLSTableAddress; + DWORD TLSTableSize; + DWORD RelocationTableAddress; + DWORD RelocationTableSize; + DWORD TimeDateStamp; + WORD SectionNumber; + DWORD CheckSum; + WORD SubSystem; + WORD Characteristics; + DWORD NumberOfRvaAndSizes; +} PE32Struct, *PPE32Struct; + +typedef struct +{ + DWORD PE64Offset; + DWORD64 ImageBase; + DWORD OriginalEntryPoint; + DWORD BaseOfCode; + DWORD BaseOfData; + DWORD NtSizeOfImage; + DWORD NtSizeOfHeaders; + WORD SizeOfOptionalHeaders; + DWORD FileAlignment; + DWORD SectionAligment; + DWORD ImportTableAddress; + DWORD ImportTableSize; + DWORD ResourceTableAddress; + DWORD ResourceTableSize; + DWORD ExportTableAddress; + DWORD ExportTableSize; + DWORD TLSTableAddress; + DWORD TLSTableSize; + DWORD RelocationTableAddress; + DWORD RelocationTableSize; + DWORD TimeDateStamp; + WORD SectionNumber; + DWORD CheckSum; + WORD SubSystem; + WORD Characteristics; + DWORD NumberOfRvaAndSizes; +} PE64Struct, *PPE64Struct; + +#if defined(_WIN64) +typedef PE64Struct PEStruct; +#else +typedef PE32Struct PEStruct; +#endif + +typedef struct +{ + bool NewDll; + int NumberOfImports; + ULONG_PTR ImageBase; + ULONG_PTR BaseImportThunk; + ULONG_PTR ImportThunk; + char* APIName; + char* DLLName; +} ImportEnumData, *PImportEnumData; + +typedef struct +{ + HANDLE hThread; + DWORD dwThreadId; + void* ThreadStartAddress; + void* ThreadLocalBase; +} THREAD_ITEM_DATA, *PTHREAD_ITEM_DATA; + +typedef struct +{ + HANDLE hFile; + void* BaseOfDll; + HANDLE hFileMapping; + void* hFileMappingView; + char szLibraryPath[MAX_PATH]; + char szLibraryName[MAX_PATH]; +} LIBRARY_ITEM_DATA, *PLIBRARY_ITEM_DATA; + +typedef struct +{ + HANDLE hFile; + void* BaseOfDll; + HANDLE hFileMapping; + void* hFileMappingView; + wchar_t szLibraryPath[MAX_PATH]; + wchar_t szLibraryName[MAX_PATH]; +} LIBRARY_ITEM_DATAW, *PLIBRARY_ITEM_DATAW; + +typedef struct +{ + HANDLE hProcess; + DWORD dwProcessId; + HANDLE hThread; + DWORD dwThreadId; + HANDLE hFile; + void* BaseOfImage; + void* ThreadStartAddress; + void* ThreadLocalBase; +} PROCESS_ITEM_DATA, *PPROCESS_ITEM_DATA; + +typedef struct +{ + ULONG ProcessId; + HANDLE hHandle; +} HandlerArray, *PHandlerArray; + +typedef struct +{ + char PluginName[64]; + DWORD PluginMajorVersion; + DWORD PluginMinorVersion; + HMODULE PluginBaseAddress; + void* TitanDebuggingCallBack; + void* TitanRegisterPlugin; + void* TitanReleasePlugin; + void* TitanResetPlugin; + bool PluginDisabled; +} PluginInformation, *PPluginInformation; + +const size_t TEE_MAXIMUM_HOOK_SIZE = 14; +const size_t TEE_MAXIMUM_HOOK_RELOCS = 7; +#if defined(_WIN64) +const size_t TEE_MAXIMUM_HOOK_INSERT_SIZE = 14; +#else +const size_t TEE_MAXIMUM_HOOK_INSERT_SIZE = 5; +#endif + +typedef struct HOOK_ENTRY +{ + bool IATHook; + BYTE HookType; + DWORD HookSize; + void* HookAddress; + void* RedirectionAddress; + BYTE HookBytes[TEE_MAXIMUM_HOOK_SIZE]; + BYTE OriginalBytes[TEE_MAXIMUM_HOOK_SIZE]; + void* IATHookModuleBase; + DWORD IATHookNameHash; + bool HookIsEnabled; + bool HookIsRemote; + void* PatchedEntry; + DWORD RelocationInfo[TEE_MAXIMUM_HOOK_RELOCS]; + int RelocationCount; +} HOOK_ENTRY, *PHOOK_ENTRY; + +const BYTE UE_DEPTH_SURFACE = 0; +const BYTE UE_DEPTH_DEEP = 1; + +const BYTE UE_UNPACKER_CONDITION_SEARCH_FROM_EP = 1; + +const BYTE UE_UNPACKER_CONDITION_LOADLIBRARY = 1; +const BYTE UE_UNPACKER_CONDITION_GETPROCADDRESS = 2; +const BYTE UE_UNPACKER_CONDITION_ENTRYPOINTBREAK = 3; +const BYTE UE_UNPACKER_CONDITION_RELOCSNAPSHOT1 = 4; +const BYTE UE_UNPACKER_CONDITION_RELOCSNAPSHOT2 = 5; + +const BYTE UE_FIELD_OK = 0; +const BYTE UE_FIELD_BROKEN_NON_FIXABLE = 1; +const BYTE UE_FIELD_BROKEN_NON_CRITICAL = 2; +const BYTE UE_FIELD_BROKEN_FIXABLE_FOR_STATIC_USE = 3; +const BYTE UE_FIELD_BROKEN_BUT_CAN_BE_EMULATED = 4; +const BYTE UE_FIELD_FIXABLE_NON_CRITICAL = 5; +const BYTE UE_FIELD_FIXABLE_CRITICAL = 6; +const BYTE UE_FIELD_NOT_PRESET = 7; +const BYTE UE_FIELD_NOT_PRESET_WARNING = 8; + +const BYTE UE_RESULT_FILE_OK = 10; +const BYTE UE_RESULT_FILE_INVALID_BUT_FIXABLE = 11; +const BYTE UE_RESULT_FILE_INVALID_AND_NON_FIXABLE = 12; +const BYTE UE_RESULT_FILE_INVALID_FORMAT = 13; + +typedef struct +{ + BYTE OveralEvaluation; + bool EvaluationTerminatedByException; + bool FileIs64Bit; + bool FileIsDLL; + bool FileIsConsole; + bool MissingDependencies; + bool MissingDeclaredAPIs; + BYTE SignatureMZ; + BYTE SignaturePE; + BYTE EntryPoint; + BYTE ImageBase; + BYTE SizeOfImage; + BYTE FileAlignment; + BYTE SectionAlignment; + BYTE ExportTable; + BYTE RelocationTable; + BYTE ImportTable; + BYTE ImportTableSection; + BYTE ImportTableData; + BYTE IATTable; + BYTE TLSTable; + BYTE LoadConfigTable; + BYTE BoundImportTable; + BYTE COMHeaderTable; + BYTE ResourceTable; + BYTE ResourceData; + BYTE SectionTable; +} FILE_STATUS_INFO, *PFILE_STATUS_INFO; + +typedef struct +{ + BYTE OveralEvaluation; + bool FixingTerminatedByException; + bool FileFixPerformed; + bool StrippedRelocation; + bool DontFixRelocations; + DWORD OriginalRelocationTableAddress; + DWORD OriginalRelocationTableSize; + bool StrippedExports; + bool DontFixExports; + DWORD OriginalExportTableAddress; + DWORD OriginalExportTableSize; + bool StrippedResources; + bool DontFixResources; + DWORD OriginalResourceTableAddress; + DWORD OriginalResourceTableSize; + bool StrippedTLS; + bool DontFixTLS; + DWORD OriginalTLSTableAddress; + DWORD OriginalTLSTableSize; + bool StrippedLoadConfig; + bool DontFixLoadConfig; + DWORD OriginalLoadConfigTableAddress; + DWORD OriginalLoadConfigTableSize; + bool StrippedBoundImports; + bool DontFixBoundImports; + DWORD OriginalBoundImportTableAddress; + DWORD OriginalBoundImportTableSize; + bool StrippedIAT; + bool DontFixIAT; + DWORD OriginalImportAddressTableAddress; + DWORD OriginalImportAddressTableSize; + bool StrippedCOM; + bool DontFixCOM; + DWORD OriginalCOMTableAddress; + DWORD OriginalCOMTableSize; +} FILE_FIX_INFO, *PFILE_FIX_INFO; + +#ifdef __cplusplus +extern "C" { +#endif /*__cplusplus*/ + +// Global.Function.Declaration: +// TitanEngine.Dumper.functions: +__declspec(dllimport) bool TITCALL DumpProcess(HANDLE hProcess, LPVOID ImageBase, char* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessW(HANDLE hProcess, LPVOID ImageBase, wchar_t* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessEx(DWORD ProcessId, LPVOID ImageBase, char* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessExW(DWORD ProcessId, LPVOID ImageBase, wchar_t* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpMemory(HANDLE hProcess, LPVOID MemoryStart, ULONG_PTR MemorySize, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryW(HANDLE hProcess, LPVOID MemoryStart, ULONG_PTR MemorySize, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryEx(DWORD ProcessId, LPVOID MemoryStart, ULONG_PTR MemorySize, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryExW(DWORD ProcessId, LPVOID MemoryStart, ULONG_PTR MemorySize, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpRegions(HANDLE hProcess, char* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsW(HANDLE hProcess, wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsEx(DWORD ProcessId, char* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsExW(DWORD ProcessId, wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpModule(HANDLE hProcess, LPVOID ModuleBase, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleW(HANDLE hProcess, LPVOID ModuleBase, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleEx(DWORD ProcessId, LPVOID ModuleBase, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleExW(DWORD ProcessId, LPVOID ModuleBase, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL PastePEHeader(HANDLE hProcess, LPVOID ImageBase, char* szDebuggedFileName); +__declspec(dllimport) bool TITCALL PastePEHeaderW(HANDLE hProcess, LPVOID ImageBase, wchar_t* szDebuggedFileName); +__declspec(dllimport) bool TITCALL ExtractSection(char* szFileName, char* szDumpFileName, DWORD SectionNumber); +__declspec(dllimport) bool TITCALL ExtractSectionW(wchar_t* szFileName, wchar_t* szDumpFileName, DWORD SectionNumber); +__declspec(dllimport) bool TITCALL ResortFileSections(char* szFileName); +__declspec(dllimport) bool TITCALL ResortFileSectionsW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL FindOverlay(char* szFileName, LPDWORD OverlayStart, LPDWORD OverlaySize); +__declspec(dllimport) bool TITCALL FindOverlayW(wchar_t* szFileName, LPDWORD OverlayStart, LPDWORD OverlaySize); +__declspec(dllimport) bool TITCALL ExtractOverlay(char* szFileName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ExtractOverlayW(wchar_t* szFileName, wchar_t* szExtractedFileName); +__declspec(dllimport) bool TITCALL AddOverlay(char* szFileName, char* szOverlayFileName); +__declspec(dllimport) bool TITCALL AddOverlayW(wchar_t* szFileName, wchar_t* szOverlayFileName); +__declspec(dllimport) bool TITCALL CopyOverlay(char* szInFileName, char* szOutFileName); +__declspec(dllimport) bool TITCALL CopyOverlayW(wchar_t* szInFileName, wchar_t* szOutFileName); +__declspec(dllimport) bool TITCALL RemoveOverlay(char* szFileName); +__declspec(dllimport) bool TITCALL RemoveOverlayW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL MakeAllSectionsRWE(char* szFileName); +__declspec(dllimport) bool TITCALL MakeAllSectionsRWEW(wchar_t* szFileName); +__declspec(dllimport) long TITCALL AddNewSectionEx(char* szFileName, char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, LPVOID SectionContent, DWORD ContentSize); +__declspec(dllimport) long TITCALL AddNewSectionExW(wchar_t* szFileName, char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, LPVOID SectionContent, DWORD ContentSize); +__declspec(dllimport) long TITCALL AddNewSection(char* szFileName, char* szSectionName, DWORD SectionSize); +__declspec(dllimport) long TITCALL AddNewSectionW(wchar_t* szFileName, char* szSectionName, DWORD SectionSize); +__declspec(dllimport) bool TITCALL ResizeLastSection(char* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData); +__declspec(dllimport) bool TITCALL ResizeLastSectionW(wchar_t* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData); +__declspec(dllimport) void TITCALL SetSharedOverlay(char* szFileName); +__declspec(dllimport) void TITCALL SetSharedOverlayW(wchar_t* szFileName); +__declspec(dllimport) char* TITCALL GetSharedOverlay(); +__declspec(dllimport) wchar_t* TITCALL GetSharedOverlayW(); +__declspec(dllimport) bool TITCALL DeleteLastSection(char* szFileName); +__declspec(dllimport) bool TITCALL DeleteLastSectionW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL DeleteLastSectionEx(char* szFileName, DWORD NumberOfSections); +__declspec(dllimport) bool TITCALL DeleteLastSectionExW(wchar_t* szFileName, DWORD NumberOfSections); +__declspec(dllimport) long long TITCALL GetPE32DataFromMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) long long TITCALL GetPE32Data(char* szFileName, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) long long TITCALL GetPE32DataW(wchar_t* szFileName, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) bool TITCALL GetPE32DataFromMappedFileEx(ULONG_PTR FileMapVA, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL GetPE32DataEx(char* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL GetPE32DataExW(wchar_t* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataForMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32Data(char* szFileName, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32DataW(wchar_t* szFileName, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32DataForMappedFileEx(ULONG_PTR FileMapVA, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataEx(char* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataExW(wchar_t* szFileName, LPVOID DataStorage); +__declspec(dllimport) long TITCALL GetPE32SectionNumberFromVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert); +__declspec(dllimport) long long TITCALL ConvertVAtoFileOffset(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertFileOffsetToVAEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllimport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead); +__declspec(dllimport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); +// TitanEngine.Realigner.functions: +__declspec(dllimport) bool TITCALL FixHeaderCheckSum(char* szFileName); +__declspec(dllimport) bool TITCALL FixHeaderCheckSumW(wchar_t* szFileName); +__declspec(dllimport) long TITCALL RealignPE(ULONG_PTR FileMapVA, DWORD FileSize, DWORD RealingMode); +__declspec(dllimport) long TITCALL RealignPEEx(char* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment); +__declspec(dllimport) long TITCALL RealignPEExW(wchar_t* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment); +__declspec(dllimport) bool TITCALL WipeSection(char* szFileName, int WipeSectionNumber, bool RemovePhysically); +__declspec(dllimport) bool TITCALL WipeSectionW(wchar_t* szFileName, int WipeSectionNumber, bool RemovePhysically); +__declspec(dllimport) bool TITCALL IsPE32FileValidEx(char* szFileName, DWORD CheckDepth, LPVOID FileStatusInfo); +__declspec(dllimport) bool TITCALL IsPE32FileValidExW(wchar_t* szFileName, DWORD CheckDepth, LPVOID FileStatusInfo); +__declspec(dllimport) bool TITCALL FixBrokenPE32FileEx(char* szFileName, LPVOID FileStatusInfo, LPVOID FileFixInfo); +__declspec(dllimport) bool TITCALL FixBrokenPE32FileExW(wchar_t* szFileName, LPVOID FileStatusInfo, LPVOID FileFixInfo); +__declspec(dllimport) bool TITCALL IsFileDLL(char* szFileName, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL IsFileDLLW(wchar_t* szFileName, ULONG_PTR FileMapVA); +// TitanEngine.Hider.functions: +__declspec(dllimport) void* TITCALL GetPEBLocation(HANDLE hProcess); +__declspec(dllimport) void* TITCALL GetPEBLocation64(HANDLE hProcess); +__declspec(dllimport) void* TITCALL GetTEBLocation(HANDLE hThread); +__declspec(dllimport) void* TITCALL GetTEBLocation64(HANDLE hThread); +__declspec(dllimport) bool TITCALL HideDebugger(HANDLE hProcess, DWORD PatchAPILevel); +__declspec(dllimport) bool TITCALL UnHideDebugger(HANDLE hProcess, DWORD PatchAPILevel); +// TitanEngine.Relocater.functions: +__declspec(dllimport) void TITCALL RelocaterCleanup(); +__declspec(dllimport) void TITCALL RelocaterInit(DWORD MemorySize, ULONG_PTR OldImageBase, ULONG_PTR NewImageBase); +__declspec(dllimport) void TITCALL RelocaterAddNewRelocation(HANDLE hProcess, ULONG_PTR RelocateAddress, DWORD RelocateState); +__declspec(dllimport) long TITCALL RelocaterEstimatedSize(); +__declspec(dllimport) bool TITCALL RelocaterExportRelocation(ULONG_PTR StorePlace, DWORD StorePlaceRVA, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL RelocaterExportRelocationEx(char* szFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL RelocaterExportRelocationExW(wchar_t* szFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL RelocaterGrabRelocationTable(HANDLE hProcess, ULONG_PTR MemoryStart, DWORD MemorySize); +__declspec(dllimport) bool TITCALL RelocaterGrabRelocationTableEx(HANDLE hProcess, ULONG_PTR MemoryStart, ULONG_PTR MemorySize, DWORD NtSizeOfImage); +__declspec(dllimport) bool TITCALL RelocaterMakeSnapshot(HANDLE hProcess, char* szSaveFileName, LPVOID MemoryStart, ULONG_PTR MemorySize); +__declspec(dllimport) bool TITCALL RelocaterMakeSnapshotW(HANDLE hProcess, wchar_t* szSaveFileName, LPVOID MemoryStart, ULONG_PTR MemorySize); +__declspec(dllimport) bool TITCALL RelocaterCompareTwoSnapshots(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, char* szDumpFile1, char* szDumpFile2, ULONG_PTR MemStart); +__declspec(dllimport) bool TITCALL RelocaterCompareTwoSnapshotsW(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, wchar_t* szDumpFile1, wchar_t* szDumpFile2, ULONG_PTR MemStart); +__declspec(dllimport) bool TITCALL RelocaterChangeFileBase(char* szFileName, ULONG_PTR NewImageBase); +__declspec(dllimport) bool TITCALL RelocaterChangeFileBaseW(wchar_t* szFileName, ULONG_PTR NewImageBase); +__declspec(dllimport) bool TITCALL RelocaterRelocateMemoryBlock(ULONG_PTR FileMapVA, ULONG_PTR MemoryLocation, void* RelocateMemory, DWORD RelocateMemorySize, ULONG_PTR CurrentLoadedBase, ULONG_PTR RelocateBase); +__declspec(dllimport) bool TITCALL RelocaterWipeRelocationTable(char* szFileName); +__declspec(dllimport) bool TITCALL RelocaterWipeRelocationTableW(wchar_t* szFileName); +// TitanEngine.Resourcer.functions: +__declspec(dllimport) long long TITCALL ResourcerLoadFileForResourceUse(char* szFileName); +__declspec(dllimport) long long TITCALL ResourcerLoadFileForResourceUseW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL ResourcerFreeLoadedFile(LPVOID LoadedFileBase); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFileEx(ULONG_PTR FileMapVA, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFile(char* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFileW(wchar_t* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerFindResource(char* szFileName, char* szResourceType, DWORD ResourceType, char* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) bool TITCALL ResourcerFindResourceW(wchar_t* szFileName, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) bool TITCALL ResourcerFindResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) void TITCALL ResourcerEnumerateResource(char* szFileName, void* CallBack); +__declspec(dllimport) void TITCALL ResourcerEnumerateResourceW(wchar_t* szFileName, void* CallBack); +__declspec(dllimport) void TITCALL ResourcerEnumerateResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, void* CallBack); +// TitanEngine.Threader.functions: +__declspec(dllimport) bool TITCALL ThreaderImportRunningThreadData(DWORD ProcessId); +__declspec(dllimport) void* TITCALL ThreaderGetThreadInfo(HANDLE hThread, DWORD ThreadId); +__declspec(dllimport) void TITCALL ThreaderEnumThreadInfo(void* EnumCallBack); +__declspec(dllimport) bool TITCALL ThreaderPauseThread(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderResumeThread(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderTerminateThread(HANDLE hThread, DWORD ThreadExitCode); +__declspec(dllimport) bool TITCALL ThreaderPauseAllThreads(bool LeaveMainRunning); +__declspec(dllimport) bool TITCALL ThreaderResumeAllThreads(bool LeaveMainPaused); +__declspec(dllimport) bool TITCALL ThreaderPauseProcess(); +__declspec(dllimport) bool TITCALL ThreaderResumeProcess(); +__declspec(dllimport) long long TITCALL ThreaderCreateRemoteThread(ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, LPVOID ThreadPassParameter, LPDWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderInjectAndExecuteCode(LPVOID InjectCode, DWORD StartDelta, DWORD InjectSize); +__declspec(dllimport) long long TITCALL ThreaderCreateRemoteThreadEx(HANDLE hProcess, ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, LPVOID ThreadPassParameter, LPDWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderInjectAndExecuteCodeEx(HANDLE hProcess, LPVOID InjectCode, DWORD StartDelta, DWORD InjectSize); +__declspec(dllimport) void TITCALL ThreaderSetCallBackForNextExitThreadEvent(LPVOID exitThreadCallBack); +__declspec(dllimport) bool TITCALL ThreaderIsThreadStillRunning(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderIsThreadActive(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderIsAnyThreadActive(); +__declspec(dllimport) bool TITCALL ThreaderExecuteOnlyInjectedThreads(); +__declspec(dllimport) long long TITCALL ThreaderGetOpenHandleForThread(DWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderIsExceptionInMainThread(); +// TitanEngine.Debugger.functions: +__declspec(dllimport) void* TITCALL StaticDisassembleEx(ULONG_PTR DisassmStart, LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL StaticDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL DisassembleEx(HANDLE hProcess, LPVOID DisassmAddress, bool ReturnInstructionType); +__declspec(dllimport) void* TITCALL Disassemble(LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL StaticLengthDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL LengthDisassembleEx(HANDLE hProcess, LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL LengthDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL InitDebug(char* szFileName, char* szCommandLine, char* szCurrentFolder); +__declspec(dllimport) void* TITCALL InitDebugW(wchar_t* szFileName, wchar_t* szCommandLine, wchar_t* szCurrentFolder); +__declspec(dllimport) void* TITCALL InitDebugEx(char* szFileName, char* szCommandLine, char* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDebugExW(wchar_t* szFileName, wchar_t* szCommandLine, wchar_t* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDLLDebug(char* szFileName, bool ReserveModuleBase, char* szCommandLine, char* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDLLDebugW(wchar_t* szFileName, bool ReserveModuleBase, wchar_t* szCommandLine, wchar_t* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) bool TITCALL StopDebug(); +__declspec(dllimport) void TITCALL SetBPXOptions(long DefaultBreakPointType); +__declspec(dllimport) bool TITCALL IsBPXEnabled(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL EnableBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL DisableBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SetBPX(ULONG_PTR bpxAddress, DWORD bpxType, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SafeDeleteBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SetAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxType, DWORD bpxPlace, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxPlace); +__declspec(dllimport) bool TITCALL SafeDeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxPlace); +__declspec(dllimport) bool TITCALL SetMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL SetMemoryBPXEx(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, DWORD BreakPointType, bool RestoreOnHit, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL RemoveMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory); +__declspec(dllimport) bool TITCALL GetContextFPUDataEx(HANDLE hActiveThread, void* FPUSaveArea); +__declspec(dllimport) long long TITCALL GetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister); +__declspec(dllimport) long long TITCALL GetContextData(DWORD IndexOfRegister); +__declspec(dllimport) bool TITCALL SetContextFPUDataEx(HANDLE hActiveThread, void* FPUSaveArea); +__declspec(dllimport) bool TITCALL SetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister, ULONG_PTR NewRegisterValue); +__declspec(dllimport) bool TITCALL SetContextData(DWORD IndexOfRegister, ULONG_PTR NewRegisterValue); +__declspec(dllimport) void TITCALL ClearExceptionNumber(); +__declspec(dllimport) long TITCALL CurrentExceptionNumber(); +__declspec(dllimport) bool TITCALL MatchPatternEx(HANDLE hProcess, void* MemoryToCheck, int SizeOfMemoryToCheck, void* PatternToMatch, int SizeOfPatternToMatch, PBYTE WildCard); +__declspec(dllimport) bool TITCALL MatchPattern(void* MemoryToCheck, int SizeOfMemoryToCheck, void* PatternToMatch, int SizeOfPatternToMatch, PBYTE WildCard); +__declspec(dllimport) long long TITCALL FindEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, LPBYTE WildCard); +__declspec(dllimport) long long TITCALL Find(LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, LPBYTE WildCard); +__declspec(dllimport) bool TITCALL FillEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte); +__declspec(dllimport) bool TITCALL Fill(LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte); +__declspec(dllimport) bool TITCALL PatchEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP); +__declspec(dllimport) bool TITCALL Patch(LPVOID MemoryStart, DWORD MemorySize, LPVOID ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP); +__declspec(dllimport) bool TITCALL ReplaceEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, LPVOID ReplacePattern, DWORD ReplaceSize, PBYTE WildCard); +__declspec(dllimport) bool TITCALL Replace(LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, LPVOID ReplacePattern, DWORD ReplaceSize, PBYTE WildCard); +__declspec(dllimport) void* TITCALL GetDebugData(); +__declspec(dllimport) void* TITCALL GetTerminationData(); +__declspec(dllimport) long TITCALL GetExitCode(); +__declspec(dllimport) long long TITCALL GetDebuggedDLLBaseAddress(); +__declspec(dllimport) long long TITCALL GetDebuggedFileBaseAddress(); +__declspec(dllimport) bool TITCALL GetRemoteString(HANDLE hProcess, LPVOID StringAddress, LPVOID StringStorage, int MaximumStringSize); +__declspec(dllimport) long long TITCALL GetFunctionParameter(HANDLE hProcess, DWORD FunctionType, DWORD ParameterNumber, DWORD ParameterType); +__declspec(dllimport) long long TITCALL GetJumpDestinationEx(HANDLE hProcess, ULONG_PTR InstructionAddress, bool JustJumps); +__declspec(dllimport) long long TITCALL GetJumpDestination(HANDLE hProcess, ULONG_PTR InstructionAddress); +__declspec(dllimport) bool TITCALL IsJumpGoingToExecuteEx(HANDLE hProcess, HANDLE hThread, ULONG_PTR InstructionAddress, ULONG_PTR RegFlags); +__declspec(dllimport) bool TITCALL IsJumpGoingToExecute(); +__declspec(dllimport) void TITCALL SetCustomHandler(DWORD ExceptionId, LPVOID CallBack); +__declspec(dllimport) void TITCALL ForceClose(); +__declspec(dllimport) void TITCALL StepInto(LPVOID traceCallBack); +__declspec(dllimport) void TITCALL StepOver(LPVOID traceCallBack); +__declspec(dllimport) void TITCALL StepOut(LPVOID StepOut, bool StepFinal); +__declspec(dllimport) void TITCALL SingleStep(DWORD StepCount, LPVOID StepCallBack); +__declspec(dllimport) bool TITCALL GetUnusedHardwareBreakPointRegister(LPDWORD RegisterIndex); +__declspec(dllimport) bool TITCALL SetHardwareBreakPointEx(HANDLE hActiveThread, ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack, LPDWORD IndexOfSelectedRegister); +__declspec(dllimport) bool TITCALL SetHardwareBreakPoint(ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteHardwareBreakPoint(DWORD IndexOfRegister); +__declspec(dllimport) bool TITCALL RemoveAllBreakPoints(DWORD RemoveOption); +__declspec(dllimport) void* TITCALL GetProcessInformation(); +__declspec(dllimport) void* TITCALL GetStartupInformation(); +__declspec(dllimport) void TITCALL DebugLoop(); +__declspec(dllimport) void TITCALL SetDebugLoopTimeOut(DWORD TimeOut); +__declspec(dllimport) void TITCALL SetNextDbgContinueStatus(DWORD SetDbgCode); +__declspec(dllimport) bool TITCALL AttachDebugger(DWORD ProcessId, bool KillOnExit, LPVOID DebugInfo, LPVOID CallBack); +__declspec(dllimport) bool TITCALL DetachDebugger(DWORD ProcessId); +__declspec(dllimport) bool TITCALL DetachDebuggerEx(DWORD ProcessId); +__declspec(dllimport) void TITCALL DebugLoopEx(DWORD TimeOut); +__declspec(dllimport) void TITCALL AutoDebugEx(char* szFileName, bool ReserveModuleBase, char* szCommandLine, char* szCurrentFolder, DWORD TimeOut, LPVOID EntryCallBack); +__declspec(dllimport) void TITCALL AutoDebugExW(wchar_t* szFileName, bool ReserveModuleBase, wchar_t* szCommandLine, wchar_t* szCurrentFolder, DWORD TimeOut, LPVOID EntryCallBack); +__declspec(dllimport) bool TITCALL IsFileBeingDebugged(); +__declspec(dllimport) void TITCALL SetErrorModel(bool DisplayErrorMessages); +// TitanEngine.FindOEP.functions: +__declspec(dllimport) void TITCALL FindOEPInit(); +__declspec(dllimport) bool TITCALL FindOEPGenerically(char* szFileName, LPVOID TraceInitCallBack, LPVOID CallBack); +__declspec(dllimport) bool TITCALL FindOEPGenericallyW(wchar_t* szFileName, LPVOID TraceInitCallBack, LPVOID CallBack); +// TitanEngine.Importer.functions: +__declspec(dllimport) void TITCALL ImporterAddNewDll(char* szDLLName, ULONG_PTR FirstThunk); +__declspec(dllimport) void TITCALL ImporterAddNewAPI(char* szAPIName, ULONG_PTR ThunkValue); +__declspec(dllimport) void TITCALL ImporterAddNewOrdinalAPI(ULONG_PTR OrdinalNumber, ULONG_PTR ThunkValue); +__declspec(dllimport) long TITCALL ImporterGetAddedDllCount(); +__declspec(dllimport) long TITCALL ImporterGetAddedAPICount(); +__declspec(dllimport) bool TITCALL ImporterExportIAT(ULONG_PTR StorePlace, ULONG_PTR FileMapVA, HANDLE hFileMap); +__declspec(dllimport) long TITCALL ImporterEstimatedSize(); +__declspec(dllimport) bool TITCALL ImporterExportIATEx(char* szDumpFileName, char* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ImporterExportIATExW(wchar_t* szDumpFileName, wchar_t* szExportFileName, wchar_t* szSectionName = L".RL!TEv2"); +__declspec(dllimport) long long TITCALL ImporterFindAPIWriteLocation(char* szAPIName); +__declspec(dllimport) long long TITCALL ImporterFindOrdinalAPIWriteLocation(ULONG_PTR OrdinalNumber); +__declspec(dllimport) long long TITCALL ImporterFindAPIByWriteLocation(ULONG_PTR APIWriteLocation); +__declspec(dllimport) long long TITCALL ImporterFindDLLByWriteLocation(ULONG_PTR APIWriteLocation); +__declspec(dllimport) void* TITCALL ImporterGetDLLName(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameW(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPIName(ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumber(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPINameEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddressEx(char* szDLLName, char* szAPIName); +__declspec(dllimport) long long TITCALL ImporterGetLocalAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameFromDebugeeW(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPINameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumberFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long TITCALL ImporterGetDLLIndexEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long TITCALL ImporterGetDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetRemoteDLLBase(HANDLE hProcess, HMODULE LocalModuleBase); +__declspec(dllimport) long long TITCALL ImporterGetRemoteDLLBaseEx(HANDLE hProcess, char* szModuleName); +__declspec(dllimport) void* TITCALL ImporterGetRemoteDLLBaseExW(HANDLE hProcess, wchar_t* szModuleName); +__declspec(dllimport) bool TITCALL ImporterIsForwardedAPI(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetForwardedAPIName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetForwardedDLLName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long TITCALL ImporterGetForwardedDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetForwardedAPIOrdinalNumber(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetNearestAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetNearestAPIName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) bool TITCALL ImporterCopyOriginalIAT(char* szOriginalFile, char* szDumpFile); +__declspec(dllimport) bool TITCALL ImporterCopyOriginalIATW(wchar_t* szOriginalFile, wchar_t* szDumpFile); +__declspec(dllimport) bool TITCALL ImporterLoadImportTable(char* szFileName); +__declspec(dllimport) bool TITCALL ImporterLoadImportTableW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL ImporterMoveOriginalIAT(char* szOriginalFile, char* szDumpFile, char* szSectionName); +__declspec(dllimport) bool TITCALL ImporterMoveOriginalIATW(wchar_t* szOriginalFile, wchar_t* szDumpFile, char* szSectionName); +__declspec(dllimport) void TITCALL ImporterAutoSearchIAT(DWORD ProcessId, char* szFileName, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterAutoSearchIATW(DWORD ProcessIds, wchar_t* szFileName, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterAutoSearchIATEx(DWORD ProcessId, ULONG_PTR ImageBase, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterEnumAddedData(LPVOID EnumCallBack); +__declspec(dllimport) long TITCALL ImporterAutoFixIATEx(DWORD ProcessId, char* szDumpedFile, char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, bool TryAutoFix, bool FixEliminations, LPVOID UnknownPointerFixCallback); +__declspec(dllimport) long TITCALL ImporterAutoFixIATExW(DWORD ProcessId, wchar_t* szDumpedFile, char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, bool TryAutoFix, bool FixEliminations, LPVOID UnknownPointerFixCallback); +__declspec(dllimport) long TITCALL ImporterAutoFixIAT(DWORD ProcessId, char* szDumpedFile, ULONG_PTR SearchStart); +__declspec(dllimport) long TITCALL ImporterAutoFixIATW(DWORD ProcessId, wchar_t* szDumpedFile, ULONG_PTR SearchStart); +__declspec(dllimport) bool TITCALL ImporterDeleteAPI(DWORD_PTR apiAddr); +// Global.Engine.Hook.functions: +__declspec(dllimport) bool TITCALL HooksSafeTransitionEx(LPVOID HookAddressArray, int NumberOfHooks, bool TransitionStart); +__declspec(dllimport) bool TITCALL HooksSafeTransition(LPVOID HookAddress, bool TransitionStart); +__declspec(dllimport) bool TITCALL HooksIsAddressRedirected(LPVOID HookAddress); +__declspec(dllimport) void* TITCALL HooksGetTrampolineAddress(LPVOID HookAddress); +__declspec(dllimport) void* TITCALL HooksGetHookEntryDetails(LPVOID HookAddress); +__declspec(dllimport) bool TITCALL HooksInsertNewRedirection(LPVOID HookAddress, LPVOID RedirectTo, int HookType); +__declspec(dllimport) bool TITCALL HooksInsertNewIATRedirectionEx(ULONG_PTR FileMapVA, ULONG_PTR LoadedModuleBase, char* szHookFunction, LPVOID RedirectTo); +__declspec(dllimport) bool TITCALL HooksInsertNewIATRedirection(char* szModuleName, char* szHookFunction, LPVOID RedirectTo); +__declspec(dllimport) bool TITCALL HooksRemoveRedirection(LPVOID HookAddress, bool RemoveAll); +__declspec(dllimport) bool TITCALL HooksRemoveRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksRemoveIATRedirection(char* szModuleName, char* szHookFunction, bool RemoveAll); +__declspec(dllimport) bool TITCALL HooksDisableRedirection(LPVOID HookAddress, bool DisableAll); +__declspec(dllimport) bool TITCALL HooksDisableRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksDisableIATRedirection(char* szModuleName, char* szHookFunction, bool DisableAll); +__declspec(dllimport) bool TITCALL HooksEnableRedirection(LPVOID HookAddress, bool EnableAll); +__declspec(dllimport) bool TITCALL HooksEnableRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksEnableIATRedirection(char* szModuleName, char* szHookFunction, bool EnableAll); +__declspec(dllimport) void TITCALL HooksScanModuleMemory(HMODULE ModuleBase, LPVOID CallBack); +__declspec(dllimport) void TITCALL HooksScanEntireProcessMemory(LPVOID CallBack); +__declspec(dllimport) void TITCALL HooksScanEntireProcessMemoryEx(); +// TitanEngine.Tracer.functions: +__declspec(dllimport) void TITCALL TracerInit(); +__declspec(dllimport) long long TITCALL TracerLevel1(HANDLE hProcess, ULONG_PTR AddressToTrace); +__declspec(dllimport) long long TITCALL HashTracerLevel1(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD InputNumberOfInstructions); +__declspec(dllimport) long TITCALL TracerDetectRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace); +__declspec(dllimport) long long TITCALL TracerFixKnownRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD RedirectionId); +__declspec(dllimport) long long TITCALL TracerFixRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD IdParameter); +__declspec(dllimport) long long TITCALL TracerDetectRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, PDWORD ReturnedId); +__declspec(dllimport) long TITCALL TracerFixRedirectionViaImpRecPlugin(HANDLE hProcess, char* szPluginName, ULONG_PTR AddressToTrace); +// TitanEngine.Exporter.functions: +__declspec(dllimport) void TITCALL ExporterCleanup(); +__declspec(dllimport) void TITCALL ExporterSetImageBase(ULONG_PTR ImageBase); +__declspec(dllimport) void TITCALL ExporterInit(DWORD MemorySize, ULONG_PTR ImageBase, DWORD ExportOrdinalBase, char* szExportModuleName); +__declspec(dllimport) bool TITCALL ExporterAddNewExport(char* szExportName, DWORD ExportRelativeAddress); +__declspec(dllimport) bool TITCALL ExporterAddNewOrdinalExport(DWORD OrdinalNumber, DWORD ExportRelativeAddress); +__declspec(dllimport) long TITCALL ExporterGetAddedExportCount(); +__declspec(dllimport) long TITCALL ExporterEstimatedSize(); +__declspec(dllimport) bool TITCALL ExporterBuildExportTable(ULONG_PTR StorePlace, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL ExporterBuildExportTableEx(char* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ExporterBuildExportTableExW(wchar_t* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ExporterLoadExportTable(char* szFileName); +__declspec(dllimport) bool TITCALL ExporterLoadExportTableW(wchar_t* szFileName); +// TitanEngine.Librarian.functions: +__declspec(dllimport) bool TITCALL LibrarianSetBreakPoint(char* szLibraryName, DWORD bpxType, bool SingleShoot, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL LibrarianRemoveBreakPoint(char* szLibraryName, DWORD bpxType); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfo(char* szLibraryName); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoW(wchar_t* szLibraryName); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoEx(void* BaseOfDll); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoExW(void* BaseOfDll); +__declspec(dllimport) void TITCALL LibrarianEnumLibraryInfo(void* EnumCallBack); +__declspec(dllimport) void TITCALL LibrarianEnumLibraryInfoW(void* EnumCallBack); +// TitanEngine.Process.functions: +__declspec(dllimport) long TITCALL GetActiveProcessId(char* szImageName); +__declspec(dllimport) long TITCALL GetActiveProcessIdW(wchar_t* szImageName); +__declspec(dllimport) void TITCALL EnumProcessesWithLibrary(char* szLibraryName, void* EnumFunction); +// TitanEngine.TLSFixer.functions: +__declspec(dllimport) bool TITCALL TLSBreakOnCallBack(LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSGrabCallBackData(char* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSGrabCallBackDataW(wchar_t* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBreakOnCallBackEx(char* szFileName, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSBreakOnCallBackExW(wchar_t* szFileName, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSRemoveCallback(char* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveCallbackW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveTable(char* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveTableW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSBackupData(char* szFileName); +__declspec(dllimport) bool TITCALL TLSBackupDataW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSRestoreData(); +__declspec(dllimport) bool TITCALL TLSBuildNewTable(ULONG_PTR FileMapVA, ULONG_PTR StorePlace, ULONG_PTR StorePlaceRVA, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBuildNewTableEx(char* szFileName, char* szSectionName, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBuildNewTableExW(wchar_t* szFileName, char* szSectionName, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +// TitanEngine.TranslateName.functions: +__declspec(dllimport) void* TITCALL TranslateNativeName(char* szNativeName); +__declspec(dllimport) void* TITCALL TranslateNativeNameW(wchar_t* szNativeName); +// TitanEngine.Handler.functions: +__declspec(dllimport) long TITCALL HandlerGetActiveHandleCount(DWORD ProcessId); +__declspec(dllimport) bool TITCALL HandlerIsHandleOpen(DWORD ProcessId, HANDLE hHandle); +__declspec(dllimport) void* TITCALL HandlerGetHandleName(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName); +__declspec(dllimport) void* TITCALL HandlerGetHandleNameW(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName); +__declspec(dllimport) long TITCALL HandlerEnumerateOpenHandles(DWORD ProcessId, LPVOID HandleBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long long TITCALL HandlerGetHandleDetails(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, DWORD InformationReturn); +__declspec(dllimport) bool TITCALL HandlerCloseRemoteHandle(HANDLE hProcess, HANDLE hHandle); +__declspec(dllimport) long TITCALL HandlerEnumerateLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, LPVOID HandleDataBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long TITCALL HandlerEnumerateLockHandlesW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, LPVOID HandleDataBuffer, DWORD MaxHandleCount); +__declspec(dllimport) bool TITCALL HandlerCloseAllLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerCloseAllLockHandlesW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerIsFileLocked(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerIsFileLockedW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +// TitanEngine.Handler[Mutex].functions: +__declspec(dllimport) long TITCALL HandlerEnumerateOpenMutexes(HANDLE hProcess, DWORD ProcessId, LPVOID HandleBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long long TITCALL HandlerGetOpenMutexHandle(HANDLE hProcess, DWORD ProcessId, char* szMutexString); +__declspec(dllimport) long long TITCALL HandlerGetOpenMutexHandleW(HANDLE hProcess, DWORD ProcessId, wchar_t* szMutexString); +__declspec(dllimport) long TITCALL HandlerGetProcessIdWhichCreatedMutex(char* szMutexString); +__declspec(dllimport) long TITCALL HandlerGetProcessIdWhichCreatedMutexW(wchar_t* szMutexString); +// TitanEngine.Injector.functions: +__declspec(dllimport) bool TITCALL RemoteLoadLibrary(HANDLE hProcess, char* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteLoadLibraryW(HANDLE hProcess, wchar_t* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteFreeLibrary(HANDLE hProcess, HMODULE hModule, char* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteFreeLibraryW(HANDLE hProcess, HMODULE hModule, wchar_t* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteExitProcess(HANDLE hProcess, DWORD ExitCode); +// TitanEngine.StaticUnpacker.functions: +__declspec(dllimport) bool TITCALL StaticFileLoad(char* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileLoadW(wchar_t* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileUnload(char* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileUnloadW(wchar_t* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileOpen(char* szFileName, DWORD DesiredAccess, LPHANDLE FileHandle, LPDWORD FileSizeLow, LPDWORD FileSizeHigh); +__declspec(dllimport) bool TITCALL StaticFileOpenW(wchar_t* szFileName, DWORD DesiredAccess, LPHANDLE FileHandle, LPDWORD FileSizeLow, LPDWORD FileSizeHigh); +__declspec(dllimport) bool TITCALL StaticFileGetContent(HANDLE FileHandle, DWORD FilePositionLow, LPDWORD FilePositionHigh, void* Buffer, DWORD Size); +__declspec(dllimport) void TITCALL StaticFileClose(HANDLE FileHandle); +__declspec(dllimport) void TITCALL StaticMemoryDecrypt(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionType, DWORD DecryptionKeySize, ULONG_PTR DecryptionKey); +__declspec(dllimport) void TITCALL StaticMemoryDecryptEx(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionKeySize, void* DecryptionCallBack); +__declspec(dllimport) void TITCALL StaticMemoryDecryptSpecial(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionKeySize, DWORD SpecDecryptionType, void* DecryptionCallBack); +__declspec(dllimport) void TITCALL StaticSectionDecrypt(ULONG_PTR FileMapVA, DWORD SectionNumber, bool SimulateLoad, DWORD DecryptionType, DWORD DecryptionKeySize, ULONG_PTR DecryptionKey); +__declspec(dllimport) bool TITCALL StaticMemoryDecompress(void* Source, DWORD SourceSize, void* Destination, DWORD DestinationSize, int Algorithm); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopy(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyW(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyExW(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx64W(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticHashMemory(void* MemoryToHash, DWORD SizeOfMemory, void* HashDigest, bool OutputString, int Algorithm); +__declspec(dllimport) bool TITCALL StaticHashFile(char* szFileName, char* HashDigest, bool OutputString, int Algorithm); +__declspec(dllimport) bool TITCALL StaticHashFileW(wchar_t* szFileName, char* HashDigest, bool OutputString, int Algorithm); +// TitanEngine.Engine.functions: +__declspec(dllimport) void TITCALL SetEngineVariable(DWORD VariableId, bool VariableSet); +__declspec(dllimport) bool TITCALL EngineCreateMissingDependencies(char* szFileName, char* szOutputFolder, bool LogCreatedFiles); +__declspec(dllimport) bool TITCALL EngineCreateMissingDependenciesW(wchar_t* szFileName, wchar_t* szOutputFolder, bool LogCreatedFiles); +__declspec(dllimport) bool TITCALL EngineFakeMissingDependencies(HANDLE hProcess); +__declspec(dllimport) bool TITCALL EngineDeleteCreatedDependencies(); +__declspec(dllimport) bool TITCALL EngineCreateUnpackerWindow(char* WindowUnpackerTitle, char* WindowUnpackerLongTitle, char* WindowUnpackerName, char* WindowUnpackerAuthor, void* StartUnpackingCallBack); +__declspec(dllimport) void TITCALL EngineAddUnpackerWindowLogMessage(char* szLogMessage); +// Global.Engine.Extension.Functions: +__declspec(dllimport) bool TITCALL ExtensionManagerIsPluginLoaded(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerIsPluginEnabled(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerDisableAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerDisablePlugin(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerEnableAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerEnablePlugin(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerUnloadAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerUnloadPlugin(char* szPluginName); +__declspec(dllimport) void* TITCALL ExtensionManagerGetPluginInfo(char* szPluginName); + +#ifdef __cplusplus +} +#endif /*__cplusplus*/ + +#pragma pack(pop) + +#endif /*TITANENGINE*/ diff --git a/TitanScriptGui/TitanEngine.lib b/TitanScriptGui/TitanEngine.lib new file mode 100644 index 0000000000000000000000000000000000000000..4b6174a5b30ae41aa0e9a1fc065f0534111e40aa GIT binary patch literal 101964 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 literal 0 HcmV?d00001 diff --git a/TitanScriptGui/TitanScript.h b/TitanScriptGui/TitanScript.h new file mode 100644 index 0000000..4eb75e2 --- /dev/null +++ b/TitanScriptGui/TitanScript.h @@ -0,0 +1,26 @@ +#ifndef TITANSCRIPT_H +#define TITANSCRIPT_H + +#if _MSC_VER > 1000 +//#pragma once +#endif + +#include + +enum eLogType {TS_LOG_NORMAL, TS_LOG_ERROR, TS_LOG_COMMAND, TS_LOG_DEBUG}; +typedef void(*fLogCallback)(const char* szString, eLogType Type); + +typedef bool (*tScripterLoadFileA)(const char*); +typedef bool (*tScripterLoadFileW)(const wchar_t*); +typedef bool (*tScripterLoadBuffer)(const char*); +typedef bool (*tScripterResume)(); +typedef bool (*tScripterPause)(); +typedef bool (*tScripterAutoDebugA)(const char*); +typedef bool (*tScripterAutoDebugW)(const wchar_t*); +typedef void (*tScripterSetLogCallback)(fLogCallback Callback); +typedef bool (*tScripterExecuteWithTitanMistA)(const char*, const char*); + +// use like this: tScripterResume foo = GetTSFunctionPointer(Resume); +#define GetTSFunctionPointer(x) ((tScripter ## x)GetProcAddress(GetModuleHandleA("TitanScript"), "Scripter" #x)) + +#endif /*TITANSCRIPT_H*/ diff --git a/TitanScriptGui/TitanScriptGui.cpp b/TitanScriptGui/TitanScriptGui.cpp new file mode 100644 index 0000000..5e9baf4 --- /dev/null +++ b/TitanScriptGui/TitanScriptGui.cpp @@ -0,0 +1,22 @@ +#include "stdafx.h" +#include "Form1.h" + +using namespace TitanScriptGui; + +[STAThreadAttribute] +int main(array ^args) +{ + if ( !ExtensionManagerIsPluginLoaded( "TitanScript" ) || !ExtensionManagerIsPluginEnabled( "TitanScript" ) ) { + System::Windows::Forms::MessageBox::Show("TitanScript failed to load!", "[ERROR]", MessageBoxButtons::OK, MessageBoxIcon::Error); + return -1; + } + + // Aktivieren visueller Effekte von Windows XP, bevor Steuerelemente erstellt werden + Application::EnableVisualStyles(); + Application::SetCompatibleTextRenderingDefault(false); + + // Hauptfenster erstellen und ausführen + Application::Run(gcnew Form1()); + + return 0; +} diff --git a/TitanScriptGui/TitanScriptGui.vcxproj b/TitanScriptGui/TitanScriptGui.vcxproj new file mode 100644 index 0000000..810f828 --- /dev/null +++ b/TitanScriptGui/TitanScriptGui.vcxproj @@ -0,0 +1,120 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {864AC964-6CC4-4738-A811-61C216C1A36D} + v4.0 + ManagedCProj + TitanScriptGui + + + + Application + true + Pure + Unicode + + + Application + false + Pure + Unicode + + + + + + + + + + + + + true + + + false + + + + Level3 + Disabled + WIN32;_DEBUG;%(PreprocessorDefinitions) + Use + + + + + true + TitanEngine.lib + Windows + main + + + + + Level3 + WIN32;NDEBUG;%(PreprocessorDefinitions) + Use + + + + + true + + + Windows + main + + + + + + + + + + + + + + + + + Create + Create + + + + + + CppForm + + + + + + + + + + + + Form1.h + Designer + + + + + + \ No newline at end of file diff --git a/TitanScriptGui/TitanScriptGui.vcxproj.filters b/TitanScriptGui/TitanScriptGui.vcxproj.filters new file mode 100644 index 0000000..5e21018 --- /dev/null +++ b/TitanScriptGui/TitanScriptGui.vcxproj.filters @@ -0,0 +1,61 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + Ressourcendateien + + + + + Quelldateien + + + Quelldateien + + + Quelldateien + + + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + + + Ressourcendateien + + + + + Ressourcendateien + + + \ No newline at end of file diff --git a/TitanScriptGui/app.ico b/TitanScriptGui/app.ico new file mode 100644 index 0000000000000000000000000000000000000000..3a5525fd794f7a7c5c8e6187f470ea3af38cd2b6 GIT binary patch literal 1078 zcmeHHJr05}7=1t!Hp3A*8IHkVf+j?-!eHY14Gtcw1Eb*_9>Bq^zETJ@GKj{_2j4$w zo9}xCh!8{T3=X##Skq>ikMjsvB|y%crWBM2iW(4pI}c%z6%lW!=~4v77#3{z!dmB1 z__&l)-{KUYR+|8|;wB^R|9ET$J@(@=#rd^=)qs85?vAy(PSF5CyNkus435LVkZ$rj zNw|JG-P7^hF<(;#o*Vk}5R#e|^13tBbQkeF?djULtvqyxd3<{9 literal 0 HcmV?d00001 diff --git a/TitanScriptGui/app.rc b/TitanScriptGui/app.rc new file mode 100644 index 0000000000000000000000000000000000000000..04d5f650be7f2415274ad007cfde01f41a1415a5 GIT binary patch literal 2626 zcmds(PjAye5XIjaiSJ+~7Z8xpa^RdcRuz#JL`nfE5`r{_2q&rXM}_ZR0l&BICILGF z^<*K-yY}qNc;@Y!@&5eLR$GaBnlYYgqLCJwYssByh3o>^Qfqxw&fBpbaV7e!F&1NV zCt+MME|I?uv#r;xjd+_O{~GkJ@Ym9P-Q$bxFgLNDp_QY3iEg3>n)bA{Z|MtCTlsDV zy)4*SzoSphYI?BF{C*7?bQj&eHf- zb0#708@Q0LlVjMif)gW{km$i5k{o6lsfU}LHGcKnSw|J4i*o`eziX;ba6YeC?UJ7> zYga1?IVT{qV9m8>qz2(B$BQdt9@t~~lxlG$n@v;ZS*Y1dY$nukVejhif$S5#4c@GO z&H4f>TNW{Nu)Sv8c$=TLUhYI+RCk~HJJSg@*usR7|{1)-8?zBTay~TH{x0R(tQs8J$hj;#RRp0k6XZi-?-2aQN-_VfvAxtaw z{O>V6yK_wYvTWY+-As$$FZx#b-&5wBajGZZVlQ%p@%FxCp}P0|cgh*oJG+>rXP;%} oWLI=TcgFH*Wq&Q1S>;pD@8_9_W4$ri&uIS{{Fin2|5tYZ0=fe*Z2$lO literal 0 HcmV?d00001 diff --git a/TitanScriptGui/resource.h b/TitanScriptGui/resource.h new file mode 100644 index 0000000..d5ac7c4 --- /dev/null +++ b/TitanScriptGui/resource.h @@ -0,0 +1,3 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by app.rc diff --git a/TitanScriptGui/stdafx.cpp b/TitanScriptGui/stdafx.cpp new file mode 100644 index 0000000..e3761bd --- /dev/null +++ b/TitanScriptGui/stdafx.cpp @@ -0,0 +1,7 @@ +// stdafx.cpp : Quelldatei, die nur die Standard-Includes einbindet. +// TitanScriptGui.pch ist der vorkompilierte Header. +// stdafx.obj enthält die vorkompilierten Typinformationen. + +#include "stdafx.h" + + diff --git a/TitanScriptGui/stdafx.h b/TitanScriptGui/stdafx.h new file mode 100644 index 0000000..22db9aa --- /dev/null +++ b/TitanScriptGui/stdafx.h @@ -0,0 +1,6 @@ +// stdafx.h : Includedatei für Standardsystem-Includedateien +// oder häufig verwendete projektspezifische Includedateien, +// die nur in unregelmäßigen Abständen geändert werden. +#pragma once + +// TODO: Hier auf zusätzliche Header, die das Programm erfordert, verweisen. diff --git a/TitanUnitTest/TitanEngine.h b/TitanUnitTest/TitanEngine.h index 4db1828..206f9a4 100644 --- a/TitanUnitTest/TitanEngine.h +++ b/TitanUnitTest/TitanEngine.h @@ -23,6 +23,7 @@ const BYTE UE_HIDE_BASIC = 1; const BYTE UE_PLUGIN_CALL_REASON_PREDEBUG = 1; const BYTE UE_PLUGIN_CALL_REASON_EXCEPTION = 2; const BYTE UE_PLUGIN_CALL_REASON_POSTDEBUG = 3; +const BYTE UE_PLUGIN_CALL_REASON_UNHANDLEDEXCEPTION = 4; const BYTE TEE_HOOK_NRM_JUMP = 1; const BYTE TEE_HOOK_NRM_CALL = 3; @@ -566,8 +567,8 @@ __declspec(dllimport) long long TITCALL ConvertVAtoFileOffset(ULONG_PTR FileMapV __declspec(dllimport) long long TITCALL ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType); __declspec(dllimport) long long TITCALL ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType); __declspec(dllimport) long long TITCALL ConvertFileOffsetToVAEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool ReturnType); -__declspec(dllexport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead); -__declspec(dllexport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); +__declspec(dllimport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead); +__declspec(dllimport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); // TitanEngine.Realigner.functions: __declspec(dllimport) bool TITCALL FixHeaderCheckSum(char* szFileName); __declspec(dllimport) bool TITCALL FixHeaderCheckSumW(wchar_t* szFileName); @@ -704,6 +705,7 @@ __declspec(dllimport) void TITCALL SetCustomHandler(DWORD ExceptionId, LPVOID Ca __declspec(dllimport) void TITCALL ForceClose(); __declspec(dllimport) void TITCALL StepInto(LPVOID traceCallBack); __declspec(dllimport) void TITCALL StepOver(LPVOID traceCallBack); +__declspec(dllimport) void TITCALL StepOut(LPVOID StepOut, bool StepFinal); __declspec(dllimport) void TITCALL SingleStep(DWORD StepCount, LPVOID StepCallBack); __declspec(dllimport) bool TITCALL GetUnusedHardwareBreakPointRegister(LPDWORD RegisterIndex); __declspec(dllimport) bool TITCALL SetHardwareBreakPointEx(HANDLE hActiveThread, ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack, LPDWORD IndexOfSelectedRegister); @@ -742,6 +744,7 @@ __declspec(dllimport) long long TITCALL ImporterFindOrdinalAPIWriteLocation(ULON __declspec(dllimport) long long TITCALL ImporterFindAPIByWriteLocation(ULONG_PTR APIWriteLocation); __declspec(dllimport) long long TITCALL ImporterFindDLLByWriteLocation(ULONG_PTR APIWriteLocation); __declspec(dllimport) void* TITCALL ImporterGetDLLName(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameW(ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetAPIName(ULONG_PTR APIAddress); __declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumber(ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetAPINameEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); @@ -749,11 +752,14 @@ __declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddress(HANDLE hProc __declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddressEx(char* szDLLName, char* szAPIName); __declspec(dllimport) long long TITCALL ImporterGetLocalAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetDLLNameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameFromDebugeeW(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetAPINameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumberFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) long TITCALL ImporterGetDLLIndexEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); __declspec(dllimport) long TITCALL ImporterGetDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); __declspec(dllimport) long long TITCALL ImporterGetRemoteDLLBase(HANDLE hProcess, HMODULE LocalModuleBase); +__declspec(dllimport) long long TITCALL ImporterGetRemoteDLLBaseEx(HANDLE hProcess, char* szModuleName); +__declspec(dllimport) void* TITCALL ImporterGetRemoteDLLBaseExW(HANDLE hProcess, wchar_t* szModuleName); __declspec(dllimport) bool TITCALL ImporterIsForwardedAPI(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetForwardedAPIName(HANDLE hProcess, ULONG_PTR APIAddress); __declspec(dllimport) void* TITCALL ImporterGetForwardedDLLName(HANDLE hProcess, ULONG_PTR APIAddress); @@ -893,10 +899,10 @@ __declspec(dllimport) void TITCALL StaticSectionDecrypt(ULONG_PTR FileMapVA, DWO __declspec(dllimport) bool TITCALL StaticMemoryDecompress(void* Source, DWORD SourceSize, void* Destination, DWORD DestinationSize, int Algorithm); __declspec(dllimport) bool TITCALL StaticRawMemoryCopy(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, char* szDumpFileName); __declspec(dllimport) bool TITCALL StaticRawMemoryCopyW(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, wchar_t* szDumpFileName); -__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, char* szDumpFileName); -__declspec(dllexport) bool TITCALL StaticRawMemoryCopyExW(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, wchar_t* szDumpFileName); -__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, char* szDumpFileName); -__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx64W(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyExW(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyEx64W(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, wchar_t* szDumpFileName); __declspec(dllimport) bool TITCALL StaticHashMemory(void* MemoryToHash, DWORD SizeOfMemory, void* HashDigest, bool OutputString, int Algorithm); __declspec(dllimport) bool TITCALL StaticHashFile(char* szFileName, char* HashDigest, bool OutputString, int Algorithm); __declspec(dllimport) bool TITCALL StaticHashFileW(wchar_t* szFileName, char* HashDigest, bool OutputString, int Algorithm); diff --git a/TitanUnitTest/TitanUnitTest.vcxproj b/TitanUnitTest/TitanUnitTest.vcxproj index af59b54..cbf6daa 100644 --- a/TitanUnitTest/TitanUnitTest.vcxproj +++ b/TitanUnitTest/TitanUnitTest.vcxproj @@ -81,9 +81,7 @@ - -