如果直接取出套接字

nj20346 · 发表于 2025-4-1 18:05:01

现在的情况是，需要有数据流通才能取到套接字，
我想要的效果是hook后直接取到套接字，然后发一条数据就可以了

子程序名	返回值类型	公开	备注
StartHook
参数名	类型	参考	可空	数组	备注
进程ID	整数型

变量名	类型	静态	数组	备注
地址	整数型

进程句柄＝进程_打开进程 (进程ID)

如果真 (进程句柄 ≤ 0)

信息框 (“指定程序不存在或无法拦截!”, 0, “错误:”, )

返回 ()

地址＝系统_取API地址 (“send”)
hook_Send.开始 (进程句柄, 十到十六 (地址), &Send接口, Send_返回, 5, 2, )
地址＝系统_取API地址 (“WSASend”)
hook_WSASend.开始 (进程句柄, 十到十六 (地址), &WSASend接口, WSASend_返回, 5, 2, )
' 地址＝系统_取API地址 (“recv”)
' hook_recv.开始 (进程句柄, 十到十六 (地址), &recv接口, recv_返回, 5, 2, )
' 地址＝系统_取API地址 (“WSARecv”)
' hook_WSARecv.开始 (进程句柄, 十到十六 (地址), &WSARecv接口, WSARecv_返回, 5, 2, )
标题＝ “HOOK PID：” ＋到文本 (进程ID)
按钮1.标题＝ “关闭HOOK”
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)

nj20346 · 发表于 2025-4-1 18:10:28

附件太大，我只能放云盘了
我想要的效果就是，启动后发送数据，直接到游戏
这里是所有附件https://wwpl.lanzouw.com/i5j1g2scsvna

神行 · 发表于 2025-4-1 18:05:02

文件太大，没办法直接上传，我把代码给你粘贴上来，需要添加DLL命令和自定义数据类型你就自己弄吧。
方案1：自定义数据类型

.数据类型类型_SOCKET信息
.成员 dwSize, 整数型, , , 结构大小
.成员套接字句柄, 整数型, , , 套接字句柄
.成员本地端口, 整数型, , , 本地端口号（网络字节序）
.成员远程端口, 整数型, , , 远程端口号（网络字节序）
.成员本地IP, 整数型, , , 本地IP地址（网络字节序）
.成员远程IP, 整数型, , , 远程IP地址（网络字节序）
.成员进程ID, 整数型, , , 所属进程ID
.成员协议类型, 整数型, , , 协议类型（TCP/UDP等）

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口
变量名	类型	数组	备注
进程ID	整数型
进程句柄	整数型
hook_Send	类_超级HOOK
Send_返回	类型_HOOK数据
hook_WSASend	类_超级HOOK
WSASend_返回	类型_HOOK数据
hook_recv	类_超级HOOK
hook_WSARecv	类_超级HOOK
recv_返回	类型_HOOK数据
WSARecv_返回	类型_HOOK数据
tempcurs	整数型		鼠标指针
是否有框	逻辑型		画框
鼠标按下	逻辑型
hWnd	整数型
全套接字	整数型

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

变量名	类型	静态	数组	备注
进程	整数型

通用对话框_创建进程.初始目录＝取特定目录 ( #系统桌面 )
进程＝进程_创建 (取运行目录 () ＋ “\woool.dat”, , , )
调试输出 (进程)
StartHook_你原来的 (进程)

子程序名	返回值类型	公开	备注
_组合框1_将弹出列表

变量名	类型	静态	数组	备注
进程ID	整数型		0
进程名	文本型		0
n	整数型
个数	整数型

组合框1.清空 ()
进程_枚举进程 (进程ID, 进程名)
个数＝取数组成员数 (进程ID)

计次循环首 (个数, n)

组合框1.加入项目 (进程名 [n], 进程ID [n])

计次循环尾 ()

子程序名	返回值类型	公开	备注
_按钮1_被单击

判断 (按钮1.标题＝ “开始HOOK”)

进程ID ＝组合框1.取项目数值 (组合框1.现行选中项)

StartHook_你原来的 (进程ID)

按钮1.标题＝ “关闭HOOK”

hook_Send.卸载 ()

hook_WSASend.卸载 ()

hook_recv.卸载 ()

hook_WSARecv.卸载 ()

进程_关闭句柄 (进程句柄)

按钮1.标题＝ “开始HOOK”

连续赋值 (假, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)

子程序名	返回值类型	公开	备注
StartHook_你原来的
参数名	类型	参考	可空	数组	备注
进程ID	整数型

变量名	类型	静态	数组	备注
地址	整数型

进程句柄＝进程_打开进程 (进程ID)

如果真 (进程句柄 ≤ 0)

信息框 (“指定程序不存在或无法拦截!”, 0, “错误:”, )

返回 ()

地址＝系统_取API地址 (“send”)
hook_Send.开始 (进程句柄, 十到十六 (地址), &Send接口, Send_返回, 5, 2, )
地址＝系统_取API地址 (“WSASend”)
hook_WSASend.开始 (进程句柄, 十到十六 (地址), &WSASend接口, WSASend_返回, 5, 2, )
' 地址＝系统_取API地址 (“recv”)
' hook_recv.开始 (进程句柄, 十到十六 (地址), &recv接口, recv_返回, 5, 2, )
' 地址＝系统_取API地址 (“WSARecv”)
' hook_WSARecv.开始 (进程句柄, 十到十六 (地址), &WSARecv接口, WSARecv_返回, 5, 2, )
标题＝ “HOOK PID：” ＋到文本 (进程ID)
按钮1.标题＝ “关闭HOOK”
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)

子程序名	返回值类型	公开	备注
recv接口

变量名	类型	静态	数组	备注
长度	整数型
数据	字节集
指针	整数型
套接字	整数型
文本数据	文本型
字节集请求	文本型
esp	整数型
a	整数型

esp ＝ hook_recv.读值 (recv_返回.返回地址).ESP
长度＝内存_读整数型 (进程句柄, esp ＋ 12)
调试输出 (长度)

子程序名	返回值类型	公开	备注
WSARecv接口

变量名	类型	静态	数组	备注
长度	整数型
数据	字节集
指针	整数型
套接字	整数型
文本数据	文本型
字节集请求	文本型
esp	整数型
a	整数型

esp ＝ hook_WSARecv.读值 (WSARecv_返回.返回地址).ESP

如果真 (全套接字＝ 0)

全套接字＝内存_读整数型 (进程句柄, esp ＋ 4)
' 调试输出 (全套接字)
' hook_WSARecv.卸载 ()

子程序名	返回值类型	公开	备注
Send接口

变量名	类型	静态	数组	备注
长度	整数型
数据	字节集
指针	整数型
套接字	整数型
文本数据	文本型
字节集请求	文本型
esp	整数型
a	整数型

' HOOK头部此时ebp还未压入堆栈,所以 [esp+4]是参数1
esp ＝ hook_Send.读值 (Send_返回.返回地址).ESP
' esp ＋ 4=套接字
' esp ＋ 8=发包内容
' esp ＋ 12=发包长度
' esp ＋ 16=标识符
长度＝内存_读整数型 (进程句柄, esp ＋ 12) ' 第3个参数,请求长度

