将IntPtr转换为int

本文关键字:int 转换 IntPtr | 更新日期: 2023-09-27 18:04:25

我正在动态调用Windows API。我在网上找到了一些可以做到这一点的代码,我对此非常感兴趣。至少可以说,这个主意本身是绝妙的。然而,我似乎不能使它为我的代码工作。动态调用的参数类型为string, string, int[],我想使用API GetThreadContext,参数为pInfo.hThredref ctx(如下所示)。

API调用

GetThreadContext(pInfo.hThread, ref ctx);

上面的代码将调用GetThreadContext API(假设它是在我的项目中声明的)-并且工作得很好。然而,动态调用的美妙之处在于不需要声明。所以,我尝试动态调用:

ctx = new CONTEXT {ContextFlags = 0x10007};
PROCESS_INFORMATION pInfo;
CInvokeAPI.Invoke("kernel32","GetThreadContext",pInfo.hThread, ctx);

这里的问题是,我不知道如何将参数ctx作为int类型传递,因为它是一个结构体。

请参见下面的附加代码

    [StructLayout(LayoutKind.Sequential)]
    struct CONTEXT
    {
        public uint ContextFlags;
        unsafe fixed byte unused[160];
        public uint Ebx;
        public uint Edx;
        public uint Ecx;
        public uint Eax;
        unsafe fixed byte unused2[24];
    }
    [StructLayout(LayoutKind.Sequential)]
    struct PROCESS_INFORMATION
    {
        public IntPtr hProcess;
        public IntPtr hThread;
        public int dwProcessId;
        public int dwThreadId;
    }

动态调用API类

using System;
using System.Runtime.InteropServices;
using System.Text;
/* 
 * Title: CInvokeAPI.cs
 * Description: Call API by name implementation in purely managed C# (no 'unsafe' mess here).
 * 
 * Developed by: affixiate 
 * Comments: If you use this code, I require you to give me credits. 
 */
public static class CInvokeAPI
{
    /// <summary>
    /// Generates a new, non-garbage collectable string in memory. Use this with Unicode "W" API.
    /// </summary>
    /// <param name="theString">A Unicode string.</param>
    /// <returns>Address of newly allocated string in memory. Remember to free it after use.</returns>
    public static int StringToPtrW(string theString)
    {
        return StringToPtr(Encoding.Unicode.GetBytes(theString));
    }
    /// <summary>
    /// Generates a new, non-garbage collectable string in memory. Use this with ANSI "A" API.
    /// </summary>
    /// <param name="theString">An ANSII string.</param>
    /// <returns>Address of newly allocated string in memory. Remember to free it after use.</returns>
    public static int StringToPtrA(string theString)
    {
        return StringToPtr(Encoding.ASCII.GetBytes(theString));
    }
    /// <summary>
    /// Internal method used to allocate memory.
    /// </summary>
    /// <param name="buf">A byte buffer.</param>
    /// <returns>Address of newly allocated memory. Remember to free it after use.</returns>
    private static int StringToPtr(byte[] buf)
    {
        return (int)GCHandle.Alloc(buf, GCHandleType.Pinned).AddrOfPinnedObject();
    }
    /// <summary>
    /// Invokes the specified Windows API.
    /// </summary>
    /// <param name="libraryName">Name of the library.</param>
    /// <param name="functionName">Name of the function.</param>
    /// <param name="args">The arguments.</param>
    /// <returns>True if function succeeds, otherwise false.</returns>
    public static bool Invoke(string libraryName, string functionName, params int[] args)
    {
        /* Sanity checks. */
        IntPtr hLoadLibrary = LoadLibrary(libraryName);
        if (hLoadLibrary == IntPtr.Zero) return false;
        IntPtr hGetProcAddress = GetProcAddress(hLoadLibrary, functionName);
        if (hGetProcAddress == IntPtr.Zero) return false;
        // Allocates more than enough  memory for an stdcall and the parameters of a WinAPI function
        IntPtr hMemory = VirtualAlloc(IntPtr.Zero, 1024 * 1024, MEM_COMMIT | MEM_RESERVE, MEM_EXECUTE_READWRITE);
        if (hMemory == IntPtr.Zero)
            return false;
        IntPtr hMemoryItr = hMemory;
        // Prepends the stdcall header signature
        Marshal.Copy(new byte[] {0x55, 0x89, 0xE5}, 0, hMemoryItr, 0x3);
        hMemoryItr = (IntPtr)((int)hMemoryItr + 0x3);
        // Loop through the passed in arguments and place them on the stack in reverse order
        for (int i = (args.Length - 1); i >= 0; i--) 
        {
            Marshal.Copy(new byte[] {0x68}, 0, hMemoryItr, 0x1); 
            hMemoryItr = (IntPtr)((int)hMemoryItr + 0x1);
            Marshal.Copy(BitConverter.GetBytes(args[i]), 0, hMemoryItr, 0x4);
            hMemoryItr = (IntPtr)((int)hMemoryItr + 0x4);
        }
        Marshal.Copy(new byte[] {0xE8}, 0, hMemoryItr, 0x1);
        hMemoryItr = (IntPtr)((int)hMemoryItr + 0x1);
        Marshal.Copy(BitConverter.GetBytes((int)hGetProcAddress - (int)hMemoryItr - 0x4), 0, hMemoryItr, 0x4);
        hMemoryItr = (IntPtr)((int)hMemoryItr + 0x4);
        // Cleaning up the stack
        Marshal.Copy(new byte[] {0x5D, 0xC2, 0x4, 0x0 /* <= I made a LOL. */}, 0, hMemoryItr, 0x4);
        // Don't forget to increment if you are adding more ASM code here: hMemoryItr = (IntPtr)((int)hMemoryItr + 0x4);
        try
        {
            var executeAsm = (RunAsm) Marshal.GetDelegateForFunctionPointer(hMemory, typeof (RunAsm));
            executeAsm();
        }
        catch { return false; }
        // Clean up the memory we allocated to do the dirty work
        VirtualFree(hMemory, 0, MEM_RELEASE);
        return true;
    }
    // ReSharper disable InconsistentNaming
    private const uint MEM_RELEASE = 0x8000;
    private const uint MEM_COMMIT = 0x1000;
    private const uint MEM_RESERVE = 0x2000;
    private const uint MEM_EXECUTE_READWRITE = 0x40;
    // ReSharper restore InconsistentNaming
    // My own sexy delegate:
    [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
    private delegate void RunAsm();
    // WinAPI used:
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool VirtualFree(IntPtr lpAddress, UInt32 dwSize, uint dwFreeType);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr VirtualAlloc(IntPtr lpAddress, UInt32 dwSize, uint flAllocationType, uint flProtect);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr LoadLibrary(string lpFileName);
    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Ansi)]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
}

将IntPtr转换为int

可以使用IntPtr。ToInt32方法?这应该对第一个参数有效。不确定的结构转换,但

关于如何将结构体转换为整数,可以看看这篇文章。

更新:

c#中没有VarPtr的直接等效,但我确实在这里找到了一个参考手册(以及它正在做什么的解释…听起来类似于本文中对VarPtr的解释)。这是代码的摘录。它可能对你有用:

public static int VarPtr(object e)
{
    GCHandle GC = GCHandle.Alloc(e, GCHandleType.Pinned);
    int gc = GC.AddrOfPinnedObject().ToInt32();
    GC.Free();
    return gc;
}

注意:这个函数有一些潜在的缺陷,正如这篇文章中提到的。