• 590阅读
  • 1回复

精易模块5.6  .程序集 集_进程线程 [复制链接]

上一主题 下一主题
离线啊冲
 

精易模块5.6

.版本 2

.程序集 集_进程线程
.程序集变量 集_许可证数组, 线程许可证, , "0"

.子程序 进程_取程序路径, 文本型, 公开, 取指定进程的程序路径,成功返回程序路径,失败或进程不存在返回空文本
.参数 进程ID, 整数型
.局部变量 快照句柄, 整数型
.局部变量 模块信息, 精易_模块信息
.局部变量 路径, 文本型

快照句柄 = CreateToolhelp32Snapshot (8, 进程ID)
.判断开始 (进程ID = 4)
    CloseHandle (快照句柄)
    返回 (目录_取system32目录 ())
.判断 (快照句柄 = -1)
    返回 (“”)
.默认

.判断结束
模块信息.size = 1024
Module32First (快照句柄, 模块信息)
路径 = 到文本 (模块信息.模块完整路径)
.判断开始 (取文本左边 (路径, 11) = “\SystemRoot”)
    路径 = 读环境变量 (“SystemRoot”) + 子文本替换 (路径, “\SystemRoot”, “”, , 1, 假)
.判断 (取文本左边 (路径, 4) = “\??\”)
    路径 = 子文本替换 (路径, “\??\”, “”, , 1, 假)
.默认

.判断结束
CloseHandle (快照句柄)
返回 (路径)

.子程序 进程_暂停, , 公开, 将指定进程暂停(无返回值)
.参数 进程ID, 整数型, , 欲被暂停进程的进程ID
.参数 状态, 逻辑型, 可空, 可空为假:恢复进程   真:暂停进程
.局部变量 进程句柄, 整数型

进程句柄 = OpenProcess (2035711, 0, 进程ID)
.如果 (状态)
    ZwSuspendProcess (进程句柄)
.否则
    ZwResumeProcess (进程句柄)
.如果结束
CloseHandle (进程句柄)

.子程序 进程_结束, 逻辑型, 公开, 结束指定进程。成功返回真,失败返回假。本命令为初级命令
.参数 进程ID, 整数型, 可空, 欲结束的进程ID,如果为空将结束自己

.如果真 (是否为空 (进程ID))
    进程ID = 进程_取自进程ID ()
.如果真结束
返回 (TerminateProcess (OpenProcess (1, 0, 进程ID), 0) = 1)

.子程序 进程_结束1, 逻辑型, 公开, 结束指定进程。成功返回真,失败返回假。本命令为初级命令
.参数 进程名, 文本型, 可空, 欲结束的进程名,如果为空将结束自己
.参数 是否区分大小写, 逻辑型, 可空, 默认为不区分,真=区分

.如果真 (是否为空 (进程名))
    进程名 = 取执行文件名 ()
.如果真结束
返回 (TerminateProcess (OpenProcess (1, 0, 进程_名取ID (进程名, 是否区分大小写)), 0) = 1)

.子程序 进程_枚举, 整数型, 公开, 失败返回0,成功返回进程数量
.参数 进程名数组, 文本型, 参考 可空 数组, 返回的进程名 数组
.参数 进程ID数组, 整数型, 参考 可空 数组, 返回的进程ID 数组
.局部变量 信息, 精易_进程信息列表
.局部变量 进程快照, 整数型
.局部变量 进程句柄, 整数型

进程快照 = CreateToolhelp32Snapshot (15, 0)
.如果真 (进程快照 = 0)
    返回 (0)
.如果真结束
信息.dwSize = 1024
进程句柄 = Process32First (进程快照, 信息)
.判断开始 (是否为空 (进程名数组) = 假 且 是否为空 (进程ID数组) = 假)
    清除数组 (进程名数组)
    清除数组 (进程ID数组)
    .判断循环首 (进程句柄 ≠ 0)
        加入成员 (进程名数组, 到文本 (信息.进程名称))
        加入成员 (进程ID数组, 信息.进程ID)
        进程句柄 = Process32Next (进程快照, 信息)
    .判断循环尾 ()
.判断 (是否为空 (进程名数组) = 假)
    清除数组 (进程名数组)
    .判断循环首 (进程句柄 ≠ 0)
        加入成员 (进程名数组, 到文本 (信息.进程名称))
        进程句柄 = Process32Next (进程快照, 信息)
    .判断循环尾 ()
.默认
    清除数组 (进程ID数组)
    .判断循环首 (进程句柄 ≠ 0)
        加入成员 (进程ID数组, 信息.进程ID)
        进程句柄 = Process32Next (进程快照, 信息)
    .判断循环尾 ()
    CloseHandle (进程快照)
    返回 (取数组成员数 (进程ID数组))
.判断结束
CloseHandle (进程快照)
返回 (取数组成员数 (进程名数组))

.子程序 进程_取同名ID, 整数型, 公开, 取相同名称进程,成功返回进程id数量。返回-1表示失败。
.参数 进程名, 文本型
.参数 进程ID数组, 整数型, 可空 数组, 返回的进程ID 数组
.局部变量 信息, 精易_进程信息列表
.局部变量 进程快照, 整数型
.局部变量 是否存在, 整数型

进程快照 = CreateToolhelp32Snapshot (15, 0)
.如果真 (进程快照 ≠ 0)
    信息.dwSize = 1024
    是否存在 = Process32First (进程快照, 信息)
    .判断循环首 (是否存在 ≠ 0)
        .如果真 (到小写 (到文本 (信息.进程名称)) = 到小写 (进程名))
            加入成员 (进程ID数组, 信息.进程ID)
        .如果真结束
        是否存在 = Process32Next (进程快照, 信息)
    .判断循环尾 ()
    CloseHandle (进程快照)
    返回 (取数组成员数 (进程ID数组))