如果真 (长度＞ 0)

套接字＝内存_读整数型 (进程句柄, esp ＋ 4)

指针＝内存_读整数型 (进程句柄, esp ＋ 8)

数据＝内存_读字节集 (进程句柄, 指针, 长度) ' 第2个参数,请求指针,读取时加一偏移0 读到数据

文本数据＝请求_请求到文本ASCLL (数据)

字节集请求＝字节集到十六进制文本 (数据)

' 写内存可修改参数~

a ＝超级列表框1.插入表项 (, , , , , )

超级列表框1.置标题 (a, 0, 到文本 (a ＋ 1))

超级列表框1.置标题 (a, 1, 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋到文本 (取秒 (取现行时间 ())))

超级列表框1.置标题 (a, 2, “Send”)

超级列表框1.置标题 (a, 3, 到文本 (套接字))

超级列表框1.置标题 (a, 4, 到文本 (长度))

超级列表框1.置标题 (a, 5, 字节集请求)

超级列表框1.置标题 (a, 6, 文本数据)

超级列表框1.保证显示 (a)

子程序名	返回值类型	公开	备注
WSASend接口

变量名	类型	静态	数组	备注
指针	整数型
长度	整数型
数据	字节集
数据指针	整数型
套接字	整数型
文本数据	文本型
字节集请求	文本型
esp	整数型
a	整数型

' HOOK头部此时ebp还未压入堆栈,所以 [esp+4]是参数1
esp ＝ hook_WSASend.读值 (WSASend_返回.返回地址).ESP
套接字＝内存_读整数型 (进程句柄, esp ＋ 4)
调试输出 (“套接字”, 套接字)
' esp ＋ 4=套接字
' esp ＋ 8=结构指针数组
' esp ＋ 12=数组成员数
指针＝内存_读整数型 (进程句柄, esp ＋ 8)
长度＝内存_读整数型 (进程句柄, 指针)
数据指针＝内存_读整数型 (进程句柄, 指针＋ 4)
数据＝内存_读字节集 (进程句柄, 数据指针, 长度) ' 第2个参数,请求指针,读取时加一偏移0 读到数据
文本数据＝请求_请求到文本ASCLL (数据)
字节集请求＝字节集到十六进制文本 (数据)
' 写内存可修改参数~
a ＝超级列表框1.插入表项 (, , , , , )
超级列表框1.置标题 (a, 0, 到文本 (a ＋ 1))
超级列表框1.置标题 (a, 1, 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋到文本 (取秒 (取现行时间 ())))
超级列表框1.置标题 (a, 2, “WSASend”)
超级列表框1.置标题 (a, 3, 到文本 (套接字))
超级列表框1.置标题 (a, 4, 到文本 (长度))
超级列表框1.置标题 (a, 5, 字节集请求)
超级列表框1.置标题 (a, 6, 文本数据)
超级列表框1.保证显示 (a)

子程序名	返回值类型	公开	备注
请求_请求到文本ASCLL	文本型		返回ASCLL文本，一个字节一个字
参数名	类型	参考	可空	数组	备注
请求内容	字节集

变量名	类型	静态	数组	备注
临时内存	整数型
字节数量	整数型
n	整数型
文本	文本型
字节数据	字节型

字节数量＝取字节集长度 (请求内容)

如果真 (字节数量＝ 0)

返回 (“”)
临时内存＝取指针地址 (请求内容)

计次循环首 (字节数量, n)

字节数据＝内存_读字节型 (-1, 临时内存＋ n － 1)

文本＝文本＋字符 (字节数据)

判断开始断 (字节数据＜ 32 或字节数据＞ 127) ' 用来显示标准ASCII 并过滤掉部分字符

' 文本＝文本＋ “.”

' 文本＝文本＋字符 (字节数据)

计次循环尾 ()
返回 (文本)

子程序名	返回值类型	公开	备注
__启动窗口_将被销毁

hook_Send.卸载 ()
hook_WSASend.卸载 ()
进程_关闭句柄 (进程句柄)

子程序名	返回值类型	公开	备注
_发送_被选择

变量名	类型	静态	数组	备注
类型	文本型
索引	整数型
套接字	整数型
长度	整数型
请求内容	字节集

索引＝超级列表框1.现行选中项
类型＝超级列表框1.取标题 (索引, 1)
调试输出 (类型)
套接字＝到整数 (超级列表框1.取标题 (索引, 3))
长度＝到整数 (超级列表框1.取标题 (索引, 4))
调试输出 (套接字)
请求内容＝ { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }
远程发包_Send (套接字, 请求内容, 取字节集长度 (请求内容))
' 远程发包_WSASend (套接字, { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }, 取字节集长度 ({ 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }))

子程序名	返回值类型	公开	备注
远程发包_Send	逻辑型
参数名	类型	参考	可空	数组	备注
套接字	整数型
请求字节集	字节集
请求长度	整数型

变量名	类型	静态	数组	备注
请求地址	整数型
参数	整数型		4

如果真 (进程句柄＞ 0)

hook_Send.暂停 (Send_返回.原始地址, Send_返回.原始数据)

请求地址＝内存_申请字节集内存 (进程句柄, 请求字节集, 请求长度)

参数 [1] ＝套接字

参数 [2] ＝请求地址

参数 [3] ＝请求长度

参数 [4] ＝ 0

进程_远程调用call (进程句柄, Send_返回.原始地址, 参数, )

内存_释放内存 (进程句柄, 请求地址)

hook_Send.继续 (Send_返回.原始地址, Send_返回.hook数据)

返回 (真)
返回 (假)

子程序名	返回值类型	公开	备注
远程发包_WSASend	逻辑型
参数名	类型	参考	可空	数组	备注
套接字	整数型
请求字节集	字节集
请求长度	整数型

变量名	类型	静态	数组	备注
请求地址	整数型
参数	整数型		4

如果真 (进程句柄＞ 0)

hook_WSASend.暂停 (WSASend_返回.原始地址, WSASend_返回.原始数据)

请求地址＝内存_申请字节集内存 (进程句柄, 请求字节集, 请求长度)

参数 [1] ＝套接字

参数 [2] ＝请求地址

参数 [3] ＝请求长度

参数 [4] ＝ 0

进程_远程调用call (进程句柄, WSASend_返回.原始地址, 参数, )

内存_释放内存 (进程句柄, 请求地址)

hook_WSASend.继续 (WSASend_返回.原始地址, WSASend_返回.hook数据)

返回 (真)
返回 (假)

子程序名	返回值类型	公开	备注
_超级列表框1_右键单击表项

如果真 (超级列表框1.现行选中项 ≠ -1)

弹出菜单 (发包, 取鼠标水平位置 (), 取鼠标垂直位置 ())

子程序名	返回值类型	公开	备注
_超级列表框1_当前表项被改变

变量名	类型	静态	数组	备注
计次	整数型
字节集	字节集
text	文本型

