try to fix the intervener padding problem

geode-sdk · Jan 19, 2025 · 6733f0a · 6733f0a
1 parent cfc9f91
commit 6733f0a
Show file tree

Hide file tree

Showing 11 changed files with 47 additions and 32 deletions.
diff --git a/src/Handler.cpp b/src/Handler.cpp
@@ -39,16 +39,18 @@ geode::Result<> Handler::init() {
 	GEODE_UNWRAP_INTO(auto handler, generator->generateHandler());
 	m_handlerSize = handler.m_size;
 
-	GEODE_UNWRAP_INTO(m_modifiedBytes, generator->generateIntervener());
+	GEODE_UNWRAP_INTO(auto minIntervener, generator->generateIntervener(0));
+
+	GEODE_UNWRAP_INTO(auto trampoline, generator->generateTrampoline(minIntervener.size()));
+	m_trampolineSize = trampoline.m_trampoline.m_size;
+
+	GEODE_UNWRAP_INTO(m_modifiedBytes, generator->generateIntervener(trampoline.m_originalOffset));
 
 	auto target = m_modifiedBytes.size();
 
 	auto address = reinterpret_cast<uint8_t*>(Target::get().getRealPtr(m_address));
 	m_originalBytes.insert(m_originalBytes.begin(), address, address + target);
 
-	GEODE_UNWRAP_INTO(auto trampoline, generator->generateTrampoline(target));
-	m_trampolineSize = trampoline.m_size;
-
 	this->addOriginal();
 
 	return geode::Ok();

diff --git a/src/generator/ArmV7Generator.cpp b/src/generator/ArmV7Generator.cpp
@@ -79,7 +79,7 @@ std::vector<uint8_t> ArmV7HandlerGenerator::handlerBytes(uint64_t address) {
 	return std::move(a.m_buffer);
 }
 
-std::vector<uint8_t> ArmV7HandlerGenerator::intervenerBytes(uint64_t address) {
+std::vector<uint8_t> ArmV7HandlerGenerator::intervenerBytes(uint64_t address, size_t size) {
 	ArmV7Assembler a((uint64_t)Target::get().getRealPtr((void*)address));
 	using enum ArmV7Register;
 
@@ -105,7 +105,7 @@ std::vector<uint8_t> ArmV7HandlerGenerator::intervenerBytes(uint64_t address) {
 	return std::move(a.m_buffer);
 }
 
-geode::Result<FunctionData> ArmV7HandlerGenerator::generateTrampoline(uint64_t target) {
+geode::Result<HandlerGenerator::TrampolineReturn> ArmV7HandlerGenerator::generateTrampoline(uint64_t target) {
 	auto origin = new CodeMemBlock((uint64_t)Target::get().getRealPtr(m_address), target);
 	auto relocated = new CodeMemBlock();
 	// idk about arm thumb stuff help me
@@ -129,5 +129,5 @@ geode::Result<FunctionData> ArmV7HandlerGenerator::generateTrampoline(uint64_t t
 	if (relocated->size == 0) {
 		return geode::Err("Failed to relocate original function");
 	}
-	return geode::Ok(FunctionData{m_trampoline, relocated->size});
+	return geode::Ok(TrampolineReturn{FunctionData{m_trampoline, relocated->size}, relocated->size});
 }
diff --git a/src/generator/ArmV7Generator.hpp b/src/generator/ArmV7Generator.hpp
@@ -10,10 +10,10 @@ namespace tulip::hook {
 	public:
 		using HandlerGenerator::HandlerGenerator;
 
-		geode::Result<FunctionData> generateTrampoline(uint64_t target) override;
+		geode::Result<TrampolineReturn> generateTrampoline(uint64_t target) override;
 
 		std::vector<uint8_t> handlerBytes(uint64_t address) override;
-		std::vector<uint8_t> intervenerBytes(uint64_t address) override;
+		std::vector<uint8_t> intervenerBytes(uint64_t address, size_t size) override;
 	};
 
 	class ArmV7WrapperGenerator : public WrapperGenerator {

diff --git a/src/generator/ArmV8Generator.cpp b/src/generator/ArmV8Generator.cpp
@@ -87,7 +87,7 @@ std::vector<uint8_t> ArmV8HandlerGenerator::handlerBytes(uint64_t address) {
 	return std::move(a.m_buffer);
 }
 
-std::vector<uint8_t> ArmV8HandlerGenerator::intervenerBytes(uint64_t address) {
+std::vector<uint8_t> ArmV8HandlerGenerator::intervenerBytes(uint64_t address, size_t size) {
     ArmV8Assembler a(address);
     using enum ArmV8Register;
 
@@ -125,7 +125,7 @@ std::vector<uint8_t> ArmV8HandlerGenerator::intervenerBytes(uint64_t address) {
     return std::move(a.m_buffer);
 }
 
-geode::Result<FunctionData> ArmV8HandlerGenerator::generateTrampoline(uint64_t target) {
+geode::Result<HandlerGenerator::TrampolineReturn> ArmV8HandlerGenerator::generateTrampoline(uint64_t target) {
 	auto origin = new CodeMemBlock(reinterpret_cast<uint64_t>(m_address), target);
 	auto relocated = new CodeMemBlock();
 	auto originBuffer = m_address;
@@ -148,5 +148,5 @@ geode::Result<FunctionData> ArmV8HandlerGenerator::generateTrampoline(uint64_t t
 	if (relocated->size == 0) {
 		return geode::Err("Failed to relocate original function");
 	}
-	return geode::Ok(FunctionData{m_trampoline, relocated->size});
+	return geode::Ok(TrampolineReturn{FunctionData{m_trampoline, relocated->size}, relocated->size});
 }
diff --git a/src/generator/ArmV8Generator.hpp b/src/generator/ArmV8Generator.hpp
@@ -10,10 +10,10 @@ namespace tulip::hook {
 	public:
 		using HandlerGenerator::HandlerGenerator;
 
-		geode::Result<FunctionData> generateTrampoline(uint64_t target) override;
+		geode::Result<TrampolineReturn> generateTrampoline(uint64_t target) override;
 
 		std::vector<uint8_t> handlerBytes(uint64_t address) override;
-		std::vector<uint8_t> intervenerBytes(uint64_t address) override;
+		std::vector<uint8_t> intervenerBytes(uint64_t address, size_t size) override;
 	};
 
 	class ArmV8WrapperGenerator : public WrapperGenerator {

diff --git a/src/generator/Generator.cpp b/src/generator/Generator.cpp
@@ -26,14 +26,14 @@ geode::Result<FunctionData> HandlerGenerator::generateHandler() {
 	return geode::Ok(FunctionData{m_handler, encode.size()});
 }
 
-geode::Result<std::vector<uint8_t>> HandlerGenerator::generateIntervener() {
+geode::Result<std::vector<uint8_t>> HandlerGenerator::generateIntervener(int64_t size) {
 	auto address = reinterpret_cast<uint64_t>(m_address);
-	auto encode = this->intervenerBytes(address);
+	auto encode = this->intervenerBytes(address, size);
 
 	return geode::Ok(std::move(encode));
 }
 
-geode::Result<FunctionData> HandlerGenerator::generateTrampoline(uint64_t target) {
+geode::Result<HandlerGenerator::TrampolineReturn> HandlerGenerator::generateTrampoline(uint64_t target) {
 	GEODE_UNWRAP_INTO(auto offsets, this->relocatedBytes(reinterpret_cast<uint64_t>(m_trampoline), target));
 
 	auto address = reinterpret_cast<uint64_t>(m_trampoline) + offsets.m_relocatedBytes.size();
@@ -45,13 +45,13 @@ geode::Result<FunctionData> HandlerGenerator::generateTrampoline(uint64_t target
 
 	GEODE_UNWRAP(Target::get().writeMemory(m_trampoline, merge.data(), merge.size()));
 
-	return geode::Ok(FunctionData{m_trampoline, merge.size()});
+	return geode::Ok(TrampolineReturn{FunctionData{m_trampoline, merge.size()}, offsets.m_originalOffset});
 }
 
 std::vector<uint8_t> HandlerGenerator::handlerBytes(uint64_t address) {
 	return std::vector<uint8_t>();
 }
-std::vector<uint8_t> HandlerGenerator::intervenerBytes(uint64_t address) {
+std::vector<uint8_t> HandlerGenerator::intervenerBytes(uint64_t address, size_t size) {
 	return std::vector<uint8_t>();
 }
 std::vector<uint8_t> HandlerGenerator::trampolineBytes(uint64_t address, size_t offset) {

diff --git a/src/generator/Generator.hpp b/src/generator/Generator.hpp
@@ -23,17 +23,22 @@ namespace tulip::hook {
 		virtual ~HandlerGenerator() = default;
 
 		virtual geode::Result<FunctionData> generateHandler();
-		virtual geode::Result<std::vector<uint8_t>> generateIntervener();
+		virtual geode::Result<std::vector<uint8_t>> generateIntervener(int64_t size);
 
 		struct RelocateReturn {
 			std::vector<uint8_t> m_relocatedBytes;
 			int64_t m_originalOffset;
 		};
 
-		virtual geode::Result<FunctionData> generateTrampoline(uint64_t target);
+		struct TrampolineReturn {
+			FunctionData m_trampoline;
+			int64_t m_originalOffset;
+		};
+
+		virtual geode::Result<TrampolineReturn> generateTrampoline(uint64_t target);
 
 		virtual std::vector<uint8_t> handlerBytes(uint64_t address);
-		virtual std::vector<uint8_t> intervenerBytes(uint64_t address);
+		virtual std::vector<uint8_t> intervenerBytes(uint64_t address, size_t size);
 		virtual std::vector<uint8_t> trampolineBytes(uint64_t address, size_t offset);
 		virtual geode::Result<RelocateReturn> relocatedBytes(uint64_t base, uint64_t target);
 	};

diff --git a/src/generator/X64Generator.cpp b/src/generator/X64Generator.cpp
@@ -306,7 +306,7 @@ geode::Result<FunctionData> X64HandlerGenerator::generateHandler() {
 	return geode::Ok(FunctionData{m_handler, codeSize});
 }
 
-std::vector<uint8_t> X64HandlerGenerator::intervenerBytes(uint64_t address) {
+std::vector<uint8_t> X64HandlerGenerator::intervenerBytes(uint64_t address, size_t size) {
 	X64Assembler a(address);
 	RegMem64 m;
 	using enum X64Register;
@@ -324,6 +324,10 @@ std::vector<uint8_t> X64HandlerGenerator::intervenerBytes(uint64_t address) {
 		a.updateLabels();
 	}
 
+	while (a.m_buffer.size() < size) {
+		a.nop();
+	}
+
 	return std::move(a.m_buffer);
 }
 
@@ -552,7 +556,7 @@ geode::Result<FunctionData> X64WrapperGenerator::generateWrapper() {
 // 	return std::move(a.m_buffer);
 // }
 
-geode::Result<FunctionData> X64HandlerGenerator::generateTrampoline(uint64_t target) {
+geode::Result<HandlerGenerator::TrampolineReturn> X64HandlerGenerator::generateTrampoline(uint64_t target) {
 	X64Assembler a(reinterpret_cast<uint64_t>(m_trampoline));
 	using enum X64Register;
 
@@ -656,7 +660,7 @@ geode::Result<FunctionData> X64HandlerGenerator::generateTrampoline(uint64_t tar
 
 	GEODE_UNWRAP(Target::get().writeMemory(m_trampoline, a.m_buffer.data(), a.m_buffer.size()));
 
-	return geode::Ok(FunctionData{m_trampoline, codeSizeFake});
+	return geode::Ok(TrampolineReturn{FunctionData{m_trampoline, codeSizeFake}, code.m_originalOffset});
 }
 
 geode::Result<> X64HandlerGenerator::relocateBranchInstruction(cs_insn* insn, uint8_t* buffer, uint64_t& trampolineAddress, uint64_t& originalAddress, int64_t targetAddress) {

diff --git a/src/generator/X64Generator.hpp b/src/generator/X64Generator.hpp
@@ -14,11 +14,11 @@ namespace tulip::hook {
 		using X86HandlerGenerator::X86HandlerGenerator;
 
 		// std::vector<uint8_t> handlerBytes(uint64_t address) override;
-		std::vector<uint8_t> intervenerBytes(uint64_t address) override;
+		std::vector<uint8_t> intervenerBytes(uint64_t address, size_t size) override;
 
 		geode::Result<FunctionData> generateHandler() override;
 
-		geode::Result<FunctionData> generateTrampoline(uint64_t target) override;
+		geode::Result<TrampolineReturn> generateTrampoline(uint64_t target) override;
 
 		geode::Result<> relocateRIPInstruction(cs_insn* insn, uint8_t* buffer, uint64_t& trampolineAddress, uint64_t& originalAddress, int64_t disp) override;
 		geode::Result<> relocateBranchInstruction(cs_insn* insn, uint8_t* buffer, uint64_t& trampolineAddress, uint64_t& originalAddress, int64_t targetAddress) override;

diff --git a/src/generator/X86Generator.cpp b/src/generator/X86Generator.cpp
@@ -100,11 +100,15 @@ std::vector<uint8_t> X86HandlerGenerator::handlerBytes(uint64_t address) {
 	return std::move(a.m_buffer);
 }
 
-std::vector<uint8_t> X86HandlerGenerator::intervenerBytes(uint64_t address) {
+std::vector<uint8_t> X86HandlerGenerator::intervenerBytes(uint64_t address, size_t size) {
 	X86Assembler a(address);
 
 	a.jmp(reinterpret_cast<uintptr_t>(m_handler));
 
+	while (a.m_buffer.size() < size) {
+		a.nop();
+	}
+
 	return std::move(a.m_buffer);
 }
 
@@ -166,7 +170,7 @@ geode::Result<FunctionData> X86WrapperGenerator::generateWrapper() {
 // 	return geode::Ok(area);
 // }
 
-geode::Result<FunctionData> X86HandlerGenerator::generateTrampoline(uint64_t target) {
+geode::Result<HandlerGenerator::TrampolineReturn> X86HandlerGenerator::generateTrampoline(uint64_t target) {
 	X86Assembler a(reinterpret_cast<uint64_t>(m_trampoline));
 	RegMem32 m;
 	using enum X86Register;
@@ -191,7 +195,7 @@ geode::Result<FunctionData> X86HandlerGenerator::generateTrampoline(uint64_t tar
 
 	GEODE_UNWRAP(Target::get().writeMemory(m_trampoline, a.m_buffer.data(), a.m_buffer.size()));
 
-	return geode::Ok(FunctionData{m_trampoline, codeSize});
+	return geode::Ok(TrampolineReturn{FunctionData{m_trampoline, codeSize}, code.m_originalOffset});
 }
 
 geode::Result<X86HandlerGenerator::RelocateReturn> X86HandlerGenerator::relocatedBytes(uint64_t baseAddress, uint64_t target) {

diff --git a/src/generator/X86Generator.hpp b/src/generator/X86Generator.hpp
@@ -19,9 +19,9 @@ namespace tulip::hook {
 		geode::Result<RelocateReturn> relocatedBytes(uint64_t base, uint64_t target) override;
 
 		std::vector<uint8_t> handlerBytes(uint64_t address) override;
-		std::vector<uint8_t> intervenerBytes(uint64_t address) override;
+		std::vector<uint8_t> intervenerBytes(uint64_t address, size_t size) override;
 
-		geode::Result<FunctionData> generateTrampoline(uint64_t target) override;
+		geode::Result<TrampolineReturn> generateTrampoline(uint64_t target) override;
 
 		virtual geode::Result<> relocateInstruction(cs_insn* insn, uint8_t* buffer, uint64_t& trampolineAddress, uint64_t& originalAddress);
 		virtual geode::Result<> relocateRIPInstruction(cs_insn* insn, uint8_t* buffer, uint64_t& trampolineAddress, uint64_t& originalAddress, int64_t disp);