Change SafeProcessHandle to IntPtr again, ugh

Dalamud.Bootstrap/OS/ProcessException.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace Dalamud.Bootstrap
+{
+    public class ProcessException : BootstrapException
+    {
+        internal ProcessException() : base() { }
+
+        internal ProcessException(string message) : base(message) { }
+
+        internal ProcessException(string message, Exception innerException) : base(message, innerException) { }
+
+        internal static void ThrowLastOsError()
+        {
+            var inner = new Win32Exception();
+
+            throw new ProcessException(inner.Message, inner);
+        }
+    }
+}

Dalamud.Bootstrap/OS/Windows/Process.cs

@@ -0,0 +1,215 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using Dalamud.Bootstrap.OS.Windows.Raw;
+using Microsoft.Win32.SafeHandles;
+
+namespace Dalamud.Bootstrap.OS.Windows
+{
+    /// <summary>
+    /// Provides a thin wrapper around process API.
+    /// </summary>
+    internal sealed class Process : IDisposable
+    {
+        /// <summary>
+        /// A process handle that can be passed to PInvoke. Note that it should never outlive a process object.
+        /// This handle will be disposed when the process object is disposed.
+        /// </summary>
+        public IntPtr Handle { get; private set; }
+
+        public Process(IntPtr handle)
+        {
+            Handle = handle;
+        }
+
+        public void Dispose()
+        {
+            if (Handle != IntPtr.Zero)
+            {
+                Kernel32.CloseHandle(Handle);
+            }
+
+            Handle = IntPtr.Zero;
+        }
+
+        /// <summary>
+        /// Reads process memory.
+        /// </summary>
+        /// <returns>
+        /// A number of bytes that is actually read.
+        /// </returns>
+        /// <exception cref="ProcessException">
+        /// Thrown when failed to read memory. 
+        /// </exception>
+        public int ReadMemory(IntPtr address, Span<byte> destination)
+        {
+            unsafe
+            {
+                fixed (byte* pDest = destination)
+                {
+                    if (!Kernel32.ReadProcessMemory(Handle, address, pDest, (IntPtr)destination.Length, out var bytesRead))
+                    {
+                        ProcessException.ThrowLastOsError();
+                    }
+
+                    // This is okay because destination will never be longer than int.Max
+                    return bytesRead.ToInt32();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads the exact number of bytes required to fill the buffer.
+        /// </summary>
+        /// <exception cref="ProcessException">
+        /// Thrown when failed to read memory. 
+        /// </exception>
+        public void ReadMemoryExact(IntPtr address, Span<byte> destination)
+        {
+            var totalBytesRead = 0;
+
+            while (totalBytesRead < destination.Length)
+            {
+                var bytesRead = ReadMemory(address + totalBytesRead, destination[totalBytesRead..]);
+
+                if (bytesRead == 0)
+                {
+                    // prolly page fault; there's not much we can do here
+                    var readBeginAddr = address.ToInt64() + totalBytesRead;
+                    var readEndAddr = address.ToInt64() + destination.Length;
+
+                    ProcessException.ThrowLastOsError();
+                }
+
+                totalBytesRead += bytesRead;
+            }
+        }
+
+
+        /// <exception cref="ProcessException">
+        /// Thrown when failed to read memory. 
+        /// </exception>
+        public byte[] ReadMemoryExact(IntPtr address, int length)
+        {
+            var buffer = new byte[length];
+            ReadMemoryExact(address, buffer);
+
+            return buffer;
+        }
+
+
+        /// <exception cref="ProcessException">
+        /// Thrown when failed to read memory. 
+        /// </exception>
+        public void ReadMemoryExact<T>(IntPtr address, ref T value) where T : unmanaged
+        {
+            var span = MemoryMarshal.CreateSpan(ref value, 1); // span should never leave this function since it has unbounded lifetime.
+            var buffer = MemoryMarshal.AsBytes(span);
+
+            ReadMemoryExact(address, buffer);
+        }
+
+
+        private IntPtr GetPebAddress()
+        {
+            unsafe
+            {
+                PROCESS_BASIC_INFORMATION info = default;
+
+                var status = Ntdll.NtQueryInformationProcess(Handle, PROCESSINFOCLASS.ProcessBasicInformation, &info, sizeof(PROCESS_BASIC_INFORMATION), (IntPtr*)IntPtr.Zero);
+
+                if (!status.Success)
+                {
+                    throw new ProcessException($"Could not query information on process. (Status: {status})");
+                }
+
+                return info.PebBaseAddress;
+            }
+        }
+
+        /// <summary>
+        /// Reads command-line arguments from the process.
+        /// </summary>
+        public string[] GetProcessArguments()
+        {
+            PEB peb = default;
+            RTL_USER_PROCESS_PARAMETERS procParam = default;
+
+            // Find where the command line is allocated
+            var pebAddr = GetPebAddress();
+            ReadMemoryExact(pebAddr, ref peb);
+            ReadMemoryExact(peb.ProcessParameters, ref procParam);
+
+            // Read the command line (which is utf16-like string)
+            var commandLine = ReadMemoryExact(procParam.CommandLine.Buffer, procParam.CommandLine.Length);
+
+            return ParseCommandLineToArguments(commandLine);
+        }
+
+        /// <summary>
+        /// Returns a time when the process was started.
+        /// </summary>
+        public DateTime GetCreationTime()
+        {
+            if (!Kernel32.GetProcessTimes(Handle, out var creationTime, out var _, out var _, out var _))
+            {
+                ProcessException.ThrowLastOsError();
+            }
+
+            return creationTime.ToDateTime();
+        }
+
+        private string[] ParseCommandLineToArguments(ReadOnlySpan<byte> commandLine)
+        {
+            unsafe
+            {
+                char** argv;
+                int argc;
+
+                fixed (byte* pCommandLine = commandLine)
+                {
+                    argv = Shell32.CommandLineToArgvW(pCommandLine, out argc);
+                }
+
+                if (argv == null)
+                {
+                    ProcessException.ThrowLastOsError();
+                }
+
+                // NOTE: argv must be deallocated via LocalFree when we're done
+                try
+                {
+                    var arguments = new string[argc];
+
+                    for (var i = 0; i < argc; i++)
+                    {
+                        arguments[i] = new string(argv[i]);
+                    }
+
+                    return arguments;
+                }
+                finally
+                {
+                    Kernel32.LocalFree(argv);
+                }
+            }
+        }
+
+        public string GetImageFilePath()
+        {
+            var buffer = new StringBuilder(300);
+
+            // From docs:
+            // On input, specifies the size of the lpExeName buffer, in characters.
+            // On success, receives the number of characters written to the buffer, not including the null-terminating character.
+            var size = buffer.Capacity;
+
+            if (!Kernel32.QueryFullProcessImageNameW(Handle, 0, buffer, ref size))
+            {
+                ProcessException.ThrowLastOsError();
+            }
+
+            return buffer.ToString();
+        }
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Advapi32.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.InteropServices;
 
 namespace Dalamud.Bootstrap.OS.Windows.Raw
@@ -12,5 +13,11 @@ namespace Dalamud.Bootstrap.OS.Windows.Raw
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi)]
         public static extern uint SetEntriesInAclA(ulong cCountOfExplicitEntries, ref ACL oldAcl, out ACL* NewAcl);
+        
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, ExactSpelling = true, CharSet = CharSet.Unicode)]
+        public static extern void BuildExplicitAccessWithNameW(out EXPLICIT_ACCESS_W pExplicitAccess, string pTrusteeName, uint AccessPermissions, ACCESS_MODE AccessMode, uint Inheritance);
+        
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi)]
+        public static extern uint GetSecurityInfo(IntPtr handle, SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo);
     }
 }

