diff --git a/Dalamud.Injector/Dalamud.Injector.csproj b/Dalamud.Injector/Dalamud.Injector.csproj index c0234500c..5d76a11f6 100644 --- a/Dalamud.Injector/Dalamud.Injector.csproj +++ b/Dalamud.Injector/Dalamud.Injector.csproj @@ -11,6 +11,9 @@ false true Portable + IDE1006;CS1701;CS1702 + true + $(SolutionDir)\bin\Dalamud.Injector.xml true @@ -19,9 +22,6 @@ XIVLauncher addon injection 5.2.4.6 - - - $(MSBuildProjectDirectory)\ $(AppOutputBase)=C:\goatsoft\companysecrets\injector\ @@ -33,9 +33,19 @@ dalamud.ico + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + @@ -45,6 +55,6 @@ - + diff --git a/Dalamud.Injector/GlobalSuppressions.cs b/Dalamud.Injector/GlobalSuppressions.cs new file mode 100644 index 000000000..3fca475cc --- /dev/null +++ b/Dalamud.Injector/GlobalSuppressions.cs @@ -0,0 +1,19 @@ +// This file is used by Code Analysis to maintain SuppressMessage +// attributes that are applied to this project. +// Project-level suppressions either have no target or are given +// a specific target and scoped to a namespace, type, member, etc. + +using System.Diagnostics.CodeAnalysis; + +// General +[assembly: SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1118:Parameter should not span multiple lines", Justification = "Preventing long lines", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1124:Do not use regions", Justification = "I like regions", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1123:Do not place regions within elements", Justification = "I like regions in elements too", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.LayoutRules", "SA1503:Braces should not be omitted", Justification = "This is annoying", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.LayoutRules", "SA1512:Single-line comments should not be followed by blank line", Justification = "I like this better", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.LayoutRules", "SA1515:Single-line comment should be preceded by blank line", Justification = "I like this better", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1127:Generic type constraints should be on their own line", Justification = "I like this better", Scope = "namespaceanddescendants", Target = "~N:Dalamud")] +[assembly: SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1633:File should have header", Justification = "We don't do those yet")] + +// Program.cs +[assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "Used during #if DEBUG", Scope = "member", Target = "~M:Dalamud.Injector.Program.NativeInject(System.Diagnostics.Process)")] diff --git a/Dalamud.Injector/NativeFunctions.cs b/Dalamud.Injector/NativeFunctions.cs index fb030b0e1..90e61a5fc 100644 --- a/Dalamud.Injector/NativeFunctions.cs +++ b/Dalamud.Injector/NativeFunctions.cs @@ -1,79 +1,491 @@ using System; -using System.Collections.Generic; -using System.Diagnostics; -using System.Linq; using System.Runtime.ConstrainedExecution; using System.Runtime.InteropServices; using System.Security; -using System.Text; -using System.Threading.Tasks; namespace Dalamud.Injector { - static class NativeFunctions + /// + /// Native functions. + /// + internal static class NativeFunctions { - [Flags] - public enum ProcessAccessFlags : uint - { - All = 0x001F0FFF, - Terminate = 0x00000001, - CreateThread = 0x00000002, - VirtualMemoryOperation = 0x00000008, - VirtualMemoryRead = 0x00000010, - VirtualMemoryWrite = 0x00000020, - DuplicateHandle = 0x00000040, - CreateProcess = 0x000000080, - SetQuota = 0x00000100, - SetInformation = 0x00000200, - QueryInformation = 0x00000400, - QueryLimitedInformation = 0x00001000, - Synchronize = 0x00100000 - } - - [DllImport("kernel32.dll", SetLastError = true)] - public static extern IntPtr OpenProcess( - ProcessAccessFlags processAccess, - bool bInheritHandle, - int processId); - public static IntPtr OpenProcess(Process proc, ProcessAccessFlags flags) - { - return OpenProcess(flags, false, proc.Id); - } - + /// + /// MEM_* from memoryapi. + /// [Flags] public enum AllocationType { + /// + /// To coalesce two adjacent placeholders, specify MEM_RELEASE | MEM_COALESCE_PLACEHOLDERS. When you coalesce + /// placeholders, lpAddress and dwSize must exactly match those of the placeholder. + /// + CoalescePlaceholders = 0x00000001, + + /// + /// Frees an allocation back to a placeholder (after you've replaced a placeholder with a private allocation using + /// VirtualAlloc2 or Virtual2AllocFromApp). To split a placeholder into two placeholders, specify + /// MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER. + /// + PreservePlaceholder = 0x00000002, + + /// + /// Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved + /// memory pages. The function also guarantees that when the caller later initially accesses the memory, the contents + /// will be zero. Actual physical pages are not allocated unless/until the virtual addresses are actually accessed. + /// To reserve and commit pages in one step, call VirtualAllocEx with MEM_COMMIT | MEM_RESERVE. Attempting to commit + /// a specific address range by specifying MEM_COMMIT without MEM_RESERVE and a non-NULL lpAddress fails unless the + /// entire range has already been reserved. The resulting error code is ERROR_INVALID_ADDRESS. An attempt to commit + /// a page that is already committed does not cause the function to fail. This means that you can commit pages without + /// first determining the current commitment state of each page. If lpAddress specifies an address within an enclave, + /// flAllocationType must be MEM_COMMIT. + /// Commit = 0x1000, + + /// + /// Reserves a range of the process's virtual address space without allocating any actual physical storage in memory + /// or in the paging file on disk. You commit reserved pages by calling VirtualAllocEx again with MEM_COMMIT. To + /// reserve and commit pages in one step, call VirtualAllocEx with MEM_COMMIT | MEM_RESERVE. Other memory allocation + /// functions, such as malloc and LocalAlloc, cannot use reserved memory until it has been released. + /// Reserve = 0x2000, + + /// + /// Decommits the specified region of committed pages. After the operation, the pages are in the reserved state. + /// The function does not fail if you attempt to decommit an uncommitted page. This means that you can decommit + /// a range of pages without first determining the current commitment state. The MEM_DECOMMIT value is not supported + /// when the lpAddress parameter provides the base address for an enclave. + /// Decommit = 0x4000, + + /// + /// Releases the specified region of pages, or placeholder (for a placeholder, the address space is released and + /// available for other allocations). After this operation, the pages are in the free state. If you specify this + /// value, dwSize must be 0 (zero), and lpAddress must point to the base address returned by the VirtualAlloc function + /// when the region is reserved. The function fails if either of these conditions is not met. If any pages in the + /// region are committed currently, the function first decommits, and then releases them. The function does not + /// fail if you attempt to release pages that are in different states, some reserved and some committed. This means + /// that you can release a range of pages without first determining the current commitment state. + /// Release = 0x8000, + + /// + /// Indicates that data in the memory range specified by lpAddress and dwSize is no longer of interest. The pages + /// should not be read from or written to the paging file. However, the memory block will be used again later, so + /// it should not be decommitted. This value cannot be used with any other value. Using this value does not guarantee + /// that the range operated on with MEM_RESET will contain zeros. If you want the range to contain zeros, decommit + /// the memory and then recommit it. When you use MEM_RESET, the VirtualAllocEx function ignores the value of fProtect. + /// However, you must still set fProtect to a valid protection value, such as PAGE_NOACCESS. VirtualAllocEx returns + /// an error if you use MEM_RESET and the range of memory is mapped to a file. A shared view is only acceptable + /// if it is mapped to a paging file. + /// Reset = 0x80000, + + /// + /// MEM_RESET_UNDO should only be called on an address range to which MEM_RESET was successfully applied earlier. + /// It indicates that the data in the specified memory range specified by lpAddress and dwSize is of interest to + /// the caller and attempts to reverse the effects of MEM_RESET. If the function succeeds, that means all data in + /// the specified address range is intact. If the function fails, at least some of the data in the address range + /// has been replaced with zeroes. This value cannot be used with any other value. If MEM_RESET_UNDO is called on + /// an address range which was not MEM_RESET earlier, the behavior is undefined. When you specify MEM_RESET, the + /// VirtualAllocEx function ignores the value of flProtect. However, you must still set flProtect to a valid + /// protection value, such as PAGE_NOACCESS. + /// + ResetUndo = 0x1000000, + + /// + /// Reserves an address range that can be used to map Address Windowing Extensions (AWE) pages. This value must + /// be used with MEM_RESERVE and no other values. + /// Physical = 0x400000, + + /// + /// Allocates memory at the highest possible address. This can be slower than regular allocations, especially when + /// there are many allocations. + /// TopDown = 0x100000, + + /// + /// Causes the system to track pages that are written to in the allocated region. If you specify this value, you + /// must also specify MEM_RESERVE. To retrieve the addresses of the pages that have been written to since the region + /// was allocated or the write-tracking state was reset, call the GetWriteWatch function. To reset the write-tracking + /// state, call GetWriteWatch or ResetWriteWatch. The write-tracking feature remains enabled for the memory region + /// until the region is freed. + /// WriteWatch = 0x200000, - LargePages = 0x20000000 + + /// + /// Allocates memory using large page support. The size and alignment must be a multiple of the large-page minimum. + /// To obtain this value, use the GetLargePageMinimum function. If you specify this value, you must also specify + /// MEM_RESERVE and MEM_COMMIT. + /// + LargePages = 0x20000000, } - [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)] - public static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, - int dwSize, AllocationType dwFreeType); - + /// + /// PAGE_* from memoryapi. + /// [Flags] public enum MemoryProtection { + /// + /// Enables execute access to the committed region of pages. An attempt to write to the committed region results + /// in an access violation. This flag is not supported by the CreateFileMapping function. + /// Execute = 0x10, + + /// + /// Enables execute or read-only access to the committed region of pages. An attempt to write to the committed region + /// results in an access violation. + /// ExecuteRead = 0x20, + + /// + /// Enables execute, read-only, or read/write access to the committed region of pages. + /// ExecuteReadWrite = 0x40, + + /// + /// Enables execute, read-only, or copy-on-write access to a mapped view of a file mapping object. An attempt to + /// write to a committed copy-on-write page results in a private copy of the page being made for the process. The + /// private page is marked as PAGE_EXECUTE_READWRITE, and the change is written to the new page. This flag is not + /// supported by the VirtualAlloc or VirtualAllocEx functions. + /// ExecuteWriteCopy = 0x80, + + /// + /// Disables all access to the committed region of pages. An attempt to read from, write to, or execute the committed + /// region results in an access violation. This flag is not supported by the CreateFileMapping function. + /// NoAccess = 0x01, + + /// + /// Enables read-only access to the committed region of pages. An attempt to write to the committed region results + /// in an access violation. If Data Execution Prevention is enabled, an attempt to execute code in the committed + /// region results in an access violation. + /// ReadOnly = 0x02, + + /// + /// Enables read-only or read/write access to the committed region of pages. If Data Execution Prevention is enabled, + /// attempting to execute code in the committed region results in an access violation. + /// ReadWrite = 0x04, + + /// + /// Enables read-only or copy-on-write access to a mapped view of a file mapping object. An attempt to write to + /// a committed copy-on-write page results in a private copy of the page being made for the process. The private + /// page is marked as PAGE_READWRITE, and the change is written to the new page. If Data Execution Prevention is + /// enabled, attempting to execute code in the committed region results in an access violation. This flag is not + /// supported by the VirtualAlloc or VirtualAllocEx functions. + /// WriteCopy = 0x08, - GuardModifierflag = 0x100, - NoCacheModifierflag = 0x200, - WriteCombineModifierflag = 0x400 + + /// + /// Sets all locations in the pages as invalid targets for CFG. Used along with any execute page protection like + /// PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE and PAGE_EXECUTE_WRITECOPY. Any indirect call to locations + /// in those pages will fail CFG checks and the process will be terminated. The default behavior for executable + /// pages allocated is to be marked valid call targets for CFG. This flag is not supported by the VirtualProtect + /// or CreateFileMapping functions. + /// + TargetsInvalid = 0x40000000, + + /// + /// Pages in the region will not have their CFG information updated while the protection changes for VirtualProtect. + /// For example, if the pages in the region was allocated using PAGE_TARGETS_INVALID, then the invalid information + /// will be maintained while the page protection changes. This flag is only valid when the protection changes to + /// an executable type like PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE and PAGE_EXECUTE_WRITECOPY. + /// The default behavior for VirtualProtect protection change to executable is to mark all locations as valid call + /// targets for CFG. + /// + TargetsNoUpdate = 0x40000000, + + /// + /// Pages in the region become guard pages. Any attempt to access a guard page causes the system to raise a + /// STATUS_GUARD_PAGE_VIOLATION exception and turn off the guard page status. Guard pages thus act as a one-time + /// access alarm. For more information, see Creating Guard Pages. When an access attempt leads the system to turn + /// off guard page status, the underlying page protection takes over. If a guard page exception occurs during a + /// system service, the service typically returns a failure status indicator. This value cannot be used with + /// PAGE_NOACCESS. This flag is not supported by the CreateFileMapping function. + /// + Guard = 0x100, + + /// + /// Sets all pages to be non-cachable. Applications should not use this attribute except when explicitly required + /// for a device. Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an + /// EXCEPTION_ILLEGAL_INSTRUCTION exception. The PAGE_NOCACHE flag cannot be used with the PAGE_GUARD, PAGE_NOACCESS, + /// or PAGE_WRITECOMBINE flags. The PAGE_NOCACHE flag can be used only when allocating private memory with the + /// VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions. To enable non-cached memory access for shared + /// memory, specify the SEC_NOCACHE flag when calling the CreateFileMapping function. + /// + NoCache = 0x200, + + /// + /// Sets all pages to be write-combined. Applications should not use this attribute except when explicitly required + /// for a device. Using the interlocked functions with memory that is mapped as write-combined can result in an + /// EXCEPTION_ILLEGAL_INSTRUCTION exception. The PAGE_WRITECOMBINE flag cannot be specified with the PAGE_NOACCESS, + /// PAGE_GUARD, and PAGE_NOCACHE flags. The PAGE_WRITECOMBINE flag can be used only when allocating private memory + /// with the VirtualAlloc, VirtualAllocEx, or VirtualAllocExNuma functions. To enable write-combined memory access + /// for shared memory, specify the SEC_WRITECOMBINE flag when calling the CreateFileMapping function. + /// + WriteCombine = 0x400, } + /// + /// PROCESS_* from processthreadsapi. + /// + [Flags] + public enum ProcessAccessFlags : uint + { + /// + /// All possible access rights for a process object. + /// + AllAccess = 0x001F0FFF, + + /// + /// Required to create a process. + /// + CreateProcess = 0x0080, + + /// + /// Required to create a thread. + /// + CreateThread = 0x0002, + + /// + /// Required to duplicate a handle using DuplicateHandle. + /// + DupHandle = 0x0040, + + /// + /// Required to retrieve certain information about a process, such as its token, exit code, + /// and priority class (see OpenProcessToken). + /// + QueryInformation = 0x0400, + + /// + /// Required to retrieve certain information about a process(see GetExitCodeProcess, GetPriorityClass, IsProcessInJob, + /// QueryFullProcessImageName). A handle that has the PROCESS_QUERY_INFORMATION access right is automatically granted + /// PROCESS_QUERY_LIMITED_INFORMATION. + /// + QueryLimitedInformation = 0x1000, + + /// + /// Required to set certain information about a process, such as its priority class (see SetPriorityClass). + /// + SetInformation = 0x0200, + + /// + /// Required to set memory limits using SetProcessWorkingSetSize. + /// + SetQuote = 0x0100, + + /// + /// Required to suspend or resume a process. + /// + SuspendResume = 0x0800, + + /// + /// Required to terminate a process using TerminateProcess. + /// + Terminate = 0x0001, + + /// + /// Required to perform an operation on the address space of a process(see VirtualProtectEx and WriteProcessMemory). + /// + VmOperation = 0x0008, + + /// + /// Required to read memory in a process using ReadProcessMemory. + /// + VmRead = 0x0010, + + /// + /// Required to write to memory in a process using WriteProcessMemory. + /// + VmWrite = 0x0020, + + /// + /// Required to wait for the process to terminate using the wait functions. + /// + Synchronize = 0x00100000, + } + + /// + /// Closes an open object handle. + /// + /// + /// A valid handle to an open object. + /// + /// + /// If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.To get extended + /// error information, call GetLastError. If the application is running under a debugger, the function will throw an + /// exception if it receives either a handle value that is not valid or a pseudo-handle value. This can happen if you + /// close a handle twice, or if you call CloseHandle on a handle returned by the FindFirstFile function instead of calling + /// the FindClose function. + /// + [DllImport("kernel32.dll", SetLastError = true)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool CloseHandle(IntPtr hObject); + + /// + /// Creates a thread that runs in the virtual address space of another process. Use the CreateRemoteThreadEx function + /// to create a thread that runs in the virtual address space of another process and optionally specify extended attributes. + /// + /// + /// A handle to the process in which the thread is to be created. The handle must have the PROCESS_CREATE_THREAD, + /// PROCESS_QUERY_INFORMATION, PROCESS_VM_OPERATION, PROCESS_VM_WRITE, and PROCESS_VM_READ access rights, and may fail + /// without these rights on certain platforms. For more information, see Process Security and Access Rights. + /// + /// + /// A pointer to a SECURITY_ATTRIBUTES structure that specifies a security descriptor for the new thread and determines + /// whether child processes can inherit the returned handle. If lpThreadAttributes is NULL, the thread gets a default + /// security descriptor and the handle cannot be inherited. The access control lists (ACL) in the default security descriptor + /// for a thread come from the primary token of the creator. + /// + /// + /// The initial size of the stack, in bytes. The system rounds this value to the nearest page. If this parameter is + /// 0 (zero), the new thread uses the default size for the executable. For more information, see Thread Stack Size. + /// + /// + /// A pointer to the application-defined function of type LPTHREAD_START_ROUTINE to be executed by the thread and + /// represents the starting address of the thread in the remote process. The function must exist in the remote process. + /// For more information, see ThreadProc. + /// + /// + /// A pointer to a variable to be passed to the thread function. + /// + /// + /// The flags that control the creation of the thread. + /// + /// + /// A pointer to a variable that receives the thread identifier. If this parameter is NULL, the thread identifier is + /// not returned. + /// + /// + /// If the function succeeds, the return value is a handle to the new thread. If the function fails, the return value + /// is NULL.To get extended error information, call GetLastError. Note that CreateRemoteThread may succeed even if + /// lpStartAddress points to data, code, or is not accessible. If the start address is invalid when the thread runs, + /// an exception occurs, and the thread terminates. Thread termination due to a invalid start address is handled as + /// an error exit for the thread's process. This behavior is similar to the asynchronous nature of CreateProcess, where + /// the process is created even if it refers to invalid or missing dynamic-link libraries (DLL). + /// + [DllImport("kernel32.dll")] + public static extern IntPtr CreateRemoteThread( + IntPtr hProcess, + IntPtr lpThreadAttributes, + uint dwStackSize, + IntPtr lpStartAddress, + IntPtr lpParameter, + uint dwCreationFlags, + IntPtr lpThreadId); + + /// + /// See https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandlew. + /// Retrieves a module handle for the specified module. The module must have been loaded by the calling process. To + /// avoid the race conditions described in the Remarks section, use the GetModuleHandleEx function. + /// + /// + /// The name of the loaded module (either a .dll or .exe file). If the file name extension is omitted, the default library + /// extension .dll is appended. The file name string can include a trailing point character (.) to indicate that the + /// module name has no extension. The string does not have to specify a path. When specifying a path, be sure to use + /// backslashes (\), not forward slashes (/). The name is compared (case independently) to the names of modules currently + /// mapped into the address space of the calling process. If this parameter is NULL, GetModuleHandle returns a handle + /// to the file used to create the calling process (.exe file). The GetModuleHandle function does not retrieve handles + /// for modules that were loaded using the LOAD_LIBRARY_AS_DATAFILE flag.For more information, see LoadLibraryEx. + /// + /// + /// If the function succeeds, the return value is a handle to the specified module. If the function fails, the return + /// value is NULL.To get extended error information, call GetLastError. + /// + [DllImport("kernel32.dll", CharSet = CharSet.Auto)] + public static extern IntPtr GetModuleHandle(string lpModuleName); + + /// + /// Retrieves the address of an exported function or variable from the specified dynamic-link library (DLL). + /// + /// + /// A handle to the DLL module that contains the function or variable. The LoadLibrary, LoadLibraryEx, LoadPackagedLibrary, + /// or GetModuleHandle function returns this handle. The GetProcAddress function does not retrieve addresses from modules + /// that were loaded using the LOAD_LIBRARY_AS_DATAFILE flag.For more information, see LoadLibraryEx. + /// + /// + /// The function or variable name, or the function's ordinal value. If this parameter is an ordinal value, it must be + /// in the low-order word; the high-order word must be zero. + /// + /// + /// If the function succeeds, the return value is the address of the exported function or variable. If the function + /// fails, the return value is NULL.To get extended error information, call GetLastError. + /// + [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)] + public static extern IntPtr GetProcAddress(IntPtr hModule, string procName); + + /// + /// See https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess. + /// Opens an existing local process object. + /// + /// + /// The access to the process object. This access right is checked against the security descriptor for the process. + /// This parameter can be one or more of the process access rights. If the caller has enabled the SeDebugPrivilege + /// privilege, the requested access is granted regardless of the contents of the security descriptor. + /// + /// + /// If this value is TRUE, processes created by this process will inherit the handle. Otherwise, the processes do + /// not inherit this handle. + /// + /// + /// The identifier of the local process to be opened. + /// + /// + /// If the function succeeds, the return value is an open handle to the specified process. If the function fails, the + /// return value is NULL.To get extended error information, call GetLastError. + /// + [DllImport("kernel32.dll", SetLastError = true)] + public static extern IntPtr OpenProcess( + ProcessAccessFlags processAccess, + bool bInheritHandle, + int processId); + + /// + /// See https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex. + /// Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. + /// The function initializes the memory it allocates to zero. To specify the NUMA node for the physical memory, see + /// VirtualAllocExNuma. + /// + /// + /// The handle to a process. The function allocates memory within the virtual address space of this process. The handle + /// must have the PROCESS_VM_OPERATION access right. For more information, see Process Security and Access Rights. + /// + /// + /// The pointer that specifies a desired starting address for the region of pages that you want to allocate. If you + /// are reserving memory, the function rounds this address down to the nearest multiple of the allocation granularity. + /// If you are committing memory that is already reserved, the function rounds this address down to the nearest page + /// boundary. To determine the size of a page and the allocation granularity on the host computer, use the GetSystemInfo + /// function. If lpAddress is NULL, the function determines where to allocate the region. If this address is within + /// an enclave that you have not initialized by calling InitializeEnclave, VirtualAllocEx allocates a page of zeros + /// for the enclave at that address. The page must be previously uncommitted, and will not be measured with the EEXTEND + /// instruction of the Intel Software Guard Extensions programming model. If the address in within an enclave that you + /// initialized, then the allocation operation fails with the ERROR_INVALID_ADDRESS error. + /// + /// + /// The size of the region of memory to allocate, in bytes. If lpAddress is NULL, the function rounds dwSize up to the + /// next page boundary. If lpAddress is not NULL, the function allocates all pages that contain one or more bytes in + /// the range from lpAddress to lpAddress+dwSize. This means, for example, that a 2-byte range that straddles a page + /// boundary causes the function to allocate both pages. + /// + /// + /// The type of memory allocation. This parameter must contain one of the MEM_* enum values. + /// + /// + /// The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify + /// any one of the memory protection constants. + /// + /// + /// If the function succeeds, the return value is the base address of the allocated region of pages. If the function + /// fails, the return value is NULL.To get extended error information, call GetLastError. + /// [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)] public static extern IntPtr VirtualAllocEx( IntPtr hProcess, @@ -82,34 +494,76 @@ namespace Dalamud.Injector AllocationType flAllocationType, MemoryProtection flProtect); + /// + /// See https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualfreeex. + /// Releases, decommits, or releases and decommits a region of memory within the virtual address space of a specified + /// process. + /// + /// + /// A handle to a process. The function frees memory within the virtual address space of the process. The handle must + /// have the PROCESS_VM_OPERATION access right.For more information, see Process Security and Access Rights. + /// + /// + /// A pointer to the starting address of the region of memory to be freed. If the dwFreeType parameter is MEM_RELEASE, + /// lpAddress must be the base address returned by the VirtualAllocEx function when the region is reserved. + /// + /// + /// The size of the region of memory to free, in bytes. If the dwFreeType parameter is MEM_RELEASE, dwSize must be 0 + /// (zero). The function frees the entire region that is reserved in the initial allocation call to VirtualAllocEx. + /// If dwFreeType is MEM_DECOMMIT, the function decommits all memory pages that contain one or more bytes in the range + /// from the lpAddress parameter to (lpAddress+dwSize). This means, for example, that a 2-byte region of memory that + /// straddles a page boundary causes both pages to be decommitted. If lpAddress is the base address returned by + /// VirtualAllocEx and dwSize is 0 (zero), the function decommits the entire region that is allocated by VirtualAllocEx. + /// After that, the entire region is in the reserved state. + /// + /// + /// The type of free operation. This parameter must be one of the MEM_* enum values. + /// + /// + /// If the function succeeds, the return value is a nonzero value. If the function fails, the return value is 0 (zero). + /// To get extended error information, call GetLastError. + /// + [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)] + public static extern bool VirtualFreeEx( + IntPtr hProcess, + IntPtr lpAddress, + int dwSize, + AllocationType dwFreeType); + + /// + /// Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or + /// the operation fails. + /// + /// + /// A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access + /// to the process. + /// + /// + /// A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the + /// system verifies that all data in the base address and memory of the specified size is accessible for write access, + /// and if it is not accessible, the function fails. + /// + /// + /// A pointer to the buffer that contains data to be written in the address space of the specified process. + /// + /// + /// The number of bytes to be written to the specified process. + /// + /// + /// A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter + /// is optional. If lpNumberOfBytesWritten is NULL, the parameter is ignored. + /// + /// + /// If the function succeeds, the return value is nonzero. If the function fails, the return value is 0 (zero). To get + /// extended error information, call GetLastError.The function fails if the requested write operation crosses into an + /// area of the process that is inaccessible. + /// [DllImport("kernel32.dll", SetLastError = true)] public static extern bool WriteProcessMemory( - IntPtr hProcess, - IntPtr lpBaseAddress, - byte[] lpBuffer, - int dwSize, - out IntPtr lpNumberOfBytesWritten); - - [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)] - public static extern IntPtr GetProcAddress(IntPtr hModule, string procName); - - [DllImport("kernel32.dll", CharSet = CharSet.Auto)] - public static extern IntPtr GetModuleHandle(string lpModuleName); - - [DllImport("kernel32.dll")] - public static extern IntPtr CreateRemoteThread( - IntPtr hProcess, - IntPtr lpThreadAttributes, - uint dwStackSize, - IntPtr lpStartAddress, - IntPtr lpParameter, - uint dwCreationFlags, - IntPtr lpThreadId); - - [DllImport("kernel32.dll", SetLastError = true)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [SuppressUnmanagedCodeSecurity] - [return: MarshalAs(UnmanagedType.Bool)] - public static extern bool CloseHandle(IntPtr hObject); + IntPtr hProcess, + IntPtr lpBaseAddress, + byte[] lpBuffer, + int dwSize, + out IntPtr lpNumberOfBytesWritten); } } diff --git a/Dalamud.Injector/Program.cs b/Dalamud.Injector/Program.cs index 040988955..74f3a1585 100644 --- a/Dalamud.Injector/Program.cs +++ b/Dalamud.Injector/Program.cs @@ -1,24 +1,27 @@ using System; -using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics; -using System.Drawing; using System.IO; -using System.Linq; using System.Runtime.InteropServices; using System.Text; using System.Threading; using System.Windows.Forms; + using EasyHook; using Newtonsoft.Json; -namespace Dalamud.Injector { - internal static class Program { - static private Process process = null; +namespace Dalamud.Injector +{ + /// + /// Application entrypoint. + /// + internal static class Program + { + private static Process process = null; - private static void Main(string[] args) { - - AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs eventArgs) + private static void Main(string[] args) + { + AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) => { File.WriteAllText("InjectorException.txt", eventArgs.ExceptionObject.ToString()); #if !DEBUG @@ -29,13 +32,14 @@ namespace Dalamud.Injector { Environment.Exit(0); }; - var pid = -1; - if (args.Length >= 1) { + if (args.Length >= 1) + { pid = int.Parse(args[0]); } - switch (pid) { + switch (pid) + { case -1: process = Process.GetProcessesByName("ffxiv_dx11")[0]; break; @@ -51,13 +55,16 @@ namespace Dalamud.Injector { } DalamudStartInfo startInfo; - if (args.Length <= 1) { + if (args.Length <= 1) + { startInfo = GetDefaultStartInfo(); Console.WriteLine("\nA Dalamud start info was not found in the program arguments. One has been generated for you."); Console.WriteLine("\nCopy the following contents into the program arguments:"); Console.WriteLine(); Console.WriteLine(Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(startInfo)))); - } else { + } + else + { startInfo = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(Convert.FromBase64String(args[1]))); } @@ -66,7 +73,7 @@ namespace Dalamud.Injector { // Seems to help with the STATUS_INTERNAL_ERROR condition Thread.Sleep(1000); - //Thread.Sleep(10000); + // Thread.Sleep(10000); // Inject to process Inject(process, startInfo); @@ -75,16 +82,18 @@ namespace Dalamud.Injector { #if DEBUG // Inject exception handler - //NativeInject(process); + // NativeInject(process); #endif } - private static void Inject(Process process, DalamudStartInfo info) { + private static void Inject(Process process, DalamudStartInfo info) + { Console.WriteLine($"Injecting to {process.Id}"); // File check var libPath = Path.GetFullPath("Dalamud.dll"); - if (!File.Exists(libPath)) { + if (!File.Exists(libPath)) + { Console.WriteLine($"Can't find a dll on {libPath}"); return; } @@ -104,12 +113,14 @@ namespace Dalamud.Injector { Console.WriteLine($"Injecting {libPath}..."); var handle = NativeFunctions.OpenProcess( - NativeFunctions.ProcessAccessFlags.All, + NativeFunctions.ProcessAccessFlags.AllAccess, false, process.Id); if (handle == IntPtr.Zero) + { throw new Win32Exception(Marshal.GetLastWin32Error(), "Could not OpenProcess"); + } var dllMem = NativeFunctions.VirtualAllocEx( handle, @@ -119,7 +130,9 @@ namespace Dalamud.Injector { NativeFunctions.MemoryProtection.ReadWrite); if (dllMem == IntPtr.Zero) + { throw new Win32Exception(Marshal.GetLastWin32Error(), $"Could not alloc memory {Marshal.GetLastWin32Error():X}"); + } Console.WriteLine($"dll path at {dllMem.ToInt64():X}"); @@ -128,9 +141,10 @@ namespace Dalamud.Injector { dllMem, pathBytes, len, - out var bytesWritten - )) + out var bytesWritten)) + { throw new Win32Exception(Marshal.GetLastWin32Error(), "Could not write DLL"); + } Console.WriteLine($"Wrote {bytesWritten}"); @@ -144,11 +158,12 @@ namespace Dalamud.Injector { loadLibA, dllMem, 0, - IntPtr.Zero - ); + IntPtr.Zero); if (remoteThread == IntPtr.Zero) + { throw new Win32Exception(Marshal.GetLastWin32Error(), $"Could not CreateRemoteThread"); + } /* TODO kill myself @@ -163,9 +178,11 @@ namespace Dalamud.Injector { NativeFunctions.CloseHandle(handle); } - private static DalamudStartInfo GetDefaultStartInfo() { + private static DalamudStartInfo GetDefaultStartInfo() + { var ffxivDir = Path.GetDirectoryName(process.MainModule.FileName); - var startInfo = new DalamudStartInfo { + var startInfo = new DalamudStartInfo + { WorkingDirectory = null, ConfigurationPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "XIVLauncher", "dalamudConfig.json"), PluginDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "XIVLauncher", "installedPlugins"), @@ -173,7 +190,7 @@ namespace Dalamud.Injector { AssetDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "XIVLauncher", "dalamudAssets"), GameVersion = File.ReadAllText(Path.Combine(ffxivDir, "ffxivgame.ver")), - Language = ClientLanguage.English + Language = ClientLanguage.English, }; Console.WriteLine("Creating a StartInfo with:\n" + diff --git a/Dalamud.Injector/stylecop.json b/Dalamud.Injector/stylecop.json new file mode 100644 index 000000000..6881efc6d --- /dev/null +++ b/Dalamud.Injector/stylecop.json @@ -0,0 +1,13 @@ +{ + "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json", + "settings": { + "orderingRules": { + "systemUsingDirectivesFirst": true, + "usingDirectivesPlacement": "outsideNamespace", + "blankLinesBetweenUsingGroups": "require" + }, + "maintainabilityRules": { + "topLevelTypes": [ "class", "interface", "struct", "enum" ] + } + } +}