如何使用python转换CE脚本

gzh888666

[ENABLE]
alloc(g_Thread,10)
createthread(g_Thread)

g_Thread:
pushad

mov ecx,[729670]
mov ecx,[ecx+868]
push -1
push 2
mov eax,1
push 1
push ecx
call 0040FA10

popad
retn
[DISABLE]
这段CE脚本可以实现自动种植樱桃炸弹到指定的行列，
请教一下如何使用python完成相同的功能
目前我的代码无法实现自动种植，必须要用鼠标点击一下才行，
python不知道如何实现内存线程的处理,请大佬们指点迷津。
my_ctypes.py
def WriteProcess_CE(
        handle, offset, data
):  #例子my_ctypes.WriteProcess(process_handle,0X00729670,"83 46 40 FC")
    list_data = data.split(' ')
    z = ctypes.c_int()
    for i in range(len(list_data)):
        z.value = eval('0x' + list_data[i])
        ctypes.windll.kernel32.WriteProcessMemory(handle, offset + i,
                                                  ctypes.byref(z), 1, None)


def CE_10to16(num):  #整数47 返回字符串'2F'
    return str(hex(num))[-2:]


main.py
my_ctypes.WriteProcess_CE(process_handle, 0x00413452,
                               "E9 B5 A4 2B 00 ....")
        my_ctypes.WriteProcess_CE(process_handle, 0x006CD90C,
                               "B8 " + my_ctypes.CE_10to16(ID) +
                               " 00 00 00 52 50 E9 3F 5B D4 FF ......")

FishC

要使用Python实现相同的功能，你需要使用一些库来访问和修改进程内存，并创建线程。下面是一个可能的解决方案：

1. 首先，你需要安装pywin32库和ctypes库。你可以使用以下命令在命令行中安装它们：

1. pip install pywin32
2. pip install ctypes

复制代码

2. 在你的`my_ctypes.py`文件中，为了能够正确导入ctypes库，你需要添加以下行：

1. import ctypes

复制代码

3. 创建一个新的Python文件，比如`main.py`。在最上面，添加以下导入语句：

1. import ctypes
2. import win32api
3. import win32con
4. import time

复制代码

4. 在`main.py`中，创建一个函数`seed_bomb`来实现自动种植樱桃炸弹：

1. def seed_bomb(process_handle, row, column):
2.     # 分配内存并创建线程
3.     g_thread_addr = ctypes.c_int()
4.     ctypes.windll.kernel32.VirtualAllocEx(
5.         process_handle, None, 1000,
6.         win32con.MEM_COMMIT | win32con.MEM_RESERVE, win32con.PAGE_EXECUTE_READWRITE)
7.     ctypes.windll.kernel32.CreateRemoteThread(
8.         process_handle, None, 0, g_thread_addr, 0, 0, 0)
10.     # 将指令写入内存中
11.     instructions = [
12.         "pushad",
13.         "mov ecx, " + str(row),
14.         "mov ecx, " + str(column),
15.         "push -1",
16.         "push 2",
17.         "mov eax, 1",
18.         "push 1",
19.         "push ecx",
20.         "call 0040FA10",
21.         "popad",
22.         "retn"
23.     ]
24.     offset = g_thread_addr.value
25.     for instruction in instructions:
26.         my_ctypes.WriteProcess_CE(process_handle, offset, instruction)
27.         offset += len(instruction) + 1
29. # 使用示例
30. process_handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, False, process_id)
31. seed_bomb(process_handle, 5, 3)

复制代码

请注意，这只是一个示例代码，我无法确切知道你的程序的内存地址和其他细节。你需要根据你的具体情况进行调整和修改。还要确保你已经正确获取了进程的句柄。你可以使用`win32api`来打开进程并获得句柄。

希望这能帮助到你！请记得测试和调试你的代码，并随时向我咨询如果有任何问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

gzh888666

# 将指令写入内存中
    instructions = [
        "pushad",
        "mov ecx, " + str(row),
        "mov ecx, " + str(column),
        "push -1",
        "push 2",
        "mov eax, 1",
        "push 1",
        "push ecx",
        "call 0040FA10",
        "popad",
        "retn"
    ] 汇编代码如何嵌入python代码中运行

FishC

gzh888666 发表于 2023-12-10 11:51
# 将指令写入内存中
    instructions =  汇编代码如 ...

要在Python代码中嵌入汇编代码并执行，你可以使用ctypes库的`create_string_buffer`函数来创建一个缓冲区，并将汇编指令作为字符串赋值给缓冲区。然后，你可以使用ctypes库的`cdll`方法加载kernel32.dll，并调用其中的`CreateThread`函数来创建一个新线程并执行汇编指令。

下面是一个示例代码：