Dalamud.Bootstrap/OS/Windows/Raw/Constants.cs

@@ -66,4 +66,62 @@ namespace Dalamud.Bootstrap.OS.Windows.Raw
         SE_SACL_PROTECTED = 0x2000,
         SE_SELF_RELATIVE = 0x8000,
     }
+
+    internal enum ACCESS_MODE : uint
+    {
+        NOT_USED_ACCESS,
+        GRANT_ACCESS,
+        SET_ACCESS,
+        DENY_ACCESS,
+        REVOKE_ACCESS,
+        SET_AUDIT_SUCCESS,
+        SET_AUDIT_FAILURE,
+    }
+
+    internal enum MULTIPLE_TRUSTEE_OPERATION : uint
+    {
+        NO_MULTIPLE_TRUSTEE,
+        TRUSTEE_IS_IMPERSONATE,
+    }
+
+    internal enum TRUSTEE_FORM : uint
+    {
+        TRUSTEE_IS_SID,
+        TRUSTEE_IS_NAME,
+        TRUSTEE_BAD_FORM,
+        TRUSTEE_IS_OBJECTS_AND_SID,
+        TRUSTEE_IS_OBJECTS_AND_NAME,
+    }
+
+    internal enum TRUSTEE_TYPE : uint
+    {
+        TRUSTEE_IS_UNKNOWN,
+        TRUSTEE_IS_USER,
+        TRUSTEE_IS_GROUP,
+        TRUSTEE_IS_DOMAIN,
+        TRUSTEE_IS_ALIAS,
+        TRUSTEE_IS_WELL_KNOWN_GROUP,
+        TRUSTEE_IS_DELETED,
+        TRUSTEE_IS_INVALID,
+        TRUSTEE_IS_COMPUTER,
+    }
+
+    internal enum SE_OBJECT_TYPE : uint
+    {
+
+        SE_UNKNOWN_OBJECT_TYPE,
+        SE_FILE_OBJECT,
+        SE_SERVICE,
+        SE_PRINTER,
+        SE_REGISTRY_KEY,
+        SE_LMSHARE,
+        SE_KERNEL_OBJECT,
+        SE_WINDOW_OBJECT,
+        SE_DS_OBJECT,
+        SE_DS_OBJECT_ALL,
+        SE_PROVIDER_DEFINED_OBJECT,
+        SE_WMIGUID_OBJECT,
+        SE_REGISTRY_WOW64_32KEY,
+        SE_REGISTRY_WOW64_64KEY
+    }
 }

