Python ReadProcessMemory未读取足够字节

Question

好吧，各位ctypes的高手们……

我有一个Python脚本，它每秒读取一个内存地址一百次。这个内存地址存储的值是一个无符号整数，这个值会随着时间增加。不幸的是，当这个值超过2的8次方、2的16次方或2的24次方时，ReadProcessMemory这个函数读取的字节数就不够了，无法获取更大的整数。实际上，在第一次读取之后，它似乎就不再读取正确的字节数了。

这是代码片段：

from time import sleep
from ctypes import *
from struct import *
pid = 0x0D50
op = windll.kernel32.OpenProcess
rpm = windll.kernel32.ReadProcessMemory
ch = windll.kernel32.CloseHandle
PAA = 0x1F0FFF
addy = 0x38D53368
ph = op(PAA,False,int(pid)) #program handle
lastvalue = 0
while True:
   datadummy = b'.'*4
   buff = c_char_p(datadummy)
   bufferSize = (len(buff.value))
   bytesRead = c_ulong(0)

   if rpm(ph,addy,buff,bufferSize,byref(bytesRead)):
       value = unpack('I',datadummy)[0]
       if lastvalue != value:
           print value
           print bytesRead
           lastvalue = value
   sleep(.01)

而输出可能是这样的：

191
c_ulong(4L) ////Here it got 4 bytes like I expected
211
c_ulong(1L) ////But here it only got 1 byte.?? It should be reading 4 bytes everytime
231
c_ulong(1L) 
251
c_ulong(1L)
15           ////This value is incorrect, because it only reads 1 byte. (should be 271)
c_ulong(1L)

在我看来，它似乎只读取了上一次调用所需的字节数……

我该如何解决这个问题呢？

Answer 1

好的，我搞明白了。我需要用 ctypes.create_string_buffer(init_or_size[, size])，而不是我之前尝试的 c_char_p。

下面是可以正常工作的代码：

from time import sleep
from ctypes import *
from struct import *
pid = 0x0D50
op = windll.kernel32.OpenProcess
rpm = windll.kernel32.ReadProcessMemory
ch = windll.kernel32.CloseHandle
PAA = 0x1F0FFF
addy = 0x543A88F0
ph = op(PAA,False,int(pid)) #program handle
lastvalue = 0
while True:

   buff = create_string_buffer(4)
   bufferSize = (sizeof(buff))
   bytesRead = c_ulong(0)

   if rpm(ph,addy,buff,bufferSize,byref(bytesRead)):
       value = unpack('I',buff)[0]
       if lastvalue != value:
           print value
           print bytesRead
           lastvalue = value
   sleep(.01)

Answer 2

表达式 b'.'*4 在你的模块代码中创建了一个常量 '....'。这个常量在Python中和其他对象一样，不过它是应该是不可变的。你通过使用ctypes破坏了这个假设。例如：

>>> from ctypes import *
>>> def f():
...   s = b'.'*4
...   buf = c_char_p(s)
...   memset(buf, 0, 1)
... 
>>> f.__code__.co_consts
(None, '.', 4, 0, 1, '....')
>>> c_char_p(f.__code__.co_consts[5]).value
'....'

>>> f() # set the first character to "\x00"
>>> f.__code__.co_consts
(None, '.', 4, 0, 1, '\x00...')
>>> c_char_p(f.__code__.co_consts[5]).value
''

c_char_p 的 value 描述符期望缓冲区是一个以空字符结尾的字符串。当第一个字节变成0时，value 返回一个空字符串。现在看看191以小端格式打包成的 unsigned long：

>>> import struct
>>> struct.pack("<L", 191)
'\xbf\x00\x00\x00'

这应该能解释为什么 bufferSize 在第二次运行时变成了1。

如果这个字符串被存储在内存中，你可能会让解释器崩溃或者让它变得无法使用。大多数在CPython API中使用的字符串都是存储在内存中的，模块、类、函数、属性和变量的名称也是如此。例如：

>>> from ctypes import *
>>> import numbers
>>> s = 'numbers'
>>> b = c_char_p(s)
>>> r = memset(b, 100, 1)
>>> s
'dumbers'

>>> numbers.Number
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'numbers' is not defined

>>> globals()[s].Number
<class 'numbers.Number'>

---

create_string_buffer 是一个方便的函数，可以一次性创建并设置一个 char 数组：

>>> b1 = create_string_buffer('test1')
>>> type(b1)
<class 'ctypes.c_char_Array_6'>
>>> b1.value
'test1'

>>> b2 = (c_char * 6)()
>>> b2.value = 'test2'
>>> type(b2)
<class 'ctypes.c_char_Array_6'>
>>> b2.value
'test2'
>>> b2.raw
'test2\x00'

你也可以传递一个 unsigned long 的引用：

value = c_ulong() 
bytesRead = c_ulong()
rpm(ph, addy, byref(value), sizeof(value), byref(bytesRead))

---

另一个违反不可变性假设的例子。小于256的整数是被缓存的，也就是说，使用它们的代码总是指向同一组对象。所以如果你改变了其中一个，它会影响整个系统：

>>> offset = sizeof(c_size_t)*2
>>> addr = id(200) + offset
>>> n = c_int.from_address(addr)
>>> n
c_long(200)
>>> n.value = 2000000
>>> 
>>> 200 + 1
2000001