把C语言代码 转成易语言

jojo44165592

不会英文，是编程的路上一大障碍，麻烦前辈们, 看能否转成易语言！

第一段：

  

#region IP Proxy
await Task.Run ()=>{while (crossfire.MainWindowHandle ==IntPtr.Zero): 1):
Socket to= new Socket (SocketType.Stream, ProtocolType. Tcp):
to. Bind (new IPEndPoint (IPAddress. Parse ("127.0.0.1"), 13008)):to.Listen (0):
Socket cli = null:
await Task.Run (O=>cli = to.Accept ():
Socket from= new Socket (SocketType. Stream, ProtocolType.Tcp):from.Connect (gameSrv, 13008):

#region IP Proxy<br /> await Task.Run()=>{while (crossfire.MainWindowHandle ==IntPtr.Zero): 1):<br /> Socket to= new Socket(SocketType.Stream, ProtocolType. Tcp):<br /> to. Bind (new IPEndPoint (IPAddress. Parse ("127.0.0.1"), 13008)):to.Listen(0):<br /> Socket cli = null:<br /> await Task.Run(O=>cli = to.Accept():<br /> Socket from= new Socket(SocketType. Stream, ProtocolType.Tcp):from.Connect(gameSrv, 13008):

第二段：
public static void Login(Process process, string user, string password)Process crossfire = Process. GetProcessesByName ("crossfire")[0]:
IntPtr cshell = crossfire. GetModuleAddress ("cshell. dll"):
Console. WriteLine (S"cshell. dll: {cshell. ToString("x2")}"):
IntPtr hProcess = OpenProcess(0x1FOFFF, false, crossfire.Id):
IntPtr base_pass = IntPtr.Zero:
ReadProcessMemory (hProcess, IntPtr.Add(cshell,0x01CA4B18), (IntPtr) (&base_pass),4, IntPtr.Zero):ReadProcessMemory(hProcess, IntPtr.Add (base_pass,0x08), (IntPtr)(&base_pass),4, IntPtr.Zero):base_pass = IntPtr. Add (base_pass,0x17C):
byte[] buffer_pass = Encoding.Default. GetBytes(password):
WriteProcessMemory (hProcess, base_pass, buffer_pass, buffer_pass. Length, IntPtr.Zero):
IntPtr base_acc = IntPtr.Zero:
ReadProcessMemory (hProcess, IntPtr.Add(cshell, 0x01CA4B18), (IntPtr)(&base_acc),4, IntPtr.Zero):ReadProcessMemory (hProcess, IntPtr. Add (base_acc,0x04), (IntPtr)(&base_acc),4, IntPtr.Zero):base_acc = IntPtr. Add (base_acc, 0x17C):
byte[] buffer_user =Encoding.Default.GetBytes (user):
WriteProcessMemory (hProcess, base_acc, buffer_user, buffer_user. Length, IntPtr. Zero):
CloseHandle (hProcess) :
SendMessage (crossfire.MainWindowHandle,0x0102,0x09,0x001C0001):
SendMessage(crossfire.MainWindowHandle, 0x0102, 0x0D, 0x001C0001):


  后学，感激不尽！

玩世不恭KISS

.版本 2
.程序集 窗口程序集_启动窗口
.程序集变量 游戏句柄, 整数型
.程序集变量 本地服务器, 服务器
.程序集变量 目标服务器, 客户Duan

.子程序 __启动窗口_创建完毕

启动线程(&初始化代理, , )

.子程序 初始化代理

.判断循环首 (游戏句柄 ＝ 0)
    程序_延时 (1000)
    游戏句柄 ＝ 窗口_取句柄 (, , "CrossFire", )
.判断循环尾 ()

本地服务器.创建 (13008, "127.0.0.1")
本地服务器.开始监听 ()

.子程序 _本地服务器_客户进入
.参数 客户地址, 文本型
.局部变量 客户Duan, 整数型

客户Duan ＝ 目标服务器.连接 (“gameSrv”, 13008)
.如果真 (客户Duan ≠ 0)
    启动线程(&数据转发, 客户Duan, )
.如果真结束

.子程序 数据转发
.参数 目标端口, 整数型

.局部变量 本地数据, 字节集
.局部变量 远程数据, 字节集

.判断循环首 (真)
    .如果真 (本地服务器.取回数据 (本地数据))
        目标服务器.发送数据 (本地数据, 目标端口)
    .如果真结束
   
    .如果真 (目标服务器.取回数据 (远程数据, 目标端口))
        本地服务器.发送数据 (远程数据)
    .如果真结束
   
    程序_延时 (10)
.判断循环尾

玩世不恭KISS

.版本 2
.程序集 窗口程序集_启动窗口
.DLL命令 OpenProcess, 整数型, "kernel32.dll", "OpenProcess"
    .参数 dwDesiredAccess, 整数型
    .参数 bInheritHandle, 逻辑型
    .参数 dwProcessId, 整数型

.DLL命令 ReadProcessMemory, 逻辑型, "kernel32.dll", "ReadProcessMemory"
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 整数型
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesRead, 整数型

.DLL命令 WriteProcessMemory, 逻辑型, "kernel32.dll", "WriteProcessMemory"
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 字节集
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesWritten, 整数型

.DLL命令 CloseHandle, 逻辑型, "kernel32.dll", "CloseHandle"
    .参数 hObject, 整数型

.DLL命令 SendMessage, 整数型, "user32.dll", "SendMessageA"
    .参数 hWnd, 整数型
    .参数 Msg, 整数型
    .参数 wParam, 整数型
    .参数 lParam, 整数型

.子程序 _按钮_登录_被单击
.局部变量 进程列表, 进程信息, , "0"
.局部变量 hProcess, 整数型
.局部变量 cshell地址, 整数型
.局部变量 jz_pass, 整数型
.局部变量 jz_acc, 整数型
.局部变量 缓冲区_pass, 字节集
.局部变量 缓冲区_user, 字节集

进程_枚举(进程列表)
.计次循环首 (取数组成员数(进程列表), i)
    .如果真 (进程列表[i].进程名称 ＝ "crossfire.exe")
        cshell地址 ＝ 进程_取模块句柄(进程列表[i].进程ID, "cshell.dll")
        hProcess ＝ OpenProcess(2035711, 假, 进程列表[i].进程ID)  ' 0x1F0FFF
        
        ' 处理密码地址
        ReadProcessMemory(hProcess, cshell地址 ＋ 0x01CA4B18, 取变量地址(jz_pass), 4, 0)
        ReadProcessMemory(hProcess, jz_pass ＋ 0x08, 取变量地址(jz_pass), 4, 0)
        jz_pass ＝ jz_pass ＋ 0x17C
        
        ' 写入密码
        缓冲区_pass ＝ 到字节集(编辑框_密码.内容)
        WriteProcessMemory(hProcess, jz_pass, 缓冲区_pass, 取字节集长度(缓冲区_pass), 0)
        
        ' 处理账号地址
        ReadProcessMemory(hProcess, cshell地址 ＋ 0x01CA4B18, 取变量地址(jz_acc), 4, 0)
        ReadProcessMemory(hProcess, jz_acc ＋ 0x04, 取变量地址(jz_acc), 4, 0)
        jz_acc ＝ jz_acc ＋ 0x17C
        
        ' 写入账号
        缓冲区_user ＝ 到字节集(编辑框_账号.内容)
        WriteProcessMemory(hProcess, jz_acc, 缓冲区_user, 取字节集长度(缓冲区_user), 0)
        
        ' 发送按键消息
        SendMessage(进程列表[i].窗口句柄, 258, 9, 0x001C0001)  ' WM_CHAR=0x0102
        SendMessage(进程列表[i].窗口句柄, 258, 13, 0x001C0001)
        
        CloseHandle(hProcess)
        跳出循环
    .如果真结束
.计次循环尾

wangood

.版本 2

.程序集 窗口程序集_启动窗口
.程序集引用 "System.Net.Sockets"

.子程序 _启动窗口_创建完毕
.局部变量 本地Socket, 目标Socket, 客户DuanSocket, 数据包, 目标IP, 本地IP, 端口号, 目标端口
.局部变量 游戏服务器IP, 游戏服务器端口

本地IP ＝ "127.0.0.1"
端口号 ＝ 13008
游戏服务器IP ＝ "192.168.1.100"  '假设目标服务器的IP是这个
游戏服务器端口 ＝ 13008

' 创建本地Socket
本地Socket ＝ 创建Socket(2, 1)  ' 参数2表示流套接字，1表示TCP协议
如果 (本地Socket ＝ 空)  ' 如果创建失败
    输出调试文本("创建Socket失败")
    返回
结束

' 绑定本地IP和端口
如果 (本地Socket.绑定(本地IP, 端口号) ＝ 假)
    输出调试文本("绑定端口失败")
    返回
结束

' 开始监听
本地Socket.监听(10)

' 循环接收客户Duan连接
循环
    客户DuanSocket ＝ 本地Socket.接收连接()
    如果 (客户DuanSocket ＝ 空)
        输出调试文本("客户Duan连接失败")
        继续
    结束

    ' 创建目标Socket连接到游戏服务器
    目标Socket ＝ 创建Socket(2, 1)  ' 参数2表示流套接字，1表示TCP协议
    如果 (目标Socket ＝ 空)
        输出调试文本("创建目标Socket失败")
        继续
    结束
   
    如果 (目标Socket.连接(游戏服务器IP, 游戏服务器端口) ＝ 假)
        输出调试文本("连接到游戏服务器失败")
        继续
    结束

    ' 创建数据包来转发数据
    数据包 ＝ 创建数据包()

    ' 启动线程进行数据转发
    开始线程 (转发数据, 客户DuanSocket, 目标Socket)
结束

.子程序 转发数据, 客户DuanSocket, 目标Socket
.局部变量 数据, 接收数据, 发送数据
.局部变量 接收字节数

' 客户Duan到目标服务器的数据转发
循环
    接收数据 ＝ 客户DuanSocket.接收(1024)  ' 每次接收1024字节
    如果 (接收数据 ＝ 空)
        返回
    结束
    目标Socket.发送(接收数据)
   
    接收数据 ＝ 目标Socket.接收(1024)
    如果 (接收数据 ＝ 空)
        返回
    结束
    客户DuanSocket.发送(接收数据)
结束


第二段：
.版本 2

.程序集 窗口程序集_启动窗口
.程序集引用 "System.Diagnostics"
.程序集引用 "System.Text"
.程序集引用 "System.Runtime.InteropServices"

.外部声明 "kernel32.dll" 函数 OpenProcess (整型 dwDesiredAccess, 逻辑 bInheritHandle, 整型 dwProcessId) 作为 "OpenProcess"
.外部声明 "kernel32.dll" 函数 ReadProcessMemory (整型 hProcess, 整型 lpBaseAddress, 整型 lpBuffer, 整型 nSize, 整型 lpNumberOfBytesRead) 作为 "ReadProcessMemory"
.外部声明 "kernel32.dll" 函数 WriteProcessMemory (整型 hProcess, 整型 lpBaseAddress, 整型 lpBuffer, 整型 nSize, 整型 lpNumberOfBytesWritten) 作为 "WriteProcessMemory"
.外部声明 "kernel32.dll" 函数 CloseHandle (整型 hObject) 作为 "CloseHandle"
.外部声明 "user32.dll" 函数 SendMessage (整型 hWnd, 整型 Msg, 整型 wParam, 整型 lParam) 作为 "SendMessage"

.子程序 登录, 整型 进程ID, 文本 用户名, 文本 密码
.局部变量 进程句柄, cshell地址, base_pass, base_acc, 缓存, 用户缓存, 密码缓存
.局部变量 cshell偏移, base_pass偏移, base_acc偏移

' 获取进程句柄
进程句柄 ＝ OpenProcess(0x1F0FFF, 假, 进程ID)
如果 进程句柄 ＝ 0
    输出调试文本("无法打开进程")
    返回
结束

' 获取 cshell.dll jz
cshell偏移 ＝ 0x01CA4B18
cshell地址 ＝ 读取内存地址(进程句柄, cshell偏移)

' 获取密码字段地址
base_pass偏移 ＝ 0x08
base_pass ＝ 读取内存地址(进程句柄, cshell地址 + base_pass偏移)
base_pass ＝ base_pass + 0x17C

' 将密码写入进程内存
密码缓存 ＝ 编码.默认.获取字节(密码)
写入内存(进程句柄, base_pass, 密码缓存)

' 获取账号字段地址
base_acc偏移 ＝ 0x04
base_acc ＝ 读取内存地址(进程句柄, cshell地址 + base_acc偏移)
base_acc ＝ base_acc + 0x17C

' 将用户名写入进程内存
用户缓存 ＝ 编码.默认.获取字节(用户名)
写入内存(进程句柄, base_acc, 用户缓存)

' 关闭进程句柄
CloseHandle(进程句柄)

' 模拟按键事件，发送登录消息
发送按键消息(进程ID, 0x09) ' 按键：Tab
发送按键消息(进程ID, 0x0D) ' 按键：Enter
返回

.子程序 读取内存地址, 整型 进程句柄, 整型 地址
.局部变量 读取数据, 字节数组
.局部变量 数据, 整型

读取数据 ＝ 新建字节数组(4)
ReadProcessMemory(进程句柄, 地址, 读取数据, 4, 数据)
返回 读取数据[0] + (读取数据[1] * 256) + (读取数据[2] * 65536) + (读取数据[3] * 16777216)

.子程序 写入内存, 整型 进程句柄, 整型 地址, 字节数组 数据
.局部变量 已写入字节数
WriteProcessMemory(进程句柄, 地址, 数据, 数据.长度, 已写入字节数)

.子程序 发送按键消息, 整型 进程ID, 整型 按键值
.局部变量 主窗口句柄
主窗口句柄 ＝ 获取窗口句柄(进程ID)
SendMessage(主窗口句柄, 0x0102, 按键值, 0x001C0001)

.子程序 获取窗口句柄, 整型 进程ID
.局部变量 进程列表, 进程数组
.局部变量 进程

进程列表 ＝ 获取进程列表()
进程 ＝ 获取指定进程(进程列表, 进程ID)
返回 进程.MainWindowHandle

Dayy

这个是什么原理？先编译再反编译吗

hongqingfeng

.版本 2
.程序集 主程序
.程序集变量 crossfire, 整数型

.子程序 IP代理
.局部变量 套接字, 整数型
.局部变量 客户Duan, 整数型
.局部变量 游戏服务器套接字, 整数型

' 创建TCP套接字
套接字 ＝ 创建套接字(2, 1, 6)
绑定(套接字, 127, 0, 0, 1, 13008)
监听(套接字, 0)

.判断循环首 (crossfire.主窗口句柄 ＝ 0)
    程序_延时(100)
.判断循环尾

.循环判断首 ()
    客户Duan ＝ 接受连接(套接字)
    .如果真 (客户Duan ≠ -1)
        游戏服务器套接字 ＝ 创建套接字(2, 1, 6)
        连接(游戏服务器套接字, "游戏服务器IP", 13008)
        ' 此处需要添加数据转发线程
    .如果真结束
.循环判断尾 (真)

.子程序 登录
.参数 process, 整数型
.参数 用户名, 文本型
.参数 密码, 文本型
.局部变量 hProcess, 整数型
.局部变量 cshell地址, 整数型
.局部变量 基地址, 整数型
.局部变量 缓冲, 字节集

crossfire ＝ 取进程ID("crossfire.exe")
cshell地址 ＝ 取模块地址(crossfire, "cshell.dll")
输出调试文本("cshell.dll 地址：" ＋ 取十六进制文本(cshell地址))

hProcess ＝ OpenProcess(2035711, 假, crossfire)

' 读取密码基地址
ReadProcessMemory(hProcess, cshell地址 ＋ 十六进制("01CA4B18"), 基地址, 4, 0)
ReadProcessMemory(hProcess, 基地址 ＋ 8, 基地址, 4, 0)
基地址 ＝ 基地址 ＋ 十六进制("17C")

' 写入密码
缓冲 ＝ 到字节集(密码)
WriteProcessMemory(hProcess, 基地址, 缓冲, 取字节集长度(缓冲), 0)

' 读取账号基地址
ReadProcessMemory(hProcess, cshell地址 ＋ 十六进制("01CA4B18"), 基地址, 4, 0)
ReadProcessMemory(hProcess, 基地址 ＋ 4, 基地址, 4, 0)
基地址 ＝ 基地址 ＋ 十六进制("17C")

' 写入账号
缓冲 ＝ 到字节集(用户名)
WriteProcessMemory(hProcess, 基地址, 缓冲, 取字节集长度(缓冲), 0)

CloseHandle(hProcess)
发送消息(crossfire.主窗口句柄, 258, 9, 1835137)
发送消息(crossfire.主窗口句柄, 258, 13, 1835137)

.DLL命令 OpenProcess, 整数型, "kernel32.dll",  "OpenProcess"
    .参数 dwDesiredAccess, 整数型
    .参数 bInheritHandle, 逻辑型
    .参数 dwProcessId, 整数型

.DLL命令 ReadProcessMemory, 逻辑型, "kernel32.dll",  "ReadProcessMemory"
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 整数型
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesRead, 整数型

.DLL命令 WriteProcessMemory, 逻辑型, "kernel32.dll",  "WriteProcessMemory"
    .参数 hProcess, 整数型
    .参数 lpBaseAddress, 整数型
    .参数 lpBuffer, 字节集
    .参数 nSize, 整数型
    .参数 lpNumberOfBytesWritten, 整数型

.DLL命令 CloseHandle, 逻辑型, "kernel32.dll",  "CloseHandle"
    .参数 hObject, 整数型

boxxie

多谢楼上几位回复哟

jojo44165592

感谢几位前辈们的回复和支持，这两天有事，现在才上来！