Dalamud.Bootstrap/OS/Windows/Raw/Kernel32.cs

@@ -1,4 +1,3 @@
-using Microsoft.Win32.SafeHandles;
 using System;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -10,33 +9,33 @@ namespace Dalamud.Bootstrap.OS.Windows.Raw
         private const string Name = "kernel32";
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
-        public static extern SafeProcessHandle OpenProcess(uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwProcessId);
+        public static extern IntPtr OpenProcess(uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwProcessId);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool TerminateProcess(SafeProcessHandle hProcess, int uExitCode);
+        public static extern bool TerminateProcess(IntPtr hProcess, int uExitCode);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool ReadProcessMemory(SafeProcessHandle hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesRead);
+        public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesRead);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool WriteProcessMemory(SafeProcessHandle hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesWritten);
+        public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesWritten);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
         public static extern void* LocalFree(void* hMem);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi)]
-        public static extern uint GetProcessId(SafeProcessHandle hProcess);
+        public static extern uint GetProcessId(IntPtr hProcess);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool GetProcessTimes(SafeProcessHandle hProcess, out FILETIME lpCreationTime, out FILETIME lpExitTime, out FILETIME lpKernelTime, out FILETIME lpUserTime);
+        public static extern bool GetProcessTimes(IntPtr hProcess, out FILETIME lpCreationTime, out FILETIME lpExitTime, out FILETIME lpKernelTime, out FILETIME lpUserTime);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool QueryFullProcessImageNameW(SafeProcessHandle hProcess, uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpExeName, ref int lpdwSize);
+        public static extern bool QueryFullProcessImageNameW(IntPtr hProcess, uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpExeName, ref int lpdwSize);
 
         [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
         [return: MarshalAs(UnmanagedType.Bool)]

Dalamud.Bootstrap/OS/Windows/Raw/Structures.cs

@@ -131,14 +131,23 @@ namespace Dalamud.Bootstrap.OS.Windows.Raw
         public IntPtr Dacl;
     }
 
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct EXPLICIT_ACCESS_A
+    [StructLayout(LayoutKind.Explicit)]
+    internal unsafe struct TRUSTEE_W
+    {
+        public TRUSTEE_W* pMultipleTrustee;
+        public MULTIPLE_TRUSTEE_OPERATION MULTIPLE_TRUSTEE_OPERATION;
+        public TRUSTEE_FORM TrusteeForm;
+        public TRUSTEE_TYPE TrusteeType;
+        public void* ptstrName;
+    }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct EXPLICIT_ACCESS_W
     {
-        // TODO
         uint grfAccessPermissions;
         ACCESS_MODE grfAccessMode;
         uint grfInheritance;
-        TRUSTEE_A Trustee;
+        TRUSTEE_W Trustee;
     }
 
     [StructLayout(LayoutKind.Sequential)]

Dalamud.Bootstrap/OS/Windows/RelaxedProcessHandle.cs

@@ -0,0 +1,36 @@
+using System;
+using Dalamud.Bootstrap.OS.Windows.Raw;
+using Microsoft.Win32.SafeHandles;
+
+namespace Dalamud.Bootstrap.Windows
+{
+    internal sealed class RelaxedProcessHandle : IDisposable
+    {
+        private SafeProcessHandle m_handle;
+
+        private RelaxedProcessHandle(SafeProcessHandle handle)
+        {
+            m_handle = handle;
+        }
+
+        public void Dispose()
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="handle"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        public static RelaxedProcessHandle Create(SafeProcessHandle handle, PROCESS_ACCESS_RIGHTS access)
+        {
+            
+
+            return new RelaxedProcessHandle(handle);
+        }
+    }
+}