3

我在这里找到了一段很好的代码,它使用 API 调用执行 ASM 指令以获得 CPU 的序列号:

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    class Program
    {
        [DllImport("user32", EntryPoint = "CallWindowProcW", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]         private static extern IntPtr ExecuteNativeCode([In] byte[] bytes, IntPtr hWnd, int msg, [In, Out] byte[] wParam, IntPtr lParam);

        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]         public static extern bool VirtualProtect([In] byte[] bytes, IntPtr size, int newProtect, out int oldProtect);

        const int PAGE_EXECUTE_READWRITE = 0x40;

        static void Main(string[] args)
        {
            string s = CPU32_SerialNumber();
            Console.WriteLine("CPU Serial-Number: " + s);
            Console.ReadLine();
        }

        private static string CPU32_SerialNumber()
        {
            byte[] sn = new byte[12];

            if (!ExecuteCode32(ref sn))
                return "ND";

            return string.Format("{0}{1}{2}", BitConverter.ToUInt32(sn, 0).ToString("X"), BitConverter.ToUInt32(sn, 4).ToString("X"), BitConverter.ToUInt32(sn, 8).ToString("X"));
        }

        private static bool ExecuteCode32(ref byte[] result)
        {
            // CPU 32bit SerialNumber -> asm x86 from c# (c) 2003-2011 Cantelmo Software
            // 55               PUSH EBP
            // 8BEC             MOV EBP,ESP
            // 8B7D 10          MOV EDI,DWORD PTR SS:[EBP+10]
            // 6A 02            PUSH 2
            // 58               POP EAX
            // 0FA2             CPUID
            // 891F             MOV DWORD PTR DS:[EDI],EBX
            // 894F 04          MOV DWORD PTR DS:[EDI+4],ECX
            // 8957 08          MOV DWORD PTR DS:[EDI+8],EDX
            // 8BE5             MOV ESP,EBP
            // 5D               POP EBP
            // C2 1000          RETN 10

            int num;

            byte[] code_32bit = new byte[] { 0x55, 0x8b, 0xec, 0x8b, 0x7d, 0x10, 0x6a, 2, 0x58, 15, 0xa2, 0x89, 0x1f, 0x89, 0x4f, 4, 0x89, 0x57, 8, 0x8b, 0xe5, 0x5d, 0xc2, 0x10, 0 };
            IntPtr ptr = new IntPtr(code_32bit.Length);

            if (!VirtualProtect(code_32bit, ptr, PAGE_EXECUTE_READWRITE, out num))
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

            ptr = new IntPtr(result.Length);

            return (ExecuteNativeCode(code_32bit, IntPtr.Zero, 0, result, ptr) != IntPtr.Zero);
        }
    }
}

我测试了它,它对我来说工作正常。但我仍然有一些与之相关的疑问和问题:

1)我想在可以在 x86 和 x64 环境中运行的应用程序中实现此代码。如果我将此代码运行到 64x 环境中,我会收到 AccessViolationException。代码的作者说,这可以很容易地实现,还可以实现一个包含 x64 指令(RAX、RBX、RCX、RDX ......)的字节码数组。我的问题是我完全不知道如何将 86x 字节码转换为 x64 字节码,事实上我什至不知道 ASM。是否有任何转换表或实用程序可以做到这一点?

2) 这个代码片段对任何类型的处理器都有效吗?我在使用英特尔内核的笔记本电脑上对其进行了测试,它可以工作……但是例如 AMD 呢?

3) 我不确定我获得的值是否正确。如果我运行以下代码:

string cpuInfo = String.Empty;

System.Management.ManagementClass mc = new System.Management.ManagementClass("Win32_Processor");
System.Management.ManagementObjectCollection moc = mc.GetInstances();

foreach (System.Management.ManagementObject mo in moc)
{
    if (cpuInfo == String.Empty)
        cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
}

