ToxicMushroom/Dalamud
1
0
Fork 0
mirror of https://github.com/goatcorp/Dalamud.git synced 2025-12-12 18:27:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Bump Reloaded.Hooks and dependencies to 4.0.1 (#904)

Browse source
This commit is contained in:
marzent 2022-06-29 11:51:51 +02:00 • committed by GitHub
parent e8cb303314
commit efcf8358d8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Dalamud.Injector/Dalamud.Injector.csproj
View file

@ -64,8 +64,8 @@
<PackageReference Include="JetBrains.Annotations" Version="2022.1.0" /> <PackageReference Include="JetBrains.Annotations" Version="2022.1.0" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.1" /> <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
<PackageReference Include="PeNet" Version="2.6.4" /> <PackageReference Include="PeNet" Version="2.6.4" />
<PackageReference Include="Reloaded.Memory" Version="4.1.1" /> <PackageReference Include="Reloaded.Memory" Version="7.0.0" />
<PackageReference Include="Reloaded.Memory.Buffers" Version="1.4.4" /> <PackageReference Include="Reloaded.Memory.Buffers" Version="2.0.0" />
<PackageReference Include="Serilog" Version="2.11.0" /> <PackageReference Include="Serilog" Version="2.11.0" />
<PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" /> <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />
<PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" /> <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />

2
Dalamud.Injector/EntryPoint.cs
View file

@ -726,7 +726,7 @@ namespace Dalamud.Injector
using var startInfoBuffer = new MemoryBufferHelper(process).CreatePrivateMemoryBuffer(startInfoBytes.Length + 0x8); using var startInfoBuffer = new MemoryBufferHelper(process).CreatePrivateMemoryBuffer(startInfoBytes.Length + 0x8);
var startInfoAddress = startInfoBuffer.Add(startInfoBytes); var startInfoAddress = startInfoBuffer.Add(startInfoBytes);
if (startInfoAddress == IntPtr.Zero) if (startInfoAddress == UIntPtr.Zero)
throw new Exception("Unable to allocate start info JSON"); throw new Exception("Unable to allocate start info JSON");
injector.GetFunctionAddress(bootModule, "Initialize", out var initAddress); injector.GetFunctionAddress(bootModule, "Initialize", out var initAddress);

96
Dalamud.Injector/Injector.cs
View file

