【2017-5-15】阿飞最新DXF多功能重组开源（编译可用）

佳大大 · 发表于 2017-5-23 16:42:59

以表达我对楼主的谢意，把帖子顶起来

mangguo2 · 发表于 2018-2-26 20:11:53

沙发我的谢谢！！

完美的 · 发表于 2018-3-15 15:51:03

.版本 2
.支持库 eAPI
.支持库 spec

.程序集重组集

.子程序写小数, 逻辑型
.参数内存地址, 整数型
.参数要写入的值, 小数型

返回 (_写小数 (读写句柄, 内存地址, 要写入的值, 4, 0) ＝ 1)

.子程序写整数, 逻辑型
.参数内存地址, 整数型
.参数要写入的值, 整数型
.局部变量局_长度, 整数型

返回 (_写整数 (读写句柄, 内存地址, 要写入的值, 4, 0) ＝ 1)

.子程序申请内存地址, 整数型
.参数内存大小, , 可空, 字节单位，最低4096

.如果真 (是否为空 (内存大小))
内存大小＝ 1
.如果真结束
返回 (VirtualAllocEx (读写句柄, 0, 内存大小, 4096, 64))

.子程序打开进程1, 整数型
.参数进程PID, 整数型, 可空

CloseHandle (读写句柄)
.如果真 (是否为空 (进程PID))
读写句柄＝进程取ID (“XNF.exe”)  ' 进程取id（"XNF.exe"）就是读写自身进程内存
返回 (读写句柄)
.如果真结束
读写句柄＝ OpenProcess (2035711, 0, 进程PID)
返回 (读写句柄)

.子程序取XNF进程, 整数型
.局部变量 a, 进程信息, , "0"
.局部变量 b

a ＝取系统进程列表 ()
.计次循环首 (取数组成员数 (a), b)
.如果真 (a [b].进程名称＝ “XNF.exe” 且 a [b].线程数＞ 20)
      返回 (a [b].进程标识符)
.如果真结束

.计次循环尾 ()
返回 (0)

.子程序打开XNF进程2, 整数型

返回 (打开进程1 (取XNF进程 ()))

.子程序超级BUFF