我得到的结果是“BFEBFBFF000306A9”。代码片段的结果是“F0B2FF0CA0000”。为什么?哪一个是正确的?

4

2 回答 2

23

这是修改后的代码,以在 x64x86上获得与Win32_Processor.ProcessorId相同的结果:

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
    class Program
    {
        [DllImport("user32", EntryPoint = "CallWindowProcW", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]         private static extern IntPtr CallWindowProcW([In] byte[] bytes, IntPtr hWnd, int msg, [In, Out] byte[] wParam, IntPtr lParam);

        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]         public static extern bool VirtualProtect([In] byte[] bytes, IntPtr size, int newProtect, out int oldProtect);

        const int PAGE_EXECUTE_READWRITE = 0x40;

        static void Main(string[] args)
        {
            string s = ProcessorId();
            Console.WriteLine("ProcessorId: " + s);
            Console.ReadLine();
        }

        private static string ProcessorId()
        {
            byte[] sn = new byte[8];

            if (!ExecuteCode(ref sn))
                return "ND";

            return string.Format("{0}{1}", BitConverter.ToUInt32(sn, 4).ToString("X8"), BitConverter.ToUInt32(sn, 0).ToString("X8"));
        }

        private static bool ExecuteCode(ref byte[] result)
        {
            int num;

            /* The opcodes below implement a C function with the signature:
             * __stdcall CpuIdWindowProc(hWnd, Msg, wParam, lParam);
             * with wParam interpreted as a pointer pointing to an 8 byte unsigned character buffer.
             * */

            byte[] code_x86 = new byte[] {
                0x55,                      /* push ebp */
                0x89, 0xe5,                /* mov  ebp, esp */
                0x57,                      /* push edi */
                0x8b, 0x7d, 0x10,          /* mov  edi, [ebp+0x10] */
                0x6a, 0x01,                /* push 0x1 */
                0x58,                      /* pop  eax */
                0x53,                      /* push ebx */
                0x0f, 0xa2,                /* cpuid    */
                0x89, 0x07,                /* mov  [edi], eax */
                0x89, 0x57, 0x04,          /* mov  [edi+0x4], edx */
                0x5b,                      /* pop  ebx */
                0x5f,                      /* pop  edi */
                0x89, 0xec,                /* mov  esp, ebp */
                0x5d,                      /* pop  ebp */
                0xc2, 0x10, 0x00,          /* ret  0x10 */
            };
            byte[] code_x64 = new byte[] {
                0x53,                                     /* push rbx */
                0x48, 0xc7, 0xc0, 0x01, 0x00, 0x00, 0x00, /* mov rax, 0x1 */
                0x0f, 0xa2,                               /* cpuid */
                0x41, 0x89, 0x00,                         /* mov [r8], eax */
                0x41, 0x89, 0x50, 0x04,                   /* mov [r8+0x4], edx */
                0x5b,                                     /* pop rbx */
                0xc3,                                     /* ret */
            };

            ref byte[] code;

            if (IsX64Process())
                code = ref code_x64;
            else 
                code = ref code_x86;

            IntPtr ptr = new IntPtr(code.Length);

            if (!VirtualProtect(code, ptr, PAGE_EXECUTE_READWRITE, out num))
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

            ptr = new IntPtr(result.Length);

            return (CallWindowProcW(code, IntPtr.Zero, 0, result, ptr) != IntPtr.Zero);
        }

        private static bool IsX64Process() 
        {
            return IntPtr.Size == 8;
        }
    }
}

我在没有编译代码的情况下对 C# 部分进行了简单的修改(我目前没有 Windows 开发机器设置),所以如果有语法错误,请进行明显的修复。