.如果真结束
返回 (-1)

.子程序 进程_ID是否有效, 逻辑型, 公开, 判断一个进程ID是否存在(有效)
.参数 进程ID, 整数型
.局部变量 pid, , , "1024"
.局部变量 cbNeeded
.局部变量 bool, 逻辑型
.局部变量 cnt, 整数型
.局部变量 i, 整数型
.局部变量 existence, 逻辑型

.如果真 (0 = 进程ID)
    返回 (假)
.如果真结束
bool = EnumProcesses (pid, 1024 × 2, cbNeeded)
.如果真 (bool)
    重定义数组 (pid, 真, cbNeeded ÷ 4)
    .计次循环首 (取数组成员数 (pid), i)
        .如果真 (pid  = 进程ID)
            existence = 真
        .如果真结束
        处理事件 ()
    .计次循环尾 ()
.如果真结束
返回 (existence)

.子程序 进程_取ID数组, 整数型, 公开, 取指定进程名称的所有进程的进程ID(返回进程ID数目,没有返回0)
.参数 进程名, 文本型, , 程序进程名
.参数 进程ID数组, 整数型, 参考 数组, 返回的进程ID 数组
.参数 区分大小写, 逻辑型, 可空, 默认不区分进程名大小写
.局部变量 信息, 精易_进程信息列表
.局部变量 进程快照, 整数型
.局部变量 进程句柄, 整数型

清除数组 (进程ID数组)
进程快照 = CreateToolhelp32Snapshot (15, 0)
.如果真 (进程快照 = 0)
    返回 (0)
.如果真结束
信息.dwSize = 1024
进程句柄 = Process32First (进程快照, 信息)
.判断开始 (区分大小写)
    .判断循环首 (进程句柄 ≠ 0)
        .如果真 (进程名 = 到文本 (信息.进程名称))
            加入成员 (进程ID数组, 信息.进程ID)
        .如果真结束
        进程句柄 = Process32Next (进程快照, 信息)
    .判断循环尾 ()

.默认
    .判断循环首 (进程句柄 ≠ 0)
        .如果真 (到小写 (进程名) = 到小写 (到文本 (信息.进程名称)))
            加入成员 (进程ID数组, 信息.进程ID)
        .如果真结束
        进程句柄 = Process32Next (进程快照, 信息)
    .判断循环尾 ()

.判断结束
CloseHandle (进程快照)
返回 (取数组成员数 (进程ID数组))

.子程序 进程_名取ID, 整数型, 公开, 通过进程名取进程ID;失败返回0
.参数 进程名, 文本型, , 取要进程ID的进程名
.参数 是否区分大小写, 逻辑型, 可空, 默认为不区分,真=区分
.局部变量 局_进程信息, 精易_进程信息列表
.局部变量 进程快照, 整数型
.局部变量 进程句柄, 整数型

进程快照 = CreateToolhelp32Snapshot (2, 0)
.如果真 (进程快照 = 0)
    返回 (0)
.如果真结束
局_进程信息.dwSize = 512
进程句柄 = Process32First (进程快照, 局_进程信息)
.判断开始 (是否区分大小写)
    .判断循环首 (进程句柄 ≠ 0)
        .如果真 (到文本 (局_进程信息.进程名称) = 进程名)
            CloseHandle (进程快照)
            返回 (局_进程信息.进程ID)
        .如果真结束
        进程句柄 = Process32Next (进程快照, 局_进程信息)
    .判断循环尾 ()
.默认
    .判断循环首 (进程句柄 ≠ 0)
        .如果真 (到小写 (到文本 (局_进程信息.进程名称)) = 到小写 (进程名))
            CloseHandle (进程快照)
            返回 (局_进程信息.进程ID)
        .如果真结束
        进程句柄 = Process32Next (进程快照, 局_进程信息)
    .判断循环尾 ()
.判断结束
CloseHandle (进程快照)
返回 (0)

.子程序 进程_打开, 整数型, 公开, 通过目标窗口句柄取进程句柄,成功就返回进程句柄
.参数 对象句柄, 整数型, , 对象的窗口句柄
.局部变量 进程句柄, 整数型
.局部变量 dwProcessID, 整数型

GetWindowThreadProcessId (对象句柄, dwProcessID)
进程句柄 = OpenProcess (2035711, 0, dwProcessID)
返回 (进程句柄)

.子程序 进程_打开1, 整数型, 公开, 通过目标进程ID取进程句柄,成功就返回进程句柄
.参数 进程ID, 整数型, , 目标进程ID

返回 (OpenProcess (2035711, 0, 进程ID))

.子程序 进程_关闭, 逻辑型, 公开, 关闭已经打开的操作句柄
.参数 进程句柄, 整数型, , 进程句柄,线程句柄

返回 (CloseHandle (进程句柄))

.子程序 进程_创建, 整数型, 公开, 创建一个程序进程(成功返回进程ID,失败返回0)
.参数 程序路径, 文本型, , 欲创建进程的执行路径
.参数 命令行, 文本型, 可空, 附加上程序路径后的命令行参数
.参数 运行目录, 文本型, 可空, 通常留空,特殊情况下使用
.参数 进程结构, 精易_进程结构, 参考 可空, 接收进程结构信息的变量,如果不为空,产品的句柄用CloseHandle函数释放
.局部变量 窗口结构, StartupInfo

.如果真 (运行目录 = “”)
    运行目录 = 取文本左边 (程序路径, 倒找文本 (程序路径, “\”, , 假))