编辑框1.内容＝超级列表框1.取标题 (超级列表框1.现行选中项, 5)
编辑框2.内容＝超级列表框1.取标题 (超级列表框1.现行选中项, 6)
字节集＝到字节集 (编辑框2.内容)
text ＝ “{”

计次循环首 (取字节集长度 (字节集), 计次)

text ＝ text ＋到文本 (字节集 [计次])

如果真 (取字节集长度 (字节集) ≠ 计次)

text ＝ text ＋ “,”

计次循环尾 ()
编辑框3.内容＝ text ＋ “}”

i支持库列表	支持库注释
shell	操作系统界面功能支持库
spec	特殊功能支持库
iext	扩展界面支持库一
shellEx	扩展功能支持库一

.版本 2<br />
.支持库 shell<br />
.支持库 spec<br />
.支持库 iext<br />
.支持库 shellEx<br />
<br />
.程序集 窗口程序集_启动窗口<br />
.程序集变量 进程ID, 整数型<br />
.程序集变量 进程句柄, 整数型<br />
.程序集变量 hook_Send, 类_超级HOOK<br />
.程序集变量 Send_返回, 类型_HOOK数据<br />
.程序集变量 hook_WSASend, 类_超级HOOK<br />
.程序集变量 WSASend_返回, 类型_HOOK数据<br />
.程序集变量 hook_recv, 类_超级HOOK<br />
.程序集变量 hook_WSARecv, 类_超级HOOK<br />
.程序集变量 recv_返回, 类型_HOOK数据<br />
.程序集变量 WSARecv_返回, 类型_HOOK数据<br />
.程序集变量 tempcurs, 整数型, , , 鼠标指针<br />
.程序集变量 是否有框, 逻辑型, , , 画框<br />
.程序集变量 鼠标按下, 逻辑型<br />
.程序集变量 hWnd, 整数型<br />
.程序集变量 全套接字, 整数型<br />
<br />
.子程序 __启动窗口_创建完毕<br />
.局部变量 进程, 整数型<br />
<br />
通用对话框_创建进程.初始目录 ＝ 取特定目录 (#系统桌面)<br />
进程 ＝ 进程_创建 (取运行目录 () ＋ “\woool.dat”, , , )<br />
调试输出 (进程)<br />
<br />
<br />
StartHook_你原来的 (进程)<br />
<br />
<br />
.子程序 _组合框1_将弹出列表<br />
.局部变量 进程ID, 整数型, , "0"<br />
.局部变量 进程名, 文本型, , "0"<br />
.局部变量 n, 整数型<br />
.局部变量 个数, 整数型<br />
<br />
组合框1.清空 ()<br />
进程_枚举进程 (进程ID, 进程名)<br />
个数 ＝ 取数组成员数 (进程ID)<br />
.计次循环首 (个数, n)<br />
    组合框1.加入项目 (进程名 [n], 进程ID [n])<br />
<br />
.计次循环尾 ()<br />
<br />
<br />
.子程序 _按钮1_被单击<br />
<br />
.判断开始 (按钮1.标题 ＝ “开始HOOK”)<br />
    进程ID ＝ 组合框1.取项目数值 (组合框1.现行选中项)<br />
    StartHook_你原来的 (进程ID)<br />
    按钮1.标题 ＝ “关闭HOOK”<br />
.默认<br />
    hook_Send.卸载 ()<br />
    hook_WSASend.卸载 ()<br />
    hook_recv.卸载 ()<br />
    hook_WSARecv.卸载 ()<br />
    进程_关闭句柄 (进程句柄)<br />
    按钮1.标题 ＝ “开始HOOK”<br />
    连续赋值 (假, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)<br />
.判断结束<br />
<br />
<br />
<br />
.子程序 StartHook_你原来的<br />
.参数 进程ID, 整数型<br />
.局部变量 地址, 整数型<br />
<br />
进程句柄 ＝ 进程_打开进程 (进程ID)<br />
.如果真 (进程句柄 ≤ 0)<br />
    信息框 (“指定程序不存在或无法拦截!”, 0, “错误:”, )<br />
    返回 ()<br />
.如果真结束<br />
<br />
地址 ＝ 系统_取API地址 (“send”)<br />
hook_Send.开始 (进程句柄, 十到十六 (地址), &Send接口, Send_返回, 5, 2, )<br />
地址 ＝ 系统_取API地址 (“WSASend”)<br />
hook_WSASend.开始 (进程句柄, 十到十六 (地址), &WSASend接口, WSASend_返回, 5, 2, )<br />
<br />
<br />
<br />
' 地址 ＝ 系统_取API地址 (“recv”)<br />
' hook_recv.开始 (进程句柄, 十到十六 (地址), &recv接口, recv_返回, 5, 2, )<br />
' 地址 ＝ 系统_取API地址 (“WSARecv”)<br />
' hook_WSARecv.开始 (进程句柄, 十到十六 (地址), &WSARecv接口, WSARecv_返回, 5, 2, )<br />
<br />
<br />
标题 ＝ “HOOK PID：” ＋ 到文本 (进程ID)<br />
按钮1.标题 ＝ “关闭HOOK”<br />
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)<br />
<br />
<br />
.子程序 recv接口<br />
.局部变量 长度, 整数型<br />
.局部变量 数据, 字节集<br />
.局部变量 指针, 整数型<br />
.局部变量 套接字, 整数型<br />
.局部变量 文本数据, 文本型<br />
.局部变量 字节集请求, 文本型<br />
.局部变量 esp, 整数型<br />
.局部变量 a, 整数型<br />
<br />
esp ＝ hook_recv.读值 (recv_返回.返回地址).ESP<br />
长度 ＝ 内存_读整数型 (进程句柄, esp ＋ 12)<br />
调试输出 (长度)<br />
<br />
.子程序 WSARecv接口<br />
.局部变量 长度, 整数型<br />
.局部变量 数据, 字节集<br />
.局部变量 指针, 整数型<br />
.局部变量 套接字, 整数型<br />
.局部变量 文本数据, 文本型<br />
.局部变量 字节集请求, 文本型<br />
.局部变量 esp, 整数型<br />
.局部变量 a, 整数型<br />
<br />
esp ＝ hook_WSARecv.读值 (WSARecv_返回.返回地址).ESP<br />
<br />
<br />
<br />
.如果真 (全套接字 ＝ 0)<br />
    全套接字 ＝ 内存_读整数型 (进程句柄, esp ＋ 4)<br />