我想强调一个非常重要的一点:您的原始代码读回的不是CPU 序列号

  • 您使用了 CPUID 函数 2(通过在执行CPUID指令之前将 2 放在EAX中)。如果您阅读IntelAMD CPUID 应用说明,您会发现这会读回缓存和 TLB 硬件配置,并且仅在 Intel 上受支持。
  • 我修改了您的代码以使用 CPUID 函数 1,它读回 CPU 的步进、型号和系列。这与WIN32_Processor.ProcessorID的行为匹配
  • 现代 x86 CPU 的序列号在“下线”的相同单元中没有唯一的序列号。处理器序列号只能通过 CPUID 函数 3 在 Pentium 3 上获得。

我现在将解释我使用的过程和工具。

将操作码数组粘贴到 Python 脚本中,然后将操作码写入二进制文件 ( cpuid-x86.bin ):

cpuid_opcodes = [ 0x55, 0x8b, 0xec, 0x8b, ... ]
open('cpuid-x86.bin', 'w').write(''.join(chr(x) for x in cpuid_opcodes))

反汇编cpuid-x86.bin。我使用了来自udis86的udcli

$ udcli -att cpuid-x86.bin
0000000000000000 55               push %ebp               
0000000000000001 8bec             mov %esp, %ebp          
0000000000000003 8b7d10           mov 0x10(%ebp), %edi    
0000000000000006 6a02             push $0x2                
0000000000000008 58               pop %eax                
0000000000000009 0fa2             cpuid                   
000000000000000b 891f             mov %ebx, (%edi)        
000000000000000d 894f04           mov %ecx, 0x4(%edi)     
0000000000000010 895708           mov %edx, 0x8(%edi)     
0000000000000013 8be5             mov %ebp, %esp          
0000000000000015 5d               pop %ebp                
0000000000000016 c21000           ret $0x10 

立即突出的一件事是为什么使用“ push $0x2; pop %eax ”将值 2 移动到EAX中,而简单的“ mov $0x2, %eax ”就可以了?

我的猜测是“ push $0x2 ”的指令编码6a02更容易以十六进制形式修改。手动和编程方式。我猜有人试图使用 CPUID 函数 3 来获取处理器序列号,发现它不受支持,然后切换到使用函数 2。

最后的“ ret $0x10 ”也很不寻常。RET指令的RET IMM16形式返回给调用者,然后将IMM16字节从堆栈中弹出。被调用者负责在函数返回后从堆栈中弹出参数这一事实意味着这没有使用标准的 x86 调用约定。

事实上,快速浏览一下 C# 代码就会发现它正在使用CallWindowProc()来调用汇编函数。CallWindowProc()的文档显示汇编代码正在实现一个具有如下签名的 C 函数:

__stdcall CpuIdWindowProc(hWnd, Msg, wParam, lParam);

__stdcall是 32 位 Windows API 使用的特殊函数调用约定。

汇编代码使用函数的第三个参数0x10(%ebp)作为字符数组来存储CPUID指令的输出。(在 x86 上的标准函数序言之后,8(%ebp)是第一个参数。0xc(%ebp)是第二个 4 字节参数,0x10(%ebp)是第三个)我们的窗口过程函数原型中的第三个参数以上是wParam。它用作输出参数,并且是汇编代码中使用的唯一参数。

关于汇编代码的最后一个有趣的事情是它破坏了寄存器EDIEBX而不保存它们,这违反了__stdcall调用约定。通过CallWindowProc()调用该函数时,此错误显然是潜在的,但如果您尝试在 C 中编写自己的 main 函数来测试汇编代码 ( cpuid-main.c ),就会显示出来:

#include <stdio.h>
#include <stdint.h>

void __stdcall cpuid_wind_proc(uint32_t hWnd, uint32_t msg, uint8_t *wparam, uint32_t lparam);

enum {
    RESULT_SIZE = 2 * 4, /* Two 32-bit registers: EAX, EDX */
};

static unsigned int form_word_le(uint8_t a[])
{
    return (a[3] << 24) | (a[2] << 16) | (a[1] << 8) | a[0];
}