1. import ctypes
3. # 定义汇编指令
4. instructions = "mov eax, 10\n" \
5.               "add eax, 20\n" \
6.               "sub eax, 5\n" \
7.               "ret\n"
9. # 创建缓冲区并将汇编指令写入缓冲区
10. buffer = ctypes.create_string_buffer(instructions.encode())
12. # 加载kernel32.dll
13. kernel32 = ctypes.cdll.kernel32
15. # 定义函数类型
16. ThreadProc = ctypes.CFUNCTYPE(ctypes.c_int)
18. # 定义线程函数
19. @ThreadProc
20. def thread_func():
21.     asm_code = buffer.raw  # 获取缓冲区的原始二进制数据
22.     code_size = len(asm_code)
23.     thread_handle = kernel32.GetCurrentThread()
24.     kernel32.VirtualProtect(thread_handle, ctypes.byref(buffer), code_size, 0x40)
25.     function = ctypes.cast(asm_code, ctypes.POINTER(ThreadProc)).contents
26.     return function()
28. # 创建新线程
29. thread_id = ctypes.c_ulong()
30. thread_handle = kernel32.CreateThread(None, 0, thread_func, None, 0, ctypes.byref(thread_id))
32. # 等待线程结束
33. kernel32.WaitForSingleObject(thread_handle, -1)
35. # 关闭线程句柄
36. kernel32.CloseHandle(thread_handle)

复制代码

请注意，你需要将要执行的汇编指令以字符串形式定义在`instructions`变量中，并根据实际情况进行调整。在上面的示例中，我使用了一些简单的指令来演示。

这只是一个示例代码，具体实现需要根据你的需求进行调整和修改。同时要注意，在使用汇编指令时，需要对内存进行正确的保护和权限设置，以避免潜在的错误。

希望这可以帮助到你！如果你有任何问题，请随时向我咨询。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

gzh888666

1. import ctypes
   
2. import sys
   
3. import win32con
   
4. import time
   
5. 
   
6. window_handle = ctypes.windll.user32.FindWindowW(
   
7.             None, "Plants vs. Zombies")
   
8.         #ctypes.windll.user32.SetForegroundWindow(window_handle) #窗体置顶
   
9. PROCESS_ALL_ACCESS = (0x000F0000 | 0x00100000 | 0xFFF)
   
10. process_id = ctypes.c_ulong()
    
11. ctypes.windll.user32.GetWindowThreadProcessId(window_handle,
    
12.                                                       ctypes.byref(process_id))
    
13. process_handle = ctypes.windll.kernel32.OpenProcess(
    
14.             PROCESS_ALL_ACCESS, False, process_id)
    
15. # 定义汇编指令
    
16. instructions = "pushad\n"
    
17. instructions = "mov ecx,[729670]\n"
    
18. instructions += "mov ecx,[ecx+868]\n"
    
19. instructions += "push -1\n"
    
20. instructions += "push 2\n"
    
21. instructions += "mov eax,1\n"
    
22. instructions += "push 1\n"
    
23. instructions += "push ecx\n"
    
24. instructions += "call 0040FA10\n"
    
25. instructions += "popad\n"
    
26. instructions += "retn"
    
27. 
    
28. # 创建缓冲区并将汇编指令写入缓冲区
    
29. buffer = ctypes.create_string_buffer(instructions.encode())
    
30. # 加载kernel32.dll
    
31. kernel32 = ctypes.cdll.kernel32
    
32. # 定义函数类型
    
33. ThreadProc = ctypes.CFUNCTYPE(ctypes.c_int)
    
34. # 定义线程函数
    
35. @ThreadProc
    
36. def thread_func():
    
37.     asm_code = buffer.raw  # 获取缓冲区的原始二进制数据
    
38.     code_size = len(asm_code)
    
39.     thread_handle = kernel32.GetCurrentThread()
    
40.     kernel32.VirtualProtect(thread_handle, ctypes.byref(buffer), code_size, 0x40)
    
41.     function = ctypes.cast(asm_code, ctypes.POINTER(ThreadProc)).contents
    
42.     return function()
    
43. # 创建新线程
    
44. thread_id = ctypes.c_ulong()
    
45. thread_handle = kernel32.CreateThread(process_handle, 0, thread_func, None, 0, ctypes.byref(thread_id))
    
46. # 等待线程结束
    
47. kernel32.WaitForSingleObject(thread_handle, -1)
    
48. # 关闭线程句柄
    
49. kernel32.CloseHandle(thread_handle)

复制代码

执行后没有任何效果，请看看哪里有错误

FishC

gzh888666 发表于 2023-12-10 12:25
import ctypes
import sys
import win32con
import ...

在你提供的代码中，发现有几个错误和问题需要解决：

1. 在定义汇编指令时，你需要传递正确的参数给`mov`指令。根据你提供的CE脚本，可能是两个寄存器之间的移动操作，类似于`mov ecx, eax`。请确保正确设置这两个寄存器。

2. 在创建缓冲区的代码中，你的`instructions`字符串中加了一个多余的`\n`。需要将这行去掉。

3. 在创建新线程时，你传递了错误的参数给`kernel32.CreateThread`函数。第一个参数应该是NULL或0，第三个参数应该是远程线程的起始地址，而不是进程句柄。你可以尝试修改为以下代码：

1. thread_handle = kernel32.CreateThread(None, 0, thread_func, None, 0, ctypes.byref(thread_id))

复制代码

4. 最后，你没有关闭进程句柄。请添加以下代码以关闭进程句柄：

1. kernel32.CloseHandle(process_handle)

复制代码

请注意，这只是对你提供的代码进行的一些修正，我无法确切知道你的程序的内存地址和其他细节。你需要根据你的具体情况进行调整和修改。希望这次能够帮助到你！如果还有其他问题，请随时向我咨询。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。