.如果真结束<br />
' 调试输出 (全套接字)<br />
' hook_WSARecv.卸载 ()<br />
<br />
<br />
<br />
<br />
<br />
.子程序 Send接口<br />
.局部变量 长度, 整数型<br />
.局部变量 数据, 字节集<br />
.局部变量 指针, 整数型<br />
.局部变量 套接字, 整数型<br />
.局部变量 文本数据, 文本型<br />
.局部变量 字节集请求, 文本型<br />
.局部变量 esp, 整数型<br />
.局部变量 a, 整数型<br />
<br />
' HOOK头部此时ebp还未压入堆栈,所以  [esp+4]是参数1<br />
esp ＝ hook_Send.读值 (Send_返回.返回地址).ESP<br />
' esp ＋ 4=套接字<br />
' esp ＋ 8=发包内容<br />
' esp ＋ 12=发包长度<br />
' esp ＋ 16=标识符<br />
长度 ＝ 内存_读整数型 (进程句柄, esp ＋ 12)  ' 第3个参数,请求长度<br />
<br />
.如果真 (长度 ＞ 0)<br />
<br />
    套接字 ＝ 内存_读整数型 (进程句柄, esp ＋ 4)<br />
    指针 ＝ 内存_读整数型 (进程句柄, esp ＋ 8)<br />
    数据 ＝ 内存_读字节集 (进程句柄, 指针, 长度)  ' 第2个参数,请求指针,读取时加一偏移0 读到数据<br />
    文本数据 ＝ 请求_请求到文本ASCLL (数据)<br />
    字节集请求 ＝ 字节集到十六进制文本 (数据)<br />
    ' 写内存可修改参数~<br />
    a ＝ 超级列表框1.插入表项 (, , , , , )<br />
    超级列表框1.置标题 (a, 0, 到文本 (a ＋ 1))<br />
    超级列表框1.置标题 (a, 1, 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋ 到文本 (取秒 (取现行时间 ())))<br />
    超级列表框1.置标题 (a, 2, “Send”)<br />
    超级列表框1.置标题 (a, 3, 到文本 (套接字))<br />
    超级列表框1.置标题 (a, 4, 到文本 (长度))<br />
    超级列表框1.置标题 (a, 5, 字节集请求)<br />
    超级列表框1.置标题 (a, 6, 文本数据)<br />
    超级列表框1.保证显示 (a)<br />
<br />
.如果真结束<br />
<br />
<br />
.子程序 WSASend接口<br />
.局部变量 指针, 整数型<br />
.局部变量 长度, 整数型<br />
.局部变量 数据, 字节集<br />
.局部变量 数据指针, 整数型<br />
.局部变量 套接字, 整数型<br />
.局部变量 文本数据, 文本型<br />
.局部变量 字节集请求, 文本型<br />
.局部变量 esp, 整数型<br />
.局部变量 a, 整数型<br />
<br />
' HOOK头部此时ebp还未压入堆栈,所以  [esp+4]是参数1<br />
esp ＝ hook_WSASend.读值 (WSASend_返回.返回地址).ESP<br />
套接字 ＝ 内存_读整数型 (进程句柄, esp ＋ 4)<br />
<br />
调试输出 (“套接字”, 套接字)<br />
<br />
' esp ＋ 4=套接字<br />
' esp ＋ 8=结构指针数组<br />
' esp ＋ 12=数组成员数<br />
指针 ＝ 内存_读整数型 (进程句柄, esp ＋ 8)<br />
长度 ＝ 内存_读整数型 (进程句柄, 指针)<br />
<br />
<br />
数据指针 ＝ 内存_读整数型 (进程句柄, 指针 ＋ 4)<br />
数据 ＝ 内存_读字节集 (进程句柄, 数据指针, 长度)  ' 第2个参数,请求指针,读取时加一偏移0 读到数据<br />
文本数据 ＝ 请求_请求到文本ASCLL (数据)<br />
字节集请求 ＝ 字节集到十六进制文本 (数据)<br />
' 写内存可修改参数~<br />
a ＝ 超级列表框1.插入表项 (, , , , , )<br />
超级列表框1.置标题 (a, 0, 到文本 (a ＋ 1))<br />
超级列表框1.置标题 (a, 1, 到文本 (取小时 (取现行时间 ())) ＋ “:” ＋ 到文本 (取分钟 (取现行时间 ())) ＋ “:” ＋ 到文本 (取秒 (取现行时间 ())))<br />
超级列表框1.置标题 (a, 2, “WSASend”)<br />
超级列表框1.置标题 (a, 3, 到文本 (套接字))<br />
超级列表框1.置标题 (a, 4, 到文本 (长度))<br />
超级列表框1.置标题 (a, 5, 字节集请求)<br />
超级列表框1.置标题 (a, 6, 文本数据)<br />
超级列表框1.保证显示 (a)<br />
<br />
<br />
<br />
.子程序 请求_请求到文本ASCLL, 文本型, , 返回ASCLL文本，一个字节一个字<br />
.参数 请求内容, 字节集<br />
.局部变量 临时内存, 整数型<br />
.局部变量 字节数量, 整数型<br />
.局部变量 n, 整数型<br />
.局部变量 文本, 文本型<br />
.局部变量 字节数据, 字节型<br />
<br />
字节数量 ＝ 取字节集长度 (请求内容)<br />
.如果真 (字节数量 ＝ 0)<br />
    返回 (“”)<br />
.如果真结束<br />
临时内存 ＝ 取指针地址 (请求内容)<br />
<br />
.计次循环首 (字节数量, n)<br />
    字节数据 ＝ 内存_读字节型 (-1, 临时内存 ＋ n － 1)<br />
    文本 ＝ 文本 ＋ 字符 (字节数据)<br />
    .判断开始断 (字节数据 ＜ 32 或 字节数据 ＞ 127)  ' 用来显示标准ASCII 并过滤掉部分字符<br />
        ' 文本 ＝ 文本 ＋ “.”<br />
    .默认<br />
        ' 文本 ＝ 文本 ＋ 字符 (字节数据)<br />
    .判断结束<br />
<br />
.计次循环尾 ()<br />
返回 (文本)<br />
<br />
.子程序 __启动窗口_将被销毁<br />
<br />
hook_Send.卸载 ()<br />
<br />
hook_WSASend.卸载 ()<br />
进程_关闭句柄 (进程句柄)<br />
<br />
.子程序 _发送_被选择<br />
.局部变量 类型, 文本型<br />
.局部变量 索引, 整数型<br />
.局部变量 套接字, 整数型<br />
.局部变量 长度, 整数型<br />
.局部变量 请求内容, 字节集<br />
<br />
索引 ＝ 超级列表框1.现行选中项<br />
类型 ＝ 超级列表框1.取标题 (索引, 1)<br />
调试输出 (类型)<br />
套接字 ＝ 到整数 (超级列表框1.取标题 (索引, 3))<br />
长度 ＝ 到整数 (超级列表框1.取标题 (索引, 4))<br />
调试输出 (套接字)<br />
请求内容 ＝ { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }<br />
<br />
<br />
远程发包_Send (套接字, 请求内容, 取字节集长度 (请求内容))<br />
<br />
' 远程发包_WSASend (套接字, { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }, 取字节集长度 ({ 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }))<br />
<br />
.子程序 远程发包_Send, 逻辑型<br />
.参数 套接字, 整数型<br />
.参数 请求字节集, 字节集<br />
.参数 请求长度, 整数型<br />
.局部变量 请求地址, 整数型<br />
.局部变量 参数, 整数型, , "4"<br />
<br />
.如果真 (进程句柄 ＞ 0)<br />
    hook_Send.暂停 (Send_返回.原始地址, Send_返回.原始数据)<br />
    请求地址 ＝ 内存_申请字节集内存 (进程句柄, 请求字节集, 请求长度)<br />
    参数 [1] ＝ 套接字<br />
    参数 [2] ＝ 请求地址<br />
    参数 [3] ＝ 请求长度<br />
    参数 [4] ＝ 0<br />
    进程_远程调用call (进程句柄, Send_返回.原始地址, 参数, )<br />
    内存_释放内存 (进程句柄, 请求地址)<br />
    hook_Send.继续 (Send_返回.原始地址, Send_返回.hook数据)<br />
    返回 (真)<br />