int main()
{
    uint8_t r[RESULT_SIZE];
    memset(r, 0, sizeof(r));

    cpuid_wind_proc(0, 0, r, 0);

    printf("%08x%08x\n",  form_word_le(r + 4), form_word_le(r));
    return 0;
}

固定保存和恢复EDIEBX和使用CPUID函数 1 的程序集版本是这样的:

    .section .text
    .global _cpuid_wind_proc@16
_cpuid_wind_proc@16:
    push %ebp
    mov %esp, %ebp
    push %edi
    mov 16(%ebp), %edi
    push $1
    pop %eax
    push %ebx
    cpuid
    mov %eax, (%edi)
    mov %edx, 0x4(%edi)
    pop %ebx
    pop %edi
    mov %ebp, %esp
    pop %ebp
    ret $16

符号名称_cpuid_wind_proc@16__stdcall函数名称在 32 位 Windows 上的错位方式。@16是参数占用的字节数。(4 个参数在 32 位 Windows 上各占 4 个字节,加起来为 16)

现在我准备将代码移植到 x64。

  • 通过查阅这个方便的 ABI 表,我看到前四个参数在RCXRDXR8R9中传递,因此wParamR8中。
  • 英特尔文档告诉我CPUID指令破坏了EAXEBXECXEDXEBX是RBX的下半部分,它是ABI 中保存的GPR(“保存的 GPR”在这里是指一个通用寄存器,应该在函数调用中保留其内容)所以我确保在执行CPUID指令之前保存RBX并恢复RBX之后。

这是 x64 程序集:

    .section .text
    .global cpuid_wind_proc
cpuid_wind_proc:
    push %rbx
    mov $1, %rax
    cpuid
    movl %eax, (%r8)
    movl %edx, 4(%r8)
    pop %rbx
    ret

如您所见,x64 版本更短且更易于编写。x64 上只有一个函数调用约定,所以我们不必担心__stdcall

与cpuid-main.c一起构建 x64 汇编函数,并将其输出与此 VBScript ( cpuid.vbs ) 进行比较:

Set objProc = GetObject("winmgmts:root\cimv2:Win32_Processor='cpu0'")
WScript.echo objProc.ProcessorId

运行cpuid.vbs _

wscript cpuid.vbs

并验证输出是否匹配。(实际上,我在 Linux 上使用 MinGW-w64 进行交叉编译,并在 Wine64 仿真下运行程序,同时进行 C 和汇编工作,直到这一点。)

随着 x64 程序集 CPUID 函数的工作,我现在准备将代码集成回 C#。

  • 反汇编cpuid-x64.exe以获取操作码并将它们粘贴为新的字节数组(code_x64)。
  • 更改ExecuteCode()以通过在IsX64Process()中测试IntPtr.Size == 8来确定是运行 x86 还是 x64 版本的 CPUID 代码。

最后,更改ProcessorId()以生成十六进制字符串:

string.Format("{0}{1}", BitConverter.ToUInt32(sn, 4).ToString("X8"), BitConverter.ToUInt32(sn, 0).ToString("X8"));

使用“X8”而不是“X”可确保 UInt32 被格式化为 8 位十六进制值,填充为零。否则,当您将它们连接成一个字符串时,您无法分辨哪些数字来自EDX,哪些来自EAX 。

就是这样。

于 2013-05-10T17:12:36.273 回答
0

您发布的代码似乎调用了CPUID函数#2(由EAX寄存器给出,在 之后PUSH 2; POP EAX)。根据不是用于查询序列号的intel指令集参考:

当 CPUID 在 EAX 设置为 2 的情况下执行时,处理器会在 EAX、EBX、ECX 和 EDX 寄存器中返回有关处理器内部 TLB、缓存和预取硬件的信息。

另请注意,此功能在 AMD 处理器上不可用,但代码仍应无错误地执行。

于 2013-05-09T21:33:42.097 回答