换装call (读内存整数型 (-1, 十六到十2 (#人物基址)), 400330000)
延时 (50)
结构＝读内存代码 (-1, #人物基址＋ “+” ＋ #称号偏移)  ' 称号
壳＝读内存整数型 (-1, 结构＋ 32)
重组BUFF ()
写内存字节集 (-1, 结构＋ 2908, 数据)
写内存整数型 (-1, 结构＋ 32, 400330000)  ' 名称：[奇幻之旅 (智)] 代码：[2681351]       王之守护.风 26023
公告 (“妖神附体 - 成功”)
延时 (1000)
写内存整数型 (-1, 结构＋ 32, 壳)
写内存字节集 (-1, 结构＋ 2908, 取空白字节集 (12))

.子程序创建CALL, 整数型
.参数代码, 整数型
.局部变量 call地址, 整数型

call地址＝十六到十2 (#创建CALL)
置入代码 ({ 106, 1, 106, 0, 255, 117, 8, 255, 85, 252, 137, 69, 252 })
返回 (call地址)

.子程序换装call
.参数触发指针, 整数型
.参数装备代码, 整数型
.局部变量替换装备, 整数型

替换装备＝创建CALL (装备代码)
加密CALL (替换装备＋ 8, 1)
置入代码 ({ 139, 117, 8, 139, 22, 139, 130, 40, 7, 0, 0, 106, 26, 106, 1, 106, 255, 255, 117, 252, 137, 241, 255, 208 })

.子程序自由type, 字节集
.参数属性结构, 属性结构, 数组
.参数指定地址, , 可空
.局部变量地址
.局部变量计次1
.局部变量计次2
.局部变量计次3
.局部变量计次4
.局部变量当前地址
.局部变量数据地址1
.局部变量数据地址2

.如果 (是否为空 (指定地址))
地址＝申请内存 (4096, )
.否则
地址＝指定地址
.如果结束
当前地址＝地址＋取数组成员数 (属性结构) × 88
.计次循环首 (取数组成员数 (属性结构), 计次1)
数据地址1 ＝当前地址＋取数组成员数 (属性结构 [计次1].整数段) × 20
.计次循环首 (取数组成员数 (属性结构 [计次1].整数段), 计次2)
      .计次循环首 (取数组成员数 (属性结构 [计次1].整数段 [计次2].参数), 计次3)
         写内存整数型 (-1, 数据地址1, 属性结构 [计次1].整数段 [计次2].参数 [计次3])
         数据地址1 ＝数据地址1 ＋ 4
      .计次循环尾 ()
      写内存整数型 (-1, 当前地址, 当前地址＋ 16)
      写内存整数型 (-1, 当前地址＋ 16, 当前地址)
      写内存整数型 (-1, 当前地址＋ 4, 数据地址1 －取数组成员数 (属性结构 [计次1].整数段 [计次2].参数) × 4)  ' 写参数放在了前面所有要减
      写内存整数型 (-1, 当前地址＋ 8, 数据地址1)
      写内存整数型 (-1, 当前地址＋ 12, 数据地址1)
      当前地址＝当前地址＋ 20
.计次循环尾 ()
写内存整数型 (-1, 地址＋ (计次1 － 1) × 88, 地址＋ 16 ＋ (计次1 － 1) × 88)  ' 0
写内存整数型 (-1, 地址＋ 4 ＋ (计次1 － 1) × 88, 当前地址－ (计次2 － 1) × 20)  ' 4
写内存整数型 (-1, 地址＋ 8 ＋ (计次1 － 1) × 88, 当前地址)  ' 8
写内存整数型 (-1, 地址＋ 12 ＋ (计次1 － 1) × 88, 当前地址)  ' C
写内存整数型 (-1, 地址＋ 16 ＋ (计次1 － 1) × 88, 地址＋ (计次1 － 1) × 88)  ' 10
当前地址＝数据地址1
数据地址2 ＝当前地址＋取数组成员数 (属性结构 [计次1].小数段) × 20
.计次循环首 (取数组成员数 (属性结构 [计次1].小数段), 计次2)
      数据地址1 ＝数据地址2 ＋取数组成员数 (属性结构 [计次1].小数段 [计次2].小数) × 20
      .计次循环首 (取数组成员数 (属性结构 [计次1].小数段 [计次2].小数), 计次3)
         .计次循环首 (取数组成员数 (属性结构 [计次1].小数段 [计次2].小数 [计次3].参数), 计次4)
            写内存小数型 (-1, 数据地址1, 属性结构 [计次1].小数段 [计次2].小数 [计次3].参数 [计次4])
            数据地址1 ＝数据地址1 ＋ 4
         .计次循环尾 ()
         写内存整数型 (-1, 数据地址2, 数据地址2 ＋ 16)
         写内存整数型 (-1, 数据地址2 ＋ 16, 数据地址2)
         写内存整数型 (-1, 数据地址2 ＋ 4, 数据地址1 －取数组成员数 (属性结构 [计次1].小数段 [计次2].小数 [计次3].参数) × 4)  ' 写参数放在了前面所有要减
         写内存整数型 (-1, 数据地址2 ＋ 8, 数据地址1)
         写内存整数型 (-1, 数据地址2 ＋ 12, 数据地址1)
         数据地址2 ＝数据地址2 ＋ 20
      .计次循环尾 ()
      写内存整数型 (-1, 当前地址, 当前地址＋ 16)
      写内存整数型 (-1, 当前地址＋ 16, 当前地址)
      写内存整数型 (-1, 当前地址＋ 4, 数据地址2 －取数组成员数 (属性结构 [计次1].小数段 [计次2].小数) × 20)  ' 写参数放在了前面所有要减
      写内存整数型 (-1, 当前地址＋ 8, 数据地址2)
      写内存整数型 (-1, 当前地址＋ 12, 数据地址2)
      当前地址＝当前地址＋ 20
.计次循环尾 ()
写内存整数型 (-1, 地址＋ 20 ＋ (计次1 － 1) × 88, 地址＋ 36 ＋ (计次1 － 1) × 88)  ' 14
写内存整数型 (-1, 地址＋ 24 ＋ (计次1 － 1) × 88, 当前地址－ (计次2 － 1) × 20)  ' 18
写内存整数型 (-1, 地址＋ 28 ＋ (计次1 － 1) × 88, 当前地址)  ' 1C
写内存整数型 (-1, 地址＋ 32 ＋ (计次1 － 1) × 88, 当前地址)  ' 20
写内存整数型 (-1, 地址＋ 36 ＋ (计次1 － 1) × 88, 地址＋ 20 ＋ (计次1 － 1) × 88)  ' 24
写内存整数型 (-1, 地址＋ 40 ＋ (计次1 － 1) × 88, 地址＋ 56 ＋ (计次1 － 1) × 88)  ' 28
写内存整数型 (-1, 地址＋ 56 ＋ (计次1 － 1) × 88, 地址＋ 40 ＋ (计次1 － 1) × 88)  ' 38
.计次循环尾 ()
返回 (到字节集 (地址) ＋到字节集 (到整数 (地址＋取数组成员数 (属性结构) × 88)) ＋到字节集 (到整数 (地址＋取数组成员数 (属性结构) × 88)))

.子程序整数到浮点, 整数型
.参数待转换整数, 整数型
.局部变量 a, 小数型
.局部变量 b, 整数型

a ＝到小数 (待转换整数)
写到内存 (到字节集 (a), 取变量地址 (b), 取数据类型尺寸 (#整数型))
返回 (b)

.子程序重组BUFF

_打开当前进程 ()
重定义数组 (属性, 假, 1)  ' 定义属性个数
重定义数组 (属性 [1].整数段, 假, 1)  ' 定义整数个数
重定义数组 (属性 [1].整数段 [1].参数, 假, 2)  ' 整数参数长度
属性 [1].整数段 [1].参数 [1] ＝ 0  ' 冷却时间
属性 [1].整数段 [1].参数 [2] ＝ 1000  ' 频率
重定义数组 (属性 [1].小数段, 假, 1)  ' 定义小数段个数
重定义数组 (属性 [1].小数段 [1].小数, 假, 3)  ' type个数
重定义数组 (属性 [1].小数段 [1].小数 [1].参数, 假, 3)  ' 小数type1参数长度
属性 [1].小数段 [1].小数 [1].参数 [1] ＝ 1
属性 [1].小数段 [1].小数 [1].参数 [2] ＝ 0  ' 对象
属性 [1].小数段 [1].小数 [1].参数 [3] ＝ -1
重定义数组 (属性 [1].小数段 [1].小数 [2].参数, 假, 6)  ' 小数type2参数长度
属性 [1].小数段 [1].小数 [2].参数 [1] ＝ 2
属性 [1].小数段 [1].小数 [2].参数 [2] ＝ 0
属性 [1].小数段 [1].小数 [2].参数 [3] ＝ 1500000  ' 频率
属性 [1].小数段 [1].小数 [2].参数 [4] ＝ 0
属性 [1].小数段 [1].小数 [2].参数 [5] ＝ 0
属性 [1].小数段 [1].小数 [2].参数 [6] ＝ 0
重定义数组 (属性 [1].小数段 [1].小数 [3].参数, 假, 7)  ' 小数type7参数长度
属性 [1].小数段 [1].小数 [3].参数 [1] ＝ 7  ' 异常
属性 [1].小数段 [1].小数 [3].参数 [2] ＝ 13  ' 祝福
属性 [1].小数段 [1].小数 [3].参数 [3] ＝ 29  ' LV等级
属性 [1].小数段 [1].小数 [3].参数 [4] ＝ 100000
属性 [1].小数段 [1].小数 [3].参数 [5] ＝ 0  ' 智力
属性 [1].小数段 [1].小数 [3].参数 [6] ＝ 100000
属性 [1].小数段 [1].小数 [3].参数 [7] ＝ 0  ' 精神
数据＝自由type (属性)