.如果真结束<br />
返回 (假)<br />
<br />
<br />
<br />
<br />
.子程序 远程发包_WSASend, 逻辑型<br />
.参数 套接字, 整数型<br />
.参数 请求字节集, 字节集<br />
.参数 请求长度, 整数型<br />
.局部变量 请求地址, 整数型<br />
.局部变量 参数, 整数型, , "4"<br />
<br />
.如果真 (进程句柄 ＞ 0)<br />
    hook_WSASend.暂停 (WSASend_返回.原始地址, WSASend_返回.原始数据)<br />
    请求地址 ＝ 内存_申请字节集内存 (进程句柄, 请求字节集, 请求长度)<br />
    参数 [1] ＝ 套接字<br />
    参数 [2] ＝ 请求地址<br />
    参数 [3] ＝ 请求长度<br />
    参数 [4] ＝ 0<br />
<br />
<br />
    进程_远程调用call (进程句柄, WSASend_返回.原始地址, 参数, )<br />
    内存_释放内存 (进程句柄, 请求地址)<br />
    hook_WSASend.继续 (WSASend_返回.原始地址, WSASend_返回.hook数据)<br />
<br />
    返回 (真)<br />
.如果真结束<br />
返回 (假)<br />
<br />
.子程序 _超级列表框1_右键单击表项<br />
<br />
.如果真 (超级列表框1.现行选中项 ≠ -1)<br />
    弹出菜单 (发包, 取鼠标水平位置 (), 取鼠标垂直位置 ())<br />
.如果真结束<br />
<br />
<br />
.子程序 _超级列表框1_当前表项被改变<br />
.局部变量 计次, 整数型<br />
.局部变量 字节集, 字节集<br />
.局部变量 text, 文本型<br />
<br />
编辑框1.内容 ＝ 超级列表框1.取标题 (超级列表框1.现行选中项, 5)<br />
编辑框2.内容 ＝ 超级列表框1.取标题 (超级列表框1.现行选中项, 6)<br />
字节集 ＝ 到字节集 (编辑框2.内容)<br />
text ＝ “{”<br />
.计次循环首 (取字节集长度 (字节集), 计次)<br />
    text ＝ text ＋ 到文本 (字节集 [计次])<br />
    .如果真 (取字节集长度 (字节集) ≠ 计次)<br />
        text ＝ text ＋ “,”<br />
    .如果真结束<br />
<br />
.计次循环尾 ()<br />
编辑框3.内容 ＝ text ＋ “}”

方案2：

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口
变量名	类型	数组	备注
进程ID	整数型		目标进程ID
进程句柄	整数型		目标进程句柄
hook_Send	类_超级HOOK		Send函数HOOK对象
Send_返回	类型_HOOK数据		Send函数HOOK数据
hook_WSASend	类_超级HOOK		WSASend函数HOOK对象
WSASend_返回	类型_HOOK数据		WSASend函数HOOK数据
hook_socket	类_超级HOOK		socket函数HOOK对象
socket_返回	类型_HOOK数据		socket函数HOOK数据
hook_WSASocket	类_超级HOOK		WSASocket函数HOOK对象
WSASocket_返回	类型_HOOK数据		WSASocket函数HOOK数据
全套接字	整数型		捕获的套接字句柄

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕			窗口创建完成时执行

' 设置进程创建对话框的初始目录
通用对话框_创建进程.初始目录＝取特定目录 ( #系统桌面 )
' 调试用：自动创建测试进程
' 进程_创建 (取运行目录 () ＋ "\woool.dat", , , )
' 组合框弹出时枚举所有进程

子程序名	返回值类型	公开	备注
_组合框1_将弹出列表

变量名	类型	静态	数组	备注
进程ID数组	整数型		0	进程ID数组
进程名数组	文本型		0	进程名数组
循环变量	整数型
进程数量	整数型

组合框1.清空 () ' 清空现有内容
进程_枚举进程 (进程ID数组, 进程名数组) ' 获取系统进程列表
进程数量＝取数组成员数 (进程ID数组)
' 将进程名添加到组合框

计次循环首 (进程数量, 循环变量)

组合框1.加入项目 (进程名数组 [循环变量], 进程ID数组 [循环变量])

计次循环尾 ()

子程序名	返回值类型	公开	备注
_按钮1_被单击			开始/关闭HOOK按钮点击事件

判断 (按钮1.标题＝ "开始HOOK")

' 获取选中的进程ID

进程ID ＝组合框1.取项目数值 (组合框1.现行选中项)

' 开始HOOK目标进程

StartHook (进程ID)

按钮1.标题＝ "关闭HOOK"

' 卸载所有HOOK

UnhookAll ()

按钮1.标题＝ "开始HOOK"

' 启用相关控件

连续赋值 (假, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)

' 初始化并开始所有HOOK

子程序名	返回值类型	公开	备注
StartHook			初始化并开始所有HOOK
参数名	类型	参考	可空	数组	备注
进程ID	整数型

变量名	类型	静态	数组	备注
API地址	整数型

' 打开目标进程
进程句柄＝进程_打开进程 (进程ID)

如果真 (进程句柄 ≤ 0)

信息框 ("指定程序不存在或无法拦截!", 0, "错误:", )

返回 ()

' HOOK socket创建相关API
API地址＝系统_取API地址 ("socket")
hook_socket.开始 (进程句柄, 十到十六 (API地址), &socket接口, socket_返回, 5, 2, )
API地址＝系统_取API地址 ("WSASocketA")
hook_WSASocket.开始 (进程句柄, 十到十六 (API地址), &WSASocket接口, WSASocket_返回, 5, 2, )
' HOOK 数据发送相关API
API地址＝系统_取API地址 ("send")
hook_Send.开始 (进程句柄, 十到十六 (API地址), &Send接口, Send_返回, 5, 2, )
API地址＝系统_取API地址 ("WSASend")
hook_WSASend.开始 (进程句柄, 十到十六 (API地址), &WSASend接口, WSASend_返回, 5, 2, )
' 更新界面状态
标题＝ "HOOK PID：" ＋到文本 (进程ID)
按钮1.标题＝ "关闭HOOK"
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)
' socket函数HOOK回调

子程序名	返回值类型	公开	备注
socket接口			socket函数HOOK回调

变量名	类型	静态	数组	备注
esp	整数型
新套接字	整数型

' 获取栈指针
esp ＝ hook_socket.读值 (socket_返回.返回地址).ESP
' 读取返回值（eax值通过esp获取）
新套接字＝内存_读整数型 (进程句柄, esp)
' 验证并存储有效套接字

如果真 (新套接字 ≠ -1 且新套接字 ≠ 0)

全套接字＝新套接字

调试输出 ("[HOOK] 捕获socket套接字:", 全套接字)

子程序名	返回值类型	公开	备注
WSASocket接口			WSASocket函数HOOK回调