.如果真结束
CreateProcessA (程序路径, 命令行, 0, 0, 0, 0, 0, 运行目录, 窗口结构, 进程结构)
.如果真 (是否为空 (进程结构))
    CloseHandle (进程结构.进程句柄)
    CloseHandle (进程结构.线程句柄)
.如果真结束
返回 (进程结构.进程标识符)

.子程序 进程_名取句柄, 整数型, 公开, 通过进程名取对应的窗口句柄;成功返回窗口句柄,失败返回0,返回-1表示找到进程。
.参数 进程名, 文本型, , 要取窗口句柄的进程名;
.局部变量 pid
.局部变量 hwnd

pid = 进程_名取ID (进程名)
.如果真 (pid ≠ 0)
    返回 (进程_ID取窗口句柄 (pid))
.如果真结束
返回 (-1)

.子程序 进程_取自进程ID, 整数型, 公开, 取自身的进程ID,成功返回进程ID;失败返回0

返回 (GetCurrentProcessId ())

.子程序 进程_ID取进程名, 文本型, 公开, 通过进程ID取得该进程执行文件名,也就是进程名;
.参数 参数_进程ID, 整数型, , 该进程的ID;
.局部变量 hProcessSnap, 整数型
.局部变量 bool
.局部变量 pe32, 精易_进程信息列表
.局部变量 name, 文本型

hProcessSnap = CreateToolhelp32Snapshot (2, 0)  ' #TH32CS_SNAPPROCESS
pe32.dwSize = 296
bool = Process32Next (hProcessSnap, pe32)
.判断循环首 (bool = 1)
    .如果真 (pe32.进程ID = 参数_进程ID)
        name = 到文本 (pe32.进程名称)
        跳出循环 ()
    .如果真结束
    bool = Process32Next (hProcessSnap, pe32)
.判断循环尾 ()
CloseHandle (hProcessSnap)
返回 (name)

.子程序 进程_ID取窗口句柄, 整数型, 公开, 通过进程ID取得该进程的窗口句柄,超时则返回零
.参数 进程ID, 整数型, , 该进程的ID;
.参数 窗口标题, 文本型, 可空, 模糊参数 如果为空,忽略此参数
.参数 窗口类名, 文本型, 可空, 模糊参数 如果为空,忽略此参数
.参数 超时, , 可空, 为空则无限循环
.局部变量 局_超时时间
.局部变量 局_开始时间
.局部变量 局_窗口句柄
.局部变量 局_进程ID
.局部变量 局_标题, 文本型
.局部变量 局_类名, 文本型

局_开始时间 = 取启动时间 ()
局_超时时间 = 选择 (是否为空 (超时) 或 超时 = -1, 31536000, 超时)
.判断循环首 (取启动时间 () - 局_开始时间 < 局_超时时间)
    局_窗口句柄 = FindWindowExA_文本 (0, 局_窗口句柄, 字符 (0), 字符 (0))
    .如果真 (IsWindow (局_窗口句柄) = 1)
        .如果真 (IsWindowVisible (局_窗口句柄))
            局_进程ID = 窗口_句柄取进程ID (局_窗口句柄)
            .如果真 (局_进程ID = 进程ID)
                局_标题 = 窗口_取标题 (局_窗口句柄)
                局_类名 = 窗口_取类名 (局_窗口句柄)
                .如果真 (寻找文本 (局_标题, 窗口标题, , 假) ≠ -1)
                    返回 (局_窗口句柄)
                .如果真结束
                .如果真 (寻找文本 (局_类名, 窗口类名, , 假) ≠ -1)
                    返回 (局_窗口句柄)
                .如果真结束
                .如果真 (是否为空 (窗口标题) 或 是否为空 (窗口类名))
                    返回 (局_窗口句柄)
                .如果真结束

            .如果真结束

        .如果真结束

    .如果真结束
    处理事件 ()
.判断循环尾 ()
返回 (0)

.子程序 进程_取线程数, 整数型, 公开, 通过进程ID或进程名获取指定进程线程数。
.参数 进程ID或进程名, 文本型
.局部变量 hProcessSnap, 整数型
.局部变量 bool
.局部变量 pe32, 精易_进程信息列表
.局部变量 cntThreads

hProcessSnap = CreateToolhelp32Snapshot (2, 0)  ' #TH32CS_SNAPPROCESS
pe32.dwSize = 296
bool = Process32Next (hProcessSnap, pe32)
.判断循环首 (bool = 1)
    .判断开始 (到整数 (进程ID或进程名) ≠ 0)
        .如果真 (到整数 (进程ID或进程名) = pe32.进程ID)
            cntThreads = pe32.cntThreads
            跳出循环 ()
        .如果真结束

    .判断 (到小写 (进程ID或进程名) = 到小写 (到文本 (pe32.进程名称)))
        cntThreads = pe32.cntThreads
        跳出循环 ()
    .默认

    .判断结束
    bool = Process32Next (hProcessSnap, pe32)
.判断循环尾 ()
CloseHandle (hProcessSnap)
返回 (cntThreads)

.子程序 进程_ID取模块, 整数型, 公开, 失败为0,成功返回模块数量(该命令为高级成员命令)
.参数 进程ID, 整数型, 可空, 为空 则取当前进程模块
.参数 模块信息数组, 精易_模块信息, 参考 可空 数组, 返回的模块信息 数组
.局部变量 快照句柄, 整数型
.局部变量 模块信息, 精易_模块信息
.局部变量 进程句柄, 整数型

清除数组 (模块信息数组)
快照句柄 = CreateToolhelp32Snapshot (8, 进程ID)
.如果真 (快照句柄 = 0)
    返回 (0)
.如果真结束
模块信息.size = 1024
进程句柄 = Module32First (快照句柄, 模块信息)
.判断循环首 (进程句柄 ≠ 0)
    加入成员 (模块信息数组, 模块信息)
    进程句柄 = Module32Next (快照句柄, 模块信息)