@ -32,11 +32,11 @@ namespace Dalamud.Injector
private readonly CircularBuffer circularBuffer; private readonly CircularBuffer circularBuffer;
private readonly PrivateMemoryBuffer memoryBuffer; private readonly PrivateMemoryBuffer memoryBuffer;
private IntPtr loadLibraryShellPtr; private UIntPtr loadLibraryShellPtr;
private IntPtr loadLibraryRetPtr; private UIntPtr loadLibraryRetPtr;
private IntPtr getProcAddressShellPtr; private UIntPtr getProcAddressShellPtr;
private IntPtr getProcAddressRetPtr; private UIntPtr getProcAddressRetPtr;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="Injector"/> class. /// Initializes a new instance of the <see cref="Injector"/> class.
@ -81,16 +81,16 @@ namespace Dalamud.Injector
/// </summary> /// </summary>
/// <param name="modulePath">Absolute file path.</param> /// <param name="modulePath">Absolute file path.</param>
/// <param name="address">Address to the module.</param> /// <param name="address">Address to the module.</param>
public void LoadLibrary(string modulePath, out IntPtr address) public void LoadLibrary(string modulePath, out UIntPtr address)
{ {
var lpParameter = this.WriteNullTerminatedUnicodeString(modulePath); var lpParameter = this.WriteNullTerminatedUnicodeString(modulePath);
if (lpParameter == IntPtr.Zero) if (lpParameter == UIntPtr.Zero)
throw new Exception("Unable to allocate LoadLibraryW parameter"); throw new Exception("Unable to allocate LoadLibraryW parameter");
this.CallRemoteFunction(this.loadLibraryShellPtr, lpParameter, out var err); this.CallRemoteFunction(this.loadLibraryShellPtr, lpParameter, out var err);
address = this.extMemory.Read<IntPtr>(this.loadLibraryRetPtr); this.extMemory.Read(this.loadLibraryRetPtr, out address);
if (address == IntPtr.Zero) if (address == UIntPtr.Zero)
throw new Exception($"LoadLibraryW(\"{modulePath}\") failure: {new Win32Exception((int)err).Message} ({err})"); throw new Exception($"LoadLibraryW(\"{modulePath}\") failure: {new Win32Exception((int)err).Message} ({err})");
} }
@ -100,17 +100,17 @@ namespace Dalamud.Injector
/// <param name="module">Module address.</param> /// <param name="module">Module address.</param>
/// <param name="functionName">Name of the exported method.</param> /// <param name="functionName">Name of the exported method.</param>
/// <param name="address">Address to the function.</param> /// <param name="address">Address to the function.</param>
public void GetFunctionAddress(IntPtr module, string functionName, out IntPtr address) public void GetFunctionAddress(UIntPtr module, string functionName, out UIntPtr address)
{ {
var functionNamePtr = this.WriteNullTerminatedASCIIString(functionName); var functionNamePtr = this.WriteNullTerminatedASCIIString(functionName);
var getProcAddressParams = new GetProcAddressParams(module, functionNamePtr); var getProcAddressParams = new GetProcAddressParams(module, functionNamePtr);
var lpParameter = this.circularBuffer.Add(ref getProcAddressParams); var lpParameter = this.circularBuffer.Add(ref getProcAddressParams);
if (lpParameter == IntPtr.Zero) if (lpParameter == UIntPtr.Zero)
throw new Exception("Unable to allocate GetProcAddress parameter ptr"); throw new Exception("Unable to allocate GetProcAddress parameter ptr");
this.CallRemoteFunction(this.getProcAddressShellPtr, lpParameter, out var err); this.CallRemoteFunction(this.getProcAddressShellPtr, lpParameter, out var err);
address = this.extMemory.Read<IntPtr>(this.getProcAddressRetPtr); this.extMemory.Read(this.getProcAddressRetPtr, out address);
if (address == IntPtr.Zero) if (address == UIntPtr.Zero)
throw new Exception($"GetProcAddress(0x{module:X}, \"{functionName}\") failure: {new Win32Exception((int)err).Message} ({err})"); throw new Exception($"GetProcAddress(0x{module:X}, \"{functionName}\") failure: {new Win32Exception((int)err).Message} ({err})");
} }
@ -120,7 +120,7 @@ namespace Dalamud.Injector
/// <param name="methodAddress">Method address.</param> /// <param name="methodAddress">Method address.</param>
/// <param name="parameterAddress">Parameter address.</param> /// <param name="parameterAddress">Parameter address.</param>
/// <param name="exitCode">Thread exit code.</param> /// <param name="exitCode">Thread exit code.</param>
public void CallRemoteFunction(IntPtr methodAddress, IntPtr parameterAddress, out uint exitCode) public void CallRemoteFunction(UIntPtr methodAddress, UIntPtr parameterAddress, out uint exitCode)
{ {
// Create and initialize a thread at our address and parameter address. // Create and initialize a thread at our address and parameter address.
var threadHandle = CreateRemoteThread( var threadHandle = CreateRemoteThread(
@ -150,21 +150,21 @@ namespace Dalamud.Injector
var functionAddr = kernel32Module.BaseAddress + (int)this.GetExportedFunctionOffset(kernel32Exports, "LoadLibraryW"); var functionAddr = kernel32Module.BaseAddress + (int)this.GetExportedFunctionOffset(kernel32Exports, "LoadLibraryW");
Log.Verbose($"LoadLibraryW: 0x{functionAddr.ToInt64():X}"); Log.Verbose($"LoadLibraryW: 0x{functionAddr.ToInt64():X}");
var functionPtr = this.memoryBuffer.Add(ref functionAddr); var functionPtr = (UIntPtr)this.memoryBuffer.Add(ref functionAddr);
Log.Verbose($"LoadLibraryPtr: 0x{functionPtr.ToInt64():X}"); Log.Verbose($"LoadLibraryPtr: 0x{functionPtr.ToUInt64():X}");
if (functionPtr == IntPtr.Zero) if (functionPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate LoadLibraryW function ptr"); throw new Exception("Unable to allocate LoadLibraryW function ptr");
var dummy = IntPtr.Zero; var dummy = IntPtr.Zero;
this.loadLibraryRetPtr = this.memoryBuffer.Add(ref dummy); this.loadLibraryRetPtr = this.memoryBuffer.Add(ref dummy);
Log.Verbose($"LoadLibraryRetPtr: 0x{this.loadLibraryRetPtr.ToInt64():X}"); Log.Verbose($"LoadLibraryRetPtr: 0x{this.loadLibraryRetPtr.ToUInt64():X}");
if (this.loadLibraryRetPtr == IntPtr.Zero) if (this.loadLibraryRetPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate LoadLibraryW return value"); throw new Exception("Unable to allocate LoadLibraryW return value");
var func = functionPtr.ToInt64(); var func = functionPtr.ToUInt64();
var retVal = this.loadLibraryRetPtr.ToInt64(); var retVal = this.loadLibraryRetPtr.ToUInt64();
var asm = new Assembler(64); var asm = new Assembler(64);
@ -178,22 +178,22 @@ namespace Dalamud.Injector
var bytes = this.Assemble(asm); var bytes = this.Assemble(asm);
this.loadLibraryShellPtr = this.memoryBuffer.Add(bytes); this.loadLibraryShellPtr = this.memoryBuffer.Add(bytes);
Log.Verbose($"LoadLibraryShellPtr: 0x{this.loadLibraryShellPtr.ToInt64():X}"); Log.Verbose($"LoadLibraryShellPtr: 0x{this.loadLibraryShellPtr.ToUInt64():X}");
if (this.loadLibraryShellPtr == IntPtr.Zero) if (this.loadLibraryShellPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate LoadLibraryW shellcode"); throw new Exception("Unable to allocate LoadLibraryW shellcode");
this.extMemory.ChangePermission(this.loadLibraryShellPtr, bytes.Length, Reloaded.Memory.Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); this.extMemory.ChangePermission(this.loadLibraryShellPtr, bytes.Length, Reloaded.Memory.Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE);
#if DEBUG #if DEBUG
var outFunctionPtr = this.extMemory.Read<IntPtr>(functionPtr); this.extMemory.Read<IntPtr>(functionPtr, out var outFunctionPtr);
Log.Verbose($"LoadLibraryPtr: {this.GetResultMarker(outFunctionPtr == functionAddr)}"); Log.Verbose($"LoadLibraryPtr: {this.GetResultMarker(outFunctionPtr == functionAddr)}");
var outRetPtr = this.extMemory.Read<IntPtr>(this.loadLibraryRetPtr); this.extMemory.Read<IntPtr>(this.loadLibraryRetPtr, out var outRetPtr);
Log.Verbose($"LoadLibraryRet: {this.GetResultMarker(dummy == outRetPtr)}"); Log.Verbose($"LoadLibraryRet: {this.GetResultMarker(dummy == outRetPtr)}");
this.extMemory.ReadRaw(this.loadLibraryShellPtr, out var outBytes, bytes.Length); this.extMemory.ReadRaw(this.loadLibraryShellPtr, out var outBytes, bytes.Length);
Log.Verbose($"LoadLibraryShellPtr: {this.GetResultMarker(Enumerable.SequenceEqual(bytes, outBytes))}"); Log.Verbose($"LoadLibraryShellPtr: {this.GetResultMarker(bytes.SequenceEqual(outBytes))}");
#endif #endif
} }
@ -206,21 +206,21 @@ namespace Dalamud.Injector
var functionAddr = kernel32Module.BaseAddress + (int)offset; var functionAddr = kernel32Module.BaseAddress + (int)offset;
Log.Verbose($"GetProcAddress: 0x{functionAddr.ToInt64():X}"); Log.Verbose($"GetProcAddress: 0x{functionAddr.ToInt64():X}");
var functionPtr = this.memoryBuffer.Add(ref functionAddr); var functionPtr = (UIntPtr)this.memoryBuffer.Add(ref functionAddr);
Log.Verbose($"GetProcAddressPtr: 0x{functionPtr.ToInt64():X}"); Log.Verbose($"GetProcAddressPtr: 0x{functionPtr.ToUInt64():X}");
if (functionPtr == IntPtr.Zero) if (functionPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate GetProcAddress function ptr"); throw new Exception("Unable to allocate GetProcAddress function ptr");
var dummy = IntPtr.Zero; var dummy = IntPtr.Zero;
this.getProcAddressRetPtr = this.memoryBuffer.Add(ref dummy); this.getProcAddressRetPtr = this.memoryBuffer.Add(ref dummy);
Log.Verbose($"GetProcAddressRetPtr: 0x{this.loadLibraryRetPtr.ToInt64():X}"); Log.Verbose($"GetProcAddressRetPtr: 0x{this.loadLibraryRetPtr.ToUInt64():X}");
if (this.getProcAddressRetPtr == IntPtr.Zero) if (this.getProcAddressRetPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate GetProcAddress return value"); throw new Exception("Unable to allocate GetProcAddress return value");
var func = functionPtr.ToInt64(); var func = functionPtr.ToUInt64();
var retVal = this.getProcAddressRetPtr.ToInt64(); var retVal = this.getProcAddressRetPtr.ToUInt64();
var asm = new Assembler(64); var asm = new Assembler(64);
@ -236,22 +236,22 @@ namespace Dalamud.Injector
var bytes = this.Assemble(asm); var bytes = this.Assemble(asm);
this.getProcAddressShellPtr = this.memoryBuffer.Add(bytes); this.getProcAddressShellPtr = this.memoryBuffer.Add(bytes);
Log.Verbose($"GetProcAddressShellPtr: 0x{this.getProcAddressShellPtr.ToInt64():X}"); Log.Verbose($"GetProcAddressShellPtr: 0x{this.getProcAddressShellPtr.ToUInt64():X}");
if (this.getProcAddressShellPtr == IntPtr.Zero) if (this.getProcAddressShellPtr == UIntPtr.Zero)
throw new Exception("Unable to allocate GetProcAddress shellcode"); throw new Exception("Unable to allocate GetProcAddress shellcode");
this.extMemory.ChangePermission(this.getProcAddressShellPtr, bytes.Length, Reloaded.Memory.Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); this.extMemory.ChangePermission(this.getProcAddressShellPtr, bytes.Length, Reloaded.Memory.Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE);
#if DEBUG #if DEBUG
var outFunctionPtr = this.extMemory.Read<IntPtr>(functionPtr); this.extMemory.Read<IntPtr>(functionPtr, out var outFunctionPtr);
Log.Verbose($"GetProcAddressPtr: {this.GetResultMarker(outFunctionPtr == functionAddr)}"); Log.Verbose($"GetProcAddressPtr: {this.GetResultMarker(outFunctionPtr == functionAddr)}");
var outRetPtr = this.extMemory.Read<IntPtr>(this.loadLibraryRetPtr); this.extMemory.Read<IntPtr>(this.loadLibraryRetPtr, out var outRetPtr);
Log.Verbose($"GetProcAddressRet: {this.GetResultMarker(dummy == outRetPtr)}"); Log.Verbose($"GetProcAddressRet: {this.GetResultMarker(dummy == outRetPtr)}");
this.extMemory.ReadRaw(this.getProcAddressShellPtr, out var outBytes, bytes.Length); this.extMemory.ReadRaw(this.getProcAddressShellPtr, out var outBytes, bytes.Length);
Log.Verbose($"GetProcAddressShellPtr: {this.GetResultMarker(Enumerable.SequenceEqual(bytes, outBytes))}"); Log.Verbose($"GetProcAddressShellPtr: {this.GetResultMarker(bytes.SequenceEqual(outBytes))}");
#endif #endif
} }
@ -298,33 +298,33 @@ namespace Dalamud.Injector
return exportFunction.Address; return exportFunction.Address;
} }
private IntPtr WriteNullTerminatedASCIIString(string value) private UIntPtr WriteNullTerminatedASCIIString(string value)
{ {
var bytes = Encoding.ASCII.GetBytes(value + '\0'); var bytes = Encoding.ASCII.GetBytes(value + '\0');
var address = this.circularBuffer.Add(bytes); var address = (UIntPtr)this.circularBuffer.Add(bytes);
if (address == IntPtr.Zero) if (address == UIntPtr.Zero)
throw new Exception("Unable to write ASCII string to buffer"); throw new Exception("Unable to write ASCII string to buffer");
#if DEBUG #if DEBUG
this.extMemory.ReadRaw(address, out var outBytes, bytes.Length); this.extMemory.ReadRaw(address, out var outBytes, bytes.Length);
Log.Verbose($"WriteASCII: {this.GetResultMarker(Enumerable.SequenceEqual(bytes, outBytes))} 0x{address.ToInt64():X} {value}"); Log.Verbose($"WriteASCII: {this.GetResultMarker(bytes.SequenceEqual(outBytes))} 0x{address.ToUInt64():X} {value}");
#endif #endif
return address; return address;
} }
private IntPtr WriteNullTerminatedUnicodeString(string value) private UIntPtr WriteNullTerminatedUnicodeString(string value)
{ {
var bytes = Encoding.Unicode.GetBytes(value + '\0'); var bytes = Encoding.Unicode.GetBytes(value + '\0');
var address = this.circularBuffer.Add(bytes); var address = (UIntPtr)this.circularBuffer.Add(bytes);
if (address == IntPtr.Zero) if (address == UIntPtr.Zero)
throw new Exception("Unable to write Unicode string to buffer"); throw new Exception("Unable to write Unicode string to buffer");
#if DEBUG #if DEBUG
this.extMemory.ReadRaw(address, out var outBytes, bytes.Length); this.extMemory.ReadRaw(address, out var outBytes, bytes.Length);
Log.Verbose($"WriteUnicode: {this.GetResultMarker(Enumerable.SequenceEqual(bytes, outBytes))} 0x{address.ToInt64():X} {value}"); Log.Verbose($"WriteUnicode: {this.GetResultMarker(bytes.SequenceEqual(outBytes))} 0x{address.ToUInt64():X} {value}");
#endif #endif
return address; return address;
@ -337,10 +337,10 @@ namespace Dalamud.Injector
[StructLayout(LayoutKind.Sequential)] [StructLayout(LayoutKind.Sequential)]
private struct GetProcAddressParams private struct GetProcAddressParams
{ {
public GetProcAddressParams(IntPtr hModule, IntPtr lPProcName) public GetProcAddressParams(UIntPtr hModule, UIntPtr lPProcName)
{ {
this.HModule = hModule.ToInt64(); this.HModule = (long)hModule.ToUInt64();
this.LPProcName = lPProcName.ToInt64(); this.LPProcName = (long)lPProcName.ToUInt64();
} }
public long HModule { get; set; } public long HModule { get; set; }

4
Dalamud.Injector/NativeFunctions.cs
View file

@ -661,8 +661,8 @@ namespace Dalamud.Injector
IntPtr hProcess, IntPtr hProcess,
IntPtr lpThreadAttributes, IntPtr lpThreadAttributes,
UIntPtr dwStackSize, UIntPtr dwStackSize,
IntPtr lpStartAddress, UIntPtr lpStartAddress,
IntPtr lpParameter, UIntPtr lpParameter,
CreateThreadFlags dwCreationFlags, CreateThreadFlags dwCreationFlags,
out uint lpThreadId); out uint lpThreadId);

2
Dalamud/Dalamud.csproj
View file

@ -74,7 +74,7 @@
<PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" /> <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />
<PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" /> <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
<PackageReference Include="Serilog.Sinks.File" Version="5.0.0" /> <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
<PackageReference Include="Reloaded.Hooks" Version="3.5.3" /> <PackageReference Include="Reloaded.Hooks" Version="4.0.1" />
<PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.333"> <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.333">
<PrivateAssets>all</PrivateAssets> <PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>