变量名	类型	静态	数组	备注
esp	整数型
新套接字	整数型

' 获取栈指针
esp ＝ hook_WSASocket.读值 (WSASocket_返回.返回地址).ESP
' 读取返回值
新套接字＝内存_读整数型 (进程句柄, esp)
' 验证并存储有效套接字

如果真 (新套接字 ≠ -1 且新套接字 ≠ 0)

全套接字＝新套接字

调试输出 ("[HOOK] 捕获WSASocket套接字:", 全套接字)

子程序名	返回值类型	公开	备注
UnhookAll			卸载所有HOOK

hook_socket.卸载 ()
hook_WSASocket.卸载 ()
hook_Send.卸载 ()
hook_WSASend.卸载 ()

如果真 (进程句柄＞ 0)

进程_关闭句柄 (进程句柄)

子程序名	返回值类型	公开	备注
检查套接字有效性	逻辑型		检查套接字有效性

变量名	类型	静态	数组	备注
缓冲区	整数型
长度	整数型

如果真 (全套接字＝ 0)

返回 (假)

' 通过getsockopt检查套接字状态
长度＝ 4
返回 (getsockopt (全套接字, #SOL_SOCKET, #SO_ERROR, 缓冲区, 长度) ＝ 0)

子程序名	返回值类型	公开	备注
_按钮4_被单击			发送测试请求

变量名	类型	静态	数组	备注
请求内容	字节集

如果真 (检查套接字有效性 () ＝假)

信息框 ("套接字无效或尚未创建!", 0, "错误", )

返回 ()

' 测试请求数据
请求内容＝ { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }
' 发送请求
调试输出 ("[发送] 使用套接字:", 全套接字)
远程发包_Send (全套接字, 请求内容, 取字节集长度 (请求内容))

子程序名	返回值类型	公开	备注
__启动窗口_将被销毁			窗口销毁时清理资源

UnhookAll ()

子程序名	返回值类型	公开	备注
子程序1

' 实现原理：
' HOOK时机：在程序创建套接字时立即捕获，而不是等到发送数据时
' 双重保障：同时HOOK标准socket和WSASocket函数，确保不同实现都能捕获
' 有效性检查：发送前验证套接字是否有效
' 自动更新：每当程序创建新套接字时自动更新"全套接字"变量
' 注意事项
' 如果目标程序创建多个套接字，此方案会捕获最后一个创建的套接字
' 对于已经存在的套接字(在HOOK前创建的)，需要结合其他方法获取
' 某些程序可能会重新创建套接字，需要注意套接字更新的情况
' 这种方案比等待数据流通更直接有效，可以立即获取到可用的套接字句柄。如果需要处理多个套接字的情况，可以改为使用数组存储所有捕获的套接字。

.版本 2<br />
<br />
.程序集 窗口程序集_启动窗口<br />
.程序集变量 进程ID, 整数型, , , 目标进程ID<br />
.程序集变量 进程句柄, 整数型, , , 目标进程句柄<br />
.程序集变量 hook_Send, 类_超级HOOK, , , Send函数HOOK对象<br />
.程序集变量 Send_返回, 类型_HOOK数据, , , Send函数HOOK数据<br />
.程序集变量 hook_WSASend, 类_超级HOOK, , , WSASend函数HOOK对象<br />
.程序集变量 WSASend_返回, 类型_HOOK数据, , , WSASend函数HOOK数据<br />
.程序集变量 hook_socket, 类_超级HOOK, , , socket函数HOOK对象<br />
.程序集变量 socket_返回, 类型_HOOK数据, , , socket函数HOOK数据<br />
.程序集变量 hook_WSASocket, 类_超级HOOK, , , WSASocket函数HOOK对象<br />
.程序集变量 WSASocket_返回, 类型_HOOK数据, , , WSASocket函数HOOK数据<br />
.程序集变量 全套接字, 整数型, , , 捕获的套接字句柄<br />
<br />
.子程序 __启动窗口_创建完毕, , , 窗口创建完成时执行<br />
<br />
' 设置进程创建对话框的初始目录<br />
通用对话框_创建进程.初始目录 ＝ 取特定目录 (#系统桌面)<br />
' 调试用：自动创建测试进程<br />
' 进程_创建 (取运行目录 () ＋ "\woool.dat",  , , )<br />
<br />
' 组合框弹出时枚举所有进程<br />
<br />
.子程序 _组合框1_将弹出列表<br />
.局部变量 进程ID数组, 整数型, , "0", 进程ID数组<br />
.局部变量 进程名数组, 文本型, , "0", 进程名数组<br />
.局部变量 循环变量, 整数型<br />
.局部变量 进程数量, 整数型<br />
<br />
组合框1.清空 ()  ' 清空现有内容<br />
进程_枚举进程 (进程ID数组, 进程名数组)  ' 获取系统进程列表<br />
进程数量 ＝ 取数组成员数 (进程ID数组)<br />
<br />
' 将进程名添加到组合框<br />
.计次循环首 (进程数量, 循环变量)<br />
    组合框1.加入项目 (进程名数组 [循环变量], 进程ID数组 [循环变量])<br />
.计次循环尾 ()<br />
<br />
<br />
<br />
.子程序 _按钮1_被单击, , , 开始/关闭HOOK按钮点击事件<br />
<br />
.判断开始 (按钮1.标题 ＝ "开始HOOK")<br />
    ' 获取选中的进程ID<br />
    进程ID ＝ 组合框1.取项目数值 (组合框1.现行选中项)<br />
    ' 开始HOOK目标进程<br />
    StartHook (进程ID)<br />
    按钮1.标题 ＝ "关闭HOOK"<br />
.默认<br />
    ' 卸载所有HOOK<br />
    UnhookAll ()<br />
    按钮1.标题 ＝ "开始HOOK"<br />
    ' 启用相关控件<br />
    连续赋值 (假, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)<br />
.判断结束<br />
<br />
' 初始化并开始所有HOOK<br />
<br />
.子程序 StartHook, , , 初始化并开始所有HOOK<br />
.参数 进程ID, 整数型<br />
.局部变量 API地址, 整数型<br />
<br />
' 打开目标进程<br />
进程句柄 ＝ 进程_打开进程 (进程ID)<br />
.如果真 (进程句柄 ≤ 0)<br />
    信息框 ("指定程序不存在或无法拦截!", 0, "错误:", )<br />
    返回 ()<br />
.如果真结束<br />
<br />
' HOOK socket创建相关API<br />
API地址 ＝ 系统_取API地址 ("socket")<br />
hook_socket.开始 (进程句柄, 十到十六 (API地址), &socket接口, socket_返回, 5, 2, )<br />
<br />
API地址 ＝ 系统_取API地址 ("WSASocketA")<br />
hook_WSASocket.开始 (进程句柄, 十到十六 (API地址), &WSASocket接口, WSASocket_返回, 5, 2, )<br />
<br />
' HOOK 数据发送相关API<br />
API地址 ＝ 系统_取API地址 ("send")<br />
hook_Send.开始 (进程句柄, 十到十六 (API地址), &Send接口, Send_返回, 5, 2, )<br />
<br />
API地址 ＝ 系统_取API地址 ("WSASend")<br />
hook_WSASend.开始 (进程句柄, 十到十六 (API地址), &WSASend接口, WSASend_返回, 5, 2, )<br />
<br />
' 更新界面状态<br />
标题 ＝ "HOOK PID：" ＋ 到文本 (进程ID)<br />
按钮1.标题 ＝ "关闭HOOK"<br />
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)<br />
<br />
' socket函数HOOK回调<br />
<br />
.子程序 socket接口, , , socket函数HOOK回调<br />
.局部变量 esp, 整数型<br />
.局部变量 新套接字, 整数型<br />
<br />
' 获取栈指针<br />
esp ＝ hook_socket.读值 (socket_返回.返回地址).ESP<br />
' 读取返回值（eax值通过esp获取）<br />
新套接字 ＝ 内存_读整数型 (进程句柄, esp)<br />
<br />
' 验证并存储有效套接字<br />
.如果真 (新套接字 ≠ -1 且 新套接字 ≠ 0)<br />
    全套接字 ＝ 新套接字<br />
    调试输出 ("[HOOK] 捕获socket套接字:", 全套接字)<br />
.如果真结束<br />
<br />
<br />
<br />
.子程序 WSASocket接口, , , WSASocket函数HOOK回调<br />
.局部变量 esp, 整数型<br />
.局部变量 新套接字, 整数型<br />
<br />
' 获取栈指针<br />
esp ＝ hook_WSASocket.读值 (WSASocket_返回.返回地址).ESP<br />
' 读取返回值<br />
新套接字 ＝ 内存_读整数型 (进程句柄, esp)<br />
<br />
' 验证并存储有效套接字<br />
.如果真 (新套接字 ≠ -1 且 新套接字 ≠ 0)<br />
    全套接字 ＝ 新套接字<br />
    调试输出 ("[HOOK] 捕获WSASocket套接字:", 全套接字)<br />
.如果真结束<br />
<br />
<br />
.子程序 UnhookAll, , , 卸载所有HOOK<br />
<br />
hook_socket.卸载 ()<br />
hook_WSASocket.卸载 ()<br />
hook_Send.卸载 ()<br />
hook_WSASend.卸载 ()<br />
.如果真 (进程句柄 ＞ 0)<br />
    进程_关闭句柄 (进程句柄)<br />
.如果真结束<br />
<br />
<br />
<br />
.子程序 检查套接字有效性, 逻辑型, , 检查套接字有效性<br />
.局部变量 缓冲区, 整数型<br />
.局部变量 长度, 整数型<br />
<br />
.如果真 (全套接字 ＝ 0)<br />
    返回 (假)<br />
.如果真结束<br />
<br />
' 通过getsockopt检查套接字状态<br />
长度 ＝ 4<br />
返回 (getsockopt (全套接字, #SOL_SOCKET, #SO_ERROR, 缓冲区, 长度) ＝ 0)<br />
<br />
<br />
<br />
.子程序 _按钮4_被单击, , , 发送测试请求<br />
.局部变量 请求内容, 字节集<br />
<br />
.如果真 (检查套接字有效性 () ＝ 假)<br />
    信息框 ("套接字无效或尚未创建!", 0, "错误", )<br />
    返回 ()<br />
.如果真结束<br />
<br />
' 测试请求数据<br />
请求内容 ＝ { 35, 50, 118, 118, 102, 117, 118, 73, 103, 117, 118, 118, 102, 117, 118, 118, 102, 117, 113, 112, 83, 117, 114, 113, 88, 122, 107, 113, 84, 113, 111, 113, 84, 117, 111, 61, 33 }<br />
<br />
' 发送请求<br />
调试输出 ("[发送] 使用套接字:", 全套接字)<br />
远程发包_Send (全套接字, 请求内容, 取字节集长度 (请求内容))<br />
<br />
<br />
<br />
.子程序 __启动窗口_将被销毁, , , 窗口销毁时清理资源<br />
<br />
UnhookAll ()<br />
<br />
.子程序 子程序1<br />
<br />
' 实现原理：<br />
' HOOK时机：在程序创建套接字时立即捕获，而不是等到发送数据时<br />
' 双重保障：同时HOOK标准socket和WSASocket函数，确保不同实现都能捕获<br />
' 有效性检查：发送前验证套接字是否有效<br />
' 自动更新：每当程序创建新套接字时自动更新"全套接字"变量<br />
<br />
' 注意事项<br />
' 如果目标程序创建多个套接字，此方案会捕获最后一个创建的套接字<br />
' 对于已经存在的套接字(在HOOK前创建的)，需要结合其他方法获取<br />
' 某些程序可能会重新创建套接字，需要注意套接字更新的情况<br />
<br />
' 这种方案比等待数据流通更直接有效，可以立即获取到可用的套接字句柄。如果需要处理多个套接字的情况，可以改为使用数组存储所有捕获的套接字。

失地农民 · 发表于 2025-4-1 18:11:05

hook socket 就能拿到套接字

nj20346 · 发表于 2025-4-1 18:12:31

失地农民发表于 2025-4-1 18:11
hook socket 就能拿到套接字

但是，他要有数据流通的时候，才触发到子程序

nj20346 · 发表于 2025-4-1 18:39:59

失地农民发表于 2025-4-1 18:11
hook socket 就能拿到套接字

* “a” | 0
* “b” | 1980070800
* “c” | 68026332
* “d” | 2004992267
* “e” | 0
* “f” | -2024634255
* “recv_返回.返回地址” | 72744960
* 2
没看到4位的套接字

神行 · 发表于 2025-4-1 18:41:19

1.在进程启动时就拦截套接字创建-通过钩住socket()或者WSASocker（）函数
2.建立套接字列表-记录所有的套接字3.主动发送测试数据-对获取到的套接字发送测试数据来触发通信

新增全局变量：套接字列表，整数型，用于存储所有创建的套接字

子程序名	返回值类型	公开	备注
StartHook
参数名	类型	参考	可空	数组	备注
进程ID	整数型

变量名	类型	静态	数组	备注
地址	整数型

进程句柄＝进程_打开进程 (进程ID)

如果真 (进程句柄 ≤ 0)

信息框 ("指定程序不存在或无法拦截!", 0, "错误:", )

返回 ()

' 先钩住套接字创建函数
地址＝系统_取API地址 ("socket")
hook_Socket.开始 (进程句柄, 十到十六 (地址), &Socket接口, Socket_返回, 5, 2, )
地址＝系统_取API地址 ("WSASocketA") ' 或 WSASocketW
hook_WSASocket.开始 (进程句柄, 十到十六 (地址), &WSASocket接口, WSASocket_返回, 5, 2, )
' 然后钩住发送函数
地址＝系统_取API地址 ("send")
hook_Send.开始 (进程句柄, 十到十六 (地址), &Send接口, Send_返回, 5, 2, )
地址＝系统_取API地址 ("WSASend")
hook_WSASend.开始 (进程句柄, 十到十六 (地址), &WSASend接口, WSASend_返回, 5, 2, )
标题＝ "HOOK PID：" ＋到文本 (进程ID)
按钮1.标题＝ "关闭HOOK"
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)
' 启动定时器检测套接字
时钟1.时钟周期＝ 1000 ' 每秒检查一次

子程序名	返回值类型	公开	备注
Socket接口
参数名	类型	参考	可空	数组	备注
返回值	整数型

变量名	类型	静态	数组	备注
套接字	整数型

' 保存创建的套接字
套接字＝返回值
加入成员 (套接字列表, 套接字)
返回 (返回值)

子程序名	返回值类型	公开	备注
WSASocket接口
参数名	类型	参考	可空	数组	备注
返回值	整数型

变量名	类型	静态	数组	备注
套接字	整数型

' 保存创建的套接字
套接字＝返回值
加入成员 (套接字列表, 套接字)
返回 (返回值)

子程序名	返回值类型	公开	备注
_时钟1_周期事件

变量名	类型	静态	数组	备注
i	整数型
套接字	整数型

计次循环首 (取数组成员数 (套接字列表), i)

套接字＝套接字列表 [i]

' 测试发送数据

发送测试数据 (套接字)

计次循环尾 ()

子程序名	返回值类型	公开	备注
发送测试数据
参数名	类型	参考	可空	数组	备注
套接字	整数型

变量名	类型	静态	数组	备注
测试数据	文本型
结果	整数型

测试数据＝ "TEST" ' 测试数据
结果＝ send (套接字, 测试数据, 取文本长度 (测试数据), 0)

.版本 2<br />
<br />
.子程序 StartHook<br />
.参数 进程ID, 整数型<br />
.局部变量 地址, 整数型<br />
<br />
进程句柄 ＝ 进程_打开进程 (进程ID)<br />
.如果真 (进程句柄 ≤ 0)<br />
    信息框 ("指定程序不存在或无法拦截!", 0, "错误:", )<br />
    返回 ()<br />
.如果真结束<br />
<br />
' 先钩住套接字创建函数<br />
地址 ＝ 系统_取API地址 ("socket")<br />
hook_Socket.开始 (进程句柄, 十到十六 (地址), &Socket接口, Socket_返回, 5, 2, )<br />
<br />
地址 ＝ 系统_取API地址 ("WSASocketA")  ' 或 WSASocketW<br />
hook_WSASocket.开始 (进程句柄, 十到十六 (地址), &WSASocket接口, WSASocket_返回, 5, 2, )<br />
<br />
' 然后钩住发送函数<br />
地址 ＝ 系统_取API地址 ("send")<br />
hook_Send.开始 (进程句柄, 十到十六 (地址), &Send接口, Send_返回, 5, 2, )<br />
<br />
地址 ＝ 系统_取API地址 ("WSASend")<br />
hook_WSASend.开始 (进程句柄, 十到十六 (地址), &WSASend接口, WSASend_返回, 5, 2, )<br />
<br />
标题 ＝ "HOOK PID：" ＋ 到文本 (进程ID)<br />
按钮1.标题 ＝ "关闭HOOK"<br />
连续赋值 (真, 组合框1.禁止, 按钮3.禁止, 图形按钮1.禁止)<br />
<br />
' 启动定时器检测套接字<br />
时钟1.时钟周期 ＝ 1000  ' 每秒检查一次<br />
<br />
.子程序 Socket接口<br />
.参数 返回值, 整数型<br />
.局部变量 套接字, 整数型<br />
<br />
' 保存创建的套接字<br />
套接字 ＝ 返回值<br />
加入成员 (套接字列表, 套接字)<br />
<br />
返回 (返回值)<br />
<br />
.子程序 WSASocket接口<br />
.参数 返回值, 整数型<br />
.局部变量 套接字, 整数型<br />
<br />
' 保存创建的套接字<br />
套接字 ＝ 返回值<br />
加入成员 (套接字列表, 套接字)<br />
<br />
返回 (返回值)<br />
<br />
.子程序 _时钟1_周期事件<br />
.局部变量 i, 整数型<br />
.局部变量 套接字, 整数型<br />
<br />
.计次循环首 (取数组成员数 (套接字列表), i)<br />
    套接字 ＝ 套接字列表 <i><br />
    ' 测试发送数据<br />
    发送测试数据 (套接字)<br />
.计次循环尾 ()<br />
<br />
.子程序 发送测试数据<br />
.参数 套接字, 整数型<br />
.局部变量 测试数据, 文本型<br />
.局部变量 结果, 整数型<br />
<br />
测试数据 ＝ "TEST"  ' 测试数据<br />
结果 ＝ send (套接字, 测试数据, 取文本长度 (测试数据), 0)

实际使用中，应该考虑对无效套接字进行过滤，还可能需要判断套接字状态后再发送，发送失败时应从列表中一处无效套接字。

总之，这种方法可以让你在程序创建套接字时就立即获取到它，而不必等待数据流通过程

失地农民 · 发表于 2025-4-1 18:45:14

.版本 2

.DLL命令 socket, 整数型, "Ws2_32.dll", "socket", , 返回创建套接字句柄
.参数 af, 整数型
.参数 type, 整数型
.参数 protocol, 整数型

nj20346 · 发表于 2025-4-1 19:09:54

神行发表于 2025-4-1 18:41
1.在进程启动时就拦截套接字创建-通过钩住socket()或者WSASocker（）函数
2.建立套接字列表-记录所有的套接 ...

我原版复制您的方法也不行，怎么获取套接字都是0

神行 · 发表于 2025-4-1 19:15:09

nj20346 发表于 2025-4-1 19:09
我原版复制您的方法也不行，怎么获取套接字都是0

两个原因：
1.hook函数没有正确处理原始调用，hook接口只是简单返回了返回值但没有先调用原始函数
2.调用约定或参数传递错误， API hook需要严格匹配原始函数的调用约定

.子程序 Socket接口
.参数 af, 整数型
.参数 type, 整数型
.参数 protocol, 整数型
.局部变量套接字, 整数型

' 先调用原始函数获取套接字
套接字 := CallWindowProcA(hook_Socket.原始地址, af, type, protocol, 0, 0)

' 只保存有效的套接字
.如果 (套接字 ≠ INVALID_SOCKET)
加入成员 (套接字列表, 套接字)
.否则
输出调试文本 ("创建套接字失败，错误代码：" + 到文本(WSAGetLastError()))
.如果结束

返回 (套接字)

.子程序 WSASocket接口
.参数 af, 整数型
.参数 type, 整数型
.参数 protocol, 整数型
.参数 lpProtocolInfo, 整数型
.参数 g, 整数型
.参数 dwFlags, 整数型
.局部变量套接字, 整数型

' 调用原始WSASocket函数
套接字 := CallWindowProcA(hook_WSASocket.原始地址, af, type, protocol, lpProtocolInfo, g, dwFlags)

' 检查套接字有效性
.如果 (套接字 ≠ INVALID_SOCKET)
加入成员 (套接字列表, 套接字)
.否则
输出调试文本 ("WSASocket创建失败，错误代码：" + 到文本(WSAGetLastError()))
.如果结束

返回 (套接字)

用这个试试

		自动登录	找回密码
密码			注册

[已解决] 如果直接取出套接字

最佳答案

浏览过的版块