.判断循环尾 ()
CloseHandle (快照句柄)
返回 (取数组成员数 (模块信息数组))

.子程序 进程_是否存在, 逻辑型, 公开, 判断指定进程是否存在(此判断与进程其它信息无关联)(存在返回真,不存在或失败返回假)
.参数 进程名, 文本型, , 欲检测的进程名
.参数 是否区分大小写, 逻辑型, 可空, 默认为不区分,真=区分
.局部变量 信息, 精易_进程信息列表
.局部变量 进程快照, 整数型
.局部变量 进程句柄, 整数型

进程快照 = CreateToolhelp32Snapshot (15, 0)
.如果真 (进程快照 = 0)
    返回 (假)
.如果真结束
信息.dwSize = 1024
进程句柄 = Process32First (进程快照, 信息)
.判断开始 (是否区分大小写)
    .判断循环首 (进程句柄 ≠ 0)
        .判断开始 (进程名 = 到文本 (信息.进程名称))
            CloseHandle (进程快照)
            返回 (真)
        .默认
            进程句柄 = Process32Next (进程快照, 信息)
        .判断结束

    .判断循环尾 ()
.默认
    进程名 = 到小写 (进程名)
    .判断循环首 (进程句柄 ≠ 0)
        .判断开始 (进程名 = 到小写 (到文本 (信息.进程名称)))
            CloseHandle (进程快照)
            返回 (真)
        .默认
            进程句柄 = Process32Next (进程快照, 信息)
        .判断结束

    .判断循环尾 ()
.判断结束
CloseHandle (进程快照)
返回 (假)

.子程序 进程_提升权限, 逻辑型, 公开, 提升进程到指定权限( #备份  #启动  #关机  #调试)
.参数 目标进程ID, 整数型, 可空, 为空表示当前进程ID
.参数 权限类别, 文本型, 可空, 为空:#调试( #备份  #启动  #关机  #调试)
.局部变量 hdlProcessHandle, 整数型
.局部变量 hdlTokenHandle, 整数型
.局部变量 tmpLuid, 精易_进程令牌
.局部变量 tkp, 精易_进程权限
.局部变量 tkpNewButIgnored, 精易_进程权限
.局部变量 返回值, 逻辑型

.如果真 (取操作系统类别 () ≠ 3)
    返回 (假)
.如果真结束
.如果真 (是否为空 (目标进程ID))
    hdlProcessHandle = GetCurrentProcess ()
.如果真结束
.如果真 (是否为空 (权限类别))
    权限类别 = #调试
.如果真结束
OpenProcessToken (hdlProcessHandle, 40, hdlTokenHandle)
LookupPrivilegeValueA (“”, 权限类别, tmpLuid)
tkp.PrivilegeCount = 1
tkp.lowpart = tmpLuid.低三十二位
tkp.highpart = tmpLuid.高三十二位
tkp.Attributes = 2
返回值 = _获取令牌特权 (hdlTokenHandle, 0, tkp, 28, tkpNewButIgnored, 0)
CloseHandle (hdlTokenHandle)
返回 (返回值)

.子程序 进程_取模块句柄, 整数型, 公开
.参数 模块名, 文本型, 可空

返回 (GetModuleHandleA (模块名))

.子程序 进程_取启动参数, 文本型, 公开

返回 (GetCommandLineA ())

.子程序 进程_提升权限到Debug, 逻辑型, 公开, 成功返回真,把一个进程的权限提升到调试级权限
.参数 进程ID, 整数型, 可空, 可空为提升当前进程
.局部变量 进程句柄, 整数型
.局部变量 令牌句柄, 整数型
.局部变量 destLuid, 精易_进程令牌
.局部变量 进程权限, 精易_进程权限
.局部变量 返回值, 逻辑型

.如果真 (是否为空 (进程ID))
    进程ID = GetCurrentProcessId ()
.如果真结束
进程句柄 = OpenProcess (2035711, 0, 进程ID)
OpenProcessToken (进程句柄, 983551, 令牌句柄)
_获取权限令牌 (0, “SeDebugPrivilege”, destLuid)
进程权限.PrivilegeCount = 1
进程权限.Attributes = 2
进程权限.lowpart = destLuid.低三十二位
进程权限.highpart = destLuid.高三十二位
返回值 = AdjustTokenPrivileges (令牌句柄, 假, 进程权限, 0, 0, 0)
CloseHandle (进程句柄)
返回 (返回值)

.子程序 进程_取优先级, 整数型, 公开, 特殊进程需要特权,检索指定的进程的优先级。返回值:0=最高,1=高于标准,2=实时,3=标准,4=低于标准,5=低,返回-1表示无权限访问进程。
.参数 进程ID, 整数型, 可空, 欲设置的进程标识符,可为空,即自身进程。
.局部变量 hProcess
.局部变量 Class
.局部变量 Type

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (1024, 0, 进程ID))
.如果真 (hProcess = 0)
    返回 (-1)
.如果真结束
Class = GetPriorityClass (hProcess)
.判断开始 (Class = 256)  ' #REALTIME_PRIORITY_CLASS =256
    Type = 2
.判断 (Class = 128)  ' #HIGH_PRIORITY_CLASS =128
    Type = 0
.判断 (Class = 32768)  ' #ABOVE_NORMAL_PRIORITY_CLASS =32768
    Type = 1
.判断 (Class = 32)  ' #NORMAL_PRIORITY_CLASS  =32
    Type = 3
.判断 (Class = 16384)  ' #BELOW_NORMAL_PRIORITY_CLASS  =16384
    Type = 4
.判断 (Class = 64)  ' #IDLE_PRIORITY_CLASS  =64
    Type = 5
.默认
    Type = 0
.判断结束
CloseHandle (hProcess)
返回 (Type)

.子程序 进程_置优先级, 逻辑型, 公开, 特殊进程需要特权,设置一个进程的优先级别,成功返回真,失败返回假。
.参数 进程ID, 整数型, 可空, 欲设置的进程标识符,可为空,即自身进程。
.参数 进程级别, 整数型, 可空, 可为空,默认即0最高。0=最高,1=高于标准,2=实时,3=标准,4=低于标准,5=低
.局部变量 hProcess
.局部变量 Bool, 逻辑型

.如果真 (进程级别 = 0)
    进程级别 = 128  ' #HIGH_PRIORITY_CLASS
.如果真结束
.如果真 (进程级别 = 1)
    进程级别 = 32768  ' #ABOVE_NORMAL_PRIORITY_CLASS
.如果真结束
.如果真 (进程级别 = 2)
    进程级别 = 256  ' #REALTIME_PRIORITY_CLASS
.如果真结束
.如果真 (进程级别 = 3)
    进程级别 = 32  ' #NORMAL_PRIORITY_CLASS
.如果真结束
.如果真 (进程级别 = 4)
    进程级别 = 16384  ' #BELOW_NORMAL_PRIORITY_CLASS
.如果真结束
.如果真 (进程级别 = 5)
    进程级别 = 64  ' #IDLE_PRIORITY_CLASS
.如果真结束
.如果真 (是否为空 (进程级别) 或 进程级别 = 0)
    进程级别 = 128
.如果真结束
hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (512, 0, 进程ID))  ' #PROCESS_SET_INFORMATION
.如果真 (hProcess = 0)
    返回 (假)
.如果真结束
Bool = SetPriorityClass (hProcess, 进程级别)
CloseHandle (hProcess)
返回 (Bool)

.子程序 进程_取句柄数, 整数型, 公开, 特殊进程需要特权,获取指定进程句柄数量,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 Count, 整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessHandleCount (hProcess, Count), Count, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO读取计数, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO读取计数,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.读取操作数量, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO读取字节, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO读取字节数,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.读取字节数, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO其它计数, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO其它计数,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.其它读写操作数量, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO其它字节, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO其它字节,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.其它读写操作字节, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO写入计数, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO写入计数,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.写入操作数量, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取IO写入字节, 长整数型, 公开, 特殊进程需要特权,获取指定进程IO写入字节,与XP系统任务管理器功能一样,失败返回-1。
.参数 进程ID, , 可空, 可为空,默认即当前进程。
.局部变量 hProcess
.局部变量 lpIoCounters, IO_COUNTERS
.局部变量 Count, 长整数型

hProcess = 选择 (是否为空 (进程ID), GetCurrentProcess (), OpenProcess (2035711, 0, 进程ID))
Count = 选择 (GetProcessIoCounters (hProcess, lpIoCounters), lpIoCounters.写入字节数, -1)
CloseHandle (hProcess)
返回 (Count)

.子程序 进程_取父ID, 整数型, 公开, 根据进程名或进程ID取出进程父ID,失败返回-1。
.参数 参_ID或名称, 文本型, , 进程PID或进程名称
.局部变量 局_返回值
.局部变量 局_系统进程, SYSTEM_PROCESS_INFORMATION
.局部变量 局_缓冲区
.局部变量 局_所需尺寸
.局部变量 局_下条数据, 整数型
.局部变量 局_进程名, 文本型

ZwQuerySystemInformation (#SystemProcessInformation, 0, 0, 局_所需尺寸)
局_缓冲区 = GlobalAlloc (64, 局_所需尺寸)
局_返回值 = ZwQuerySystemInformation (#SystemProcessInformation, 局_缓冲区, 局_所需尺寸, 局_所需尺寸)
.如果真 (局_返回值 = 0)
    局_下条数据 = 局_缓冲区
    CopyMemory_system_process_information (局_系统进程, 局_缓冲区, 184)
    .判断循环首 (局_系统进程.NextEntryDelta ≠ 0)
        局_下条数据 = 局_下条数据 + 局_系统进程.NextEntryDelta
        CopyMemory_system_process_information (局_系统进程, 局_下条数据, 184)
        局_进程名 = 编码_Unicode到Ansi (指针到字节集 (局_系统进程.ImageName.缓冲区, 局_系统进程.ImageName.长度))
        .如果真 (文本比较 (局_进程名, 参_ID或名称, 假) = 0 或 到整数 (参_ID或名称) = 局_系统进程.ProcessId)
            返回 (局_系统进程.InheritedFromProcessId)
        .如果真结束
        处理事件 ()
    .判断循环尾 ()
.如果真结束
GlobalFree (局_缓冲区)
返回 (-1)

.子程序 进程_守护, 逻辑型, 公开, 前台版会在运行目录下生成AutoRunApp.vbs隐藏文件,后台版会在运行目录下生成AutoRunApp.bat隐藏文件,注意:后台版需手动结束wscript.exe进程
.参数 参_程序路径, 文本型
.参数 参_后台守护, 逻辑型, 可空, 为假则以控制台前台显示
.局部变量 局_临时文本, 文本型
.局部变量 局_路径, 文本型
.局部变量 局_返回值
.局部变量 局_名字, 文本型
.局部变量 局_标识, 文本型

.如果真 (取文本长度 (删首尾空 (参_程序路径)) > 0)
    局_名字 = 选择 (参_后台守护, 到文本 ({ 92, 65, 117, 116, 111, 82, 117, 110, 65, 112, 112, 46, 118, 98, 115 }), 到文本 ({ 92, 65, 117, 116, 111, 82, 117, 110, 65, 112, 112, 46, 98, 97, 116 }))
    局_标识 = 到文本 ({ 65, 117, 116, 111, 82, 117, 110, 65, 112, 112 })
    .如果真 (OpenEventA (2031619, 假, 局_标识) ≠ 0)
        返回 (假)
    .如果真结束
    CreateEvent (0, 假, 假, 局_标识)
    局_临时文本 = 选择 (参_后台守护, #AuAppVBs, #AuAppBat)
    局_临时文本 = 子文本替换 (局_临时文本, “程序名”, 文件_取文件名 (参_程序路径, 真), , , 真)
    参_程序路径 = 文件_到短文件名 (参_程序路径)
    局_临时文本 = 子文本替换 (局_临时文本, “程序路径”, 参_程序路径, , , 真)
    局_路径 = 取运行目录 () + 局_名字
    写到文件 (局_路径, 到字节集 (局_临时文本))
    置文件属性 (局_路径, 2)
    局_返回值 = ShellExecuteA (GetActiveWindow (), “”, 局_路径, “”, “”, 5)
    返回 (局_返回值 ≥ 32)
.如果真结束
返回 (假)

.子程序 线程_DLL注入, 逻辑型, 公开
.参数 目标进程ID, 整数型, , 要注入的进程ID
.参数 要注入的DLL文件名, 文本型, , DLL名称
.局部变量 长度, 整数型
.局部变量 hvir, 整数型
.局部变量 hprocess, 整数型
.局部变量 hmod, 整数型
.局部变量 hThread, 整数型

hprocess = OpenProcess (2035711, 0, 目标进程ID)
长度 = 取文本长度 (要注入的DLL文件名) + 1
hvir = VirtualAllocEx (hprocess, 0, 长度, 4096, 4)
WriteProcessMemory_字节集 (hprocess, hvir, 到字节集 (要注入的DLL文件名), 长度, 0)
hmod = GetProcAddress1 (GetModuleHandleA (“Kernel32”), “LoadLibraryA”)
hThread = CreateRemoteThread (hprocess, 0, 0, hmod, hvir, 0, 0)
.如果真 (hThread = 0)
    返回 (假)
.如果真结束
WaitForSingleObject (hThread, 4294967295)
VirtualFreeEx (hprocess, hvir, 0, 32768)
CloseHandle (hThread)
CloseHandle (hprocess)
返回 (真)

.子程序 线程_DLL卸载, 逻辑型, 公开
.参数 目标进程ID, 整数型
.参数 要注入的卸载文件名, 文本型
.局部变量 hprocess, 整数型
.局部变量 hvir, 整数型
.局部变量 hmod, 整数型
.局部变量 hThread, 整数型
.局部变量 DLL句柄, 整数型
.局部变量 返回值, 整数型
.局部变量 长度, 整数型
.局部变量 hThread1, 整数型

hprocess = OpenProcess (2035711, 0, 目标进程ID)
.如果真 (hprocess = 0)
    返回 (假)
.如果真结束
长度 = 取文本长度 (要注入的卸载文件名) + 1
hvir = VirtualAllocEx (hprocess, 0, 长度, 4096, 4)
WriteProcessMemory_字节集 (hprocess, hvir, 到字节集 (要注入的卸载文件名), 长度, 0)
hmod = GetProcAddress1 (GetModuleHandleA (“Kernel32”), “GetModuleHandleA”)
hThread = CreateRemoteThread (hprocess, 0, 0, hmod, hvir, 0, 0)
WaitForSingleObject (hThread, 4294967295)
GetExitCodeThread (hThread, DLL句柄)  ' 得到DLL句柄
VirtualFreeEx (hprocess, hvir, 0, 32768)
CloseHandle (hThread)
.如果真 (DLL句柄 = 0)
    返回 (假)
.如果真结束
' -----------------------------------------------
hmod = GetProcAddress1 (GetModuleHandleA (“Kernel32”), “FreeLibrary”)
hThread1 = CreateRemoteThread (hprocess, 0, 0, hmod, DLL句柄, 0, 0)  ' 执行FreeLibrary, 参数为模块句柄
WaitForSingleObject (hThread1, 4294967295)
GetExitCodeThread (hThread, 返回值)
CloseHandle (hThread1)
CloseHandle (hprocess)
.如果 (返回值 ≠ 0)
    返回 (真)
.否则
    返回 (假)
.如果结束


.子程序 线程_取中止线程退出代码, 整数型, 公开, 返回0表示该线程不存在(或句柄已被关闭),1线程已经执行完毕,2为正在运行,其他不论
.参数 线程句柄, 整数型
.局部变量 返回值, 整数型

.判断开始 (GetExitCodeThread (线程句柄, 返回值) = 0)
    返回 (0)
.判断 (返回值 = 259)
    返回 (2)
.默认
    返回 (1)
.判断结束


.子程序 线程_打开, 整数型, 公开, 成功返回线程句柄,失败返回0
.参数 线程ID, 整数型, 可空, 目标线程ID

返回 (OpenThread (2032639, 0, 线程ID))

.子程序 线程_取自线程ID, 整数型, 公开, GetCurrentThreadId,获取当前线程一个唯一的线程标识符

返回 (GetCurrentThreadId ())

.子程序 线程_取自线程句柄, 整数型, 公开, GetCurrentThread,获取当前线程的一个伪句柄

返回 (GetCurrentThread ())

.子程序 线程_初始化COM库, , 公开, 有时执行线程的时候,会自动关闭,此时,可以在多线程的程序里创建COM对象前先初始化,一个线程只能调用一次

CoInitialize (0)

.子程序 线程_取消COM库, , 公开, 取消COM库的初始化,如果你在线程头部加入了 线程_初始化COM库 请在尾部加入此命令

CoUninitialize ()

.子程序 线程_取ID, 整数型, 公开, 成功返回指定窗口的线程ID
.参数 窗口句柄, 整数型, , 指定窗口句柄
.局部变量 进程ID, 整数型, , , 用于装载进程ID的变量

返回 (GetWindowThreadProcessId (窗口句柄, 进程ID))

.子程序 线程_销毁, 逻辑型, 公开, 强制终止正在运行的线程,成功返回真,失败返回假.
.参数 线程句柄, 整数型, , 创建线程返回的句柄
.局部变量 lpExitCode, 整数型

GetExitCodeThread (线程句柄, lpExitCode)
返回 (TerminateThread (线程句柄, lpExitCode))

.子程序 线程_关闭句柄, 逻辑型, 公开, 关闭一个线程句柄,关闭后线程继续运行,但无法对该句柄进行操作。
.参数 线程句柄

返回 (CloseHandle (线程句柄))

.子程序 线程_启动, 整数型, 公开, 成功返回线程句柄,失败返回0
.参数 要启动的子程序, 子程序指针
.参数 要传去子程序的参数, 整数型, 可空, 往子程序里面传递一个整数型的参数
.参数 线程ID, 整数型, 参考 可空, 请提供一个整数型的变量,用于存放新创建的线程ID。

返回 (CreateThread (0, 0, 要启动的子程序, 要传去子程序的参数, 0, 线程ID))

.子程序 线程_启动1, 整数型, 公开, 成功返回线程句柄,失败返回0
.参数 要启动的子程序, 整数型, , 如果是子程序指针,请直接使用到数值() 命令进行转换后再传入
.参数 要传去子程序的参数, 整数型, 可空, 往子程序里面传递一个整数型的参数
.参数 线程ID, 整数型, 参考 可空, 请提供一个整数型的变量,用于存放新创建的线程ID。

返回 (CreateThread1 (0, 0, 要启动的子程序, 要传去子程序的参数, 0, 线程ID))

.子程序 线程_启动多参_整数型, 整数型, 公开, 成功返回线程句柄,失败返回0。
.参数 子程序指针, 子程序指针
.参数 参数1, 整数型, 可空, 线程传入参数1
.参数 参数2, 整数型, 可空, 线程传入参数2
.参数 参数3, 整数型, 可空, 线程传入参数3
.参数 参数4, 整数型, 可空, 线程传入参数4
.参数 参数5, 整数型, 可空, 线程传入参数5
.参数 线程ID, 整数型, 参考 可空, 请提供一个整数型的变量,用于存放新创建的线程ID。
.局部变量 局_文本, 文本型
.局部变量 局_线程句柄, 整数型

局_文本 = 到文本 (到数值 (子程序指针)) + “,” + 到文本 (参数1) + “,” + 到文本 (参数2) + “,” + 到文本 (参数3) + “,” + 到文本 (参数4) + “,” + 到文本 (参数5) + “,”
局_线程句柄 = CreateThread (0, 0, &内部_启动多参_整数型_过程, 取指针地址_文本型 (局_文本), 0, 线程ID)
Sleep (1)
返回 (局_线程句柄)

.子程序 内部_启动多参_整数型_过程
.参数 参数, 整数型
.局部变量 局_数组, 文本型, , "0"

局_数组 = 分割文本 (指针到文本 (参数), , 6)
.如果真 (取数组成员数 (局_数组) = 6)
    程序_Call (到数值 (局_数组 [1]), 到数值 (局_数组 [2]), 到数值 (局_数组 [3]), 到数值 (局_数组 [4]), 到数值 (局_数组 [5]), 到数值 (局_数组 [6]))
.如果真结束


.子程序 线程_启动多参_文本型, 整数型, 公开, 成功返回线程句柄
.参数 子程序指针, 子程序指针
.参数 整数1, 整数型, 可空, 线程传入参数1
.参数 文本1, 文本型, 可空, 线程传入参数2
.参数 文本2, 文本型, 可空, 线程传入参数3
.参数 文本3, 文本型, 可空, 线程传入参数4
.参数 文本4, 文本型, 可空, 线程传入参数5
.参数 线程ID, 整数型, 参考 可空, 请提供一个整数型的变量,用于存放新创建的线程ID。
.局部变量 局_线程句柄, 整数型
.局部变量 局_参数, 文本型, , "6"

局_参数 [1] = 到文本 (到整数 (子程序指针))
局_参数 [2] = 到文本 (整数1)
局_参数 [3] = 文本1
局_参数 [4] = 文本2
局_参数 [5] = 文本3
局_参数 [6] = 文本4
局_线程句柄 = CreateThread_Strings (0, 0, &内部_启动多参_文本型_过程, 局_参数, 0, 线程ID)
Sleep (1)
返回 (局_线程句柄)

.子程序 内部_启动多参_文本型_过程, , , 内部调用
.参数 参数, 整数型
.局部变量 局_数组, 文本型, , "6"

局_数组 [1] = 指针到文本 (取字节集数据 (指针到字节集 (参数, 4), #整数型, ))
局_数组 [2] = 指针到文本 (取字节集数据 (指针到字节集 (参数 + 4, 4), #整数型, ))
局_数组 [3] = 指针到文本 (取字节集数据 (指针到字节集 (参数 + 8, 4), #整数型, ))
局_数组 [4] = 指针到文本 (取字节集数据 (指针到字节集 (参数 + 12, 4), #整数型, ))
局_数组 [5] = 指针到文本 (取字节集数据 (指针到字节集 (参数 + 16, 4), #整数型, ))
局_数组 [6] = 指针到文本 (取字节集数据 (指针到字节集 (参数 + 20, 4), #整数型, ))
.如果真 (到整数 (局_数组 [1]) > 0)
    程序_Call (到数值 (局_数组 [1]), 到数值 (局_数组 [2]), 取指针地址_文本型 (局_数组 [3]), 取指针地址_文本型 (局_数组 [4]), 取指针地址_文本型 (局_数组 [5]), 取指针地址_文本型 (局_数组 [6]))
.如果真结束


.子程序 线程_创建许可证, 线程许可证, 公开, 创建并返回一个进入许可证数值,此许可证值用作进入程序中的指定许可代码区,以避免多线程冲突
.局部变量 进入许可证, 线程许可证

InitializeCriticalSection (进入许可证)
加入成员 (集_许可证数组, 进入许可证)
返回 (进入许可证)

.子程序 线程_删除许可证, , 公开, 删除由"创建进入许可证"命令所创建返回的进入许可证(该命令会在本类被销毁时自动被调用)
.参数 进入许可证, 线程许可证, 可空, 留空则删除所有许可证
.局部变量 i, 整数型

.如果 (是否为空 (进入许可证))
    .计次循环首 (取数组成员数 (集_许可证数组), i)
        DeleteCriticalSection (集_许可证数组 )
    .计次循环尾 ()
    清除数组 (集_许可证数组)
.否则
    DeleteCriticalSection (进入许可证)
.如果结束


.子程序 线程_进入许可区, , 公开, 根据已经创建的许可证进入指定许可代码区,在此线程未退出之前,其它线程如要通过同一个进入许可证进入该许可代码区则必须先等待此线程退出许可代码区,从而保证了指定许可代码区在任何时候都只能有一条线程进入并执行
.参数 进入许可证, 线程许可证

EnterCriticalSection (进入许可证)

.子程序 线程_退出许可区, , 公开, 指示当前线程将退出许可代码区,并允许其它使用同一进入许可证的线程进入此许可代码区
.参数 进入许可证, 线程许可证

LeaveCriticalSection (进入许可证)

.子程序 线程_等待, 逻辑型, 公开, 等待一个线程,返回真表示线程运行结束,返回假表示已超时。
.参数 线程句柄, 整数型
.参数 超时, 整数型, 可空, 留空,则无限等待
.局部变量 ret, 整数型
.局部变量 时间, 整数型

.如果真 (超时 = 0)
    超时 = -1
.如果真结束
时间 = 取启动时间 ()
.循环判断首 ()
    ret = MsgWaitForMultipleObjects (1, 线程句柄, 假, 超时, 1215)
    .如果真 (超时 ≠ -1)
        .如果真 (取启动时间 () - 时间 ≥ 超时)
            ret = 258
        .如果真结束

    .如果真结束
    处理事件 ()
.循环判断尾 (ret ≠ 0 且 ret ≠ 258)
返回 (ret = 0)

.子程序 线程_挂起, 整数型, 公开, 将指定线程的执行挂起,注意,同一个线程可以被挂起多次,如果挂起多次,就要恢复多次。
.参数 线程句柄, 整数型, , 要等待的线程句柄,用 线程_启动() 返回的;

返回 (SuspendThread (线程句柄))

.子程序 线程_恢复, 整数型, 公开, 恢复执行挂起的一个线程。
.参数 线程句柄, 整数型, , 要等待的线程句柄,用 线程_启动() 返回的;

返回 (ResumeThread (线程句柄))

.子程序 线程_枚举, 整数型, 公开, 枚举指定进程ID中所有线程列表,成功返回线程数量,失败返回零。
.参数 进程ID
.参数 线程列表, , 数组, 变量储存返回值。
.局部变量 局_线程快照
.局部变量 局_线程信息, 线程入口结构
.局部变量 局_返回值, 逻辑型

局_线程快照 = CreateToolhelp32Snapshot (4, 进程ID)
.如果真 (局_线程快照 > 0)
    清除数组 (线程列表)
    局_线程信息.结构大小 = 28
    局_返回值 = Thread32First (局_线程快照, 局_线程信息)
    .判断循环首 (局_返回值)
        .如果真 (局_线程信息.父进程ID = 进程ID)
            加入成员 (线程列表, 局_线程信息.线程ID)
        .如果真结束
        局_返回值 = Thread32Next (局_线程快照, 局_线程信息)
    .判断循环尾 ()
.如果真结束
CloseHandle (局_线程快照)
返回 (取数组成员数 (线程列表))

.子程序 线程_置CPU, 整数型, 公开, 设置线程在指定CPU上运行
.参数 参_线程句柄
.参数 参_CPU序号, , , CPU序号的或运算值:1(0001)代表只运行在CPU1,2(0010)代表只运行在CPU2,3(0011)代表可以运行在CPU1和CPU2,以此类推。

返回 (SetThreadAffinityMask (参_线程句柄, 参_CPU序号))

.子程序 线程_取状态, 整数型, 公开, 0=线程已结束  1=线程正在运行  -1=线程句柄已失效或销毁
.参数 参_线程句柄, 整数型
.局部变量 m_WaitCode, 整数型

m_WaitCode = WaitForSingleObject (参_线程句柄, 0)
.判断开始 (m_WaitCode = 258)
    返回 (1)
.判断 (m_WaitCode = -1)
    返回 (-1)
.默认
    返回 (m_WaitCode)
.判断结束
返回 (0)


善者 慈悲心常在 无怨无恨 以苦为乐
默认压缩密码www.hifyl.com
文件分享密码问题:http://www.hifyl.com/read-htm-tid-4444.html
离线ly611611

只看该作者 沙发  发表于: 05-18
快速回复
限100 字节
批量上传需要先选择文件,再选择上传
 
上一个 下一个