Question

我发现了一段很好的代码here，它使用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”。为什么？哪一个是正确的？

Answer 1

此处修改了您的代码，以便在x64 和 x86上获得与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开发机器）所以如果有语法错误，请立即解决。

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

您使用了CPUID功能2（在执行 CPUID 指令之前将2放在 EAX 中）。如果您阅读Intel和AMD CPUID应用程序说明，您将看到这会回读缓存和TLB硬件配置，并且仅在Intel上支持。
我修改了你的代码以使用CPUID函数1，它读回CPU的步进，模型和系列。这符合WIN32_Processor.ProcessorID
现代x86 CPU没有一个序列号，这个序列号在其他相同的单元中是唯一的＃34;滚下装配线＆＃34;。处理器序列号仅在Pentium 3上通过CPUID功能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

立即脱颖而出的一件事就是使用＆＃34; 推送$ 0x2; pop％eax ＆＃34;当一个简单的＆＃34; mov $ 0x2，％eax ＆＃34;时，将值2移动到 EAX ;会吗？

我的猜测是＆＃34; 推送$ 0x2 ＆＃34;， 6a02 的指令编码更容易以十六进制形式进行修改。手动和编程。我猜某个地方有人试图使用CPUID功能3获取处理器序列号，发现它不支持然后切换到使用功能2.

＆＃34; ret $ 0x10 ＆＃34;最后也很不寻常。 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 。它用作out参数，是汇编代码中使用的唯一参数。

关于汇编代码的最后一个有趣的事情是它破坏了寄存器 EDI 和 EBX 而没有保存它们，违反了 __ 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; }

修复以保存和恢复 EDI ， EBX 并使用 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 是32位Windows上 __ stdcall 函数名称被破坏的方式。 @ 16 是参数占用的字节数。（四个参数，每个在32位Windows上占用四个字节，总计16个）

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

通过咨询this handy ABI table，我看到前四个参数在 RCX ， RDX ， R8 和 R9 所以 wParam 位于 R8 。
英特尔文档告诉我 CPUID 指令符号 EAX ， EBX ， ECX 和 EDX 即可。 EBX 是 RBX 的下半部分，它是ABI中已保存的GPR （＆＃34;已保存的GPR＆＃34;这里表示一般目的寄存器应该在函数调用中保留其内容）所以我确保在执行 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 。

构建x64汇编函数以及 cpuid-main.c ，并将其输出与此VBScript（ cpuid.vbs ）进行比较：

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

使用

运行 cpuid.vbs

wscript cpuid.vbs

并验证输出是否匹配。（我实际上在Linux上与MinGW-w64交叉编译，并在执行C和汇编工作的同时在Wine64仿真下运行程序。）

随着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"));

使用＆＃34; X8＆＃34; 而不仅仅是＆＃34; X＆＃34; 可确保将UInt32格式化为8位十六进制值，零填充。否则，您无法判断哪些数字来自 EDX ，哪些数字来自 EAX ，当您将它们连接成一个字符串时。

就是这样。

Answer 2

您发布的代码似乎在CPUID之后调用EAX函数＃2（由PUSH 2; POP EAX寄存器给出。根据不用于查询序列号的intel指令集引用：

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

另请注意，此功能在AMD处理器上不可用，但代码应该可以正确执行。

内联汇编代码以获取CPU ID

2 个答案: