aardio 文档

process 库模块帮助文档

相关范例

范例程序 > 进程

process 成员列表

运行执行文件或关联文档。
如果省略所有参数则打开当前进程
失败则返回 null,错误信息,错误代码
成功返回进程对象。

个别系统 64 位程序，需要改用 process.wow64 启动以避免目录重定向。
极个别系统程序，需要用 process.shell 函数创建 process 对象。

process( ,系统命令行)

如果省略第一个参数,并仅指定命令行,则作为系统命令行启动运行

process()

返回对象:processObject

process(执行文件,命令行参数,STARTUPINFO)

命令行参数可以是字符串或由多个字符串组成的数组,
数组参数调用 string.args.join 合并,
不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号,
命令参数最大长度为 32765 个字符。
STARTUPINFO参数为process.STARTUPINFO 结构体,可选参数
如果该参数是普通table对象.将自动创建为STARTUPINFO结构体

process(执行文件,命令行参数,更多命令行参数,...)

命令行参数可以是一个数组、一个或多个字符串参数,

数组或多个命令行参数调用 string.args.join 合并,
不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号,
命令参数最大长度为 32765 个字符

process(进程ID,权限)

打开指定ID的进程,
参数@2可选用一个数值指定请求的权限，
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,
如果失败则尝试以 _SYNCHRONIZE 权限打开进程,
_SYNCHRONIZE权限打开时只能使用 wait,waitOne函数,
非管理权限进程创建管理权限进程时只能以_SYNCHRONIZE权限打开进程

process(进程句柄,负责释放进程句柄)

使用指定的进程句柄创建进程对象,
参数@2为可选参数,默认为true

process. ReadProcessMemory64

::Ntdll.api("NtWow64ReadVirtualMemory64","int(POINTER hProcess,LONG base,struct &buf,long size,long & retSize)" )

process. GetModuleFileNameEx

Psapi.api("GetModuleFileNameEx","INT(pointer hProcess,pointer hModule,ustring& lpFilename,INT size)" )

process. MEMORY_BASIC_INFORMATION

class {
        addr BaseAddress;
        addr AllocationBase;
        INT AllocationProtect;
        INT RegionSize;
        INT State;
        INT Protect;
        INT Type;
    }

process. THREADENTRY32

class {
    INT dwSize;
    INT cntUsage;
    INT th32ThreadID; // this thread
    INT th32OwnerProcessID; // Process this thread is associated with
    int tpBasePri;
    int tpDeltaPri;
    INT dwFlags;
    }

process.::Advapi32 :

..raw.loadDll("Advapi32.dll")

process.CreateProcess

::Kernel32.api("CreateProcess","int(ustring app, ustring &cmd, pointer processAttributes,pointer threadAttributes, bool inheritHandles, INT creationFlags,ustring environment, ustring lpCurrentDirectory, struct lpStartupInfo, struct& lpProcessInformation )");

process.CreateProcessWithLogonW

::Advapi32.api("CreateProcessWithLogonW","int(ustring user,ustring domain,ustring pwd,INT flags,ustring app, ustring &cmd, INT creationFlags,ustring environment, ustring lpCurrentDirectory, struct lpStartupInfo, struct& lpProcessInformation )");

process.FindExecutable

::Shell32.api("FindExecutable","int(ustring file,ustring directory,ustring &result)")

process.GetExitCodeProcess

::Kernel32.api("GetExitCodeProcess","bool(POINTER hProcess,INT &code)");

process.GetPriorityClass

::Kernel32.api("GetPriorityClass","INT(POINTER hProcess");

process.IsWow64Process

::Kernel32.api( "IsWow64Process", "bool(pointer hProcess,bool &Wow64Process)");

process.OpenProcess

::Kernel32.api("OpenProcess","pointer(INT desiredAccess,bool inherit,INT pid)")

process.PROCESS_INFORMATION

class {
        pointer hProcess;
        pointer hThread;
        INT dwProcessId;
        INT dwThreadId;
    }

process.ReadProcessMemory

::Kernel32.api("ReadProcessMemory","int(POINTER hProcess,addr base,struct &buf,INT size,INT & retSize)" )

process.ReadProcessMemoryByString

::Kernel32.api("ReadProcessMemory","int(POINTER hProcess,addr base,string &buf,INT size,INT & retSize)" )

process.ReadProcessMemoryByString64

::Ntdll.api("NtWow64ReadVirtualMemory64","int(POINTER hProcess,LONG base,string &buf,long size,long & retSize)" )

process.STARTUPINFO

class {
        INT cb = 68;
        ustring reserved;
        ustring desktop;
        ustring title;
        INT x;
        INT y;
        INT xSize;
        INT ySize;
        INT xCountChars;
        INT yCountChars;
        INT fillAttribute;
        INT flags;
        WORD showWindow;
        WORD cbReserved2;
        ustring lpReserved2;
        pointer stdInput;
        pointer stdOutput;
        pointer stdError; 
        creationFlag = 0;
        inheritHandles;
    };

process.STARTUPINFO()

创建进程启动参数

返回对象:startinfoObject

process.SetPriorityClass

::Kernel32.api("SetPriorityClass","bool(POINTER hProcess,INT priorityClass)");

process.SetProcessAffinityMask

::Kernel32.api("SetProcessAffinityMask","INT(pointer hProcess,INT dwProcessAffinityMask)" )

process.TerminateProcess

::Kernel32.api("TerminateProcess","int(pointer hProcess,INT exitCode)")

process.Thread32First

::Kernel32.api("Thread32First","int(pointer hsnap,struct& lppe)")

process.Thread32Next

::Kernel32.api("Thread32Next","int(pointer hsnap,struct& lppe)")

process.VirtualAllocEx

::Kernel32.api("VirtualAllocEx","addr(POINTER hProcess ,addr addr,int dwSize,int flAllocationType,int flProtect)")

process.VirtualFreeEx

::Kernel32.api("VirtualFreeEx","int(POINTER hProcess,addr addr,int dwSize,int dwFreeType)")

process.VirtualProtectEx

::Kernel32.api("VirtualProtectEx","bool(POINTER hProcess,addr addr, INT dwSize, INT flNewProtect, INT &lpflOldProtect )");

process.VirtualQueryEx

::Kernel32.api("VirtualQueryEx","INT(pointer hProcess,addr addr,struct& buf,INT dwLength)" )

process.WaitForInputIdle

::User32.api("WaitForInputIdle","INT(pointer hProcess,INT dwMilliseconds)");

process.WriteProcessMemory

::Kernel32.api("WriteProcessMemory","int(POINTER hProcess,addr base,struct buf,INT size,INT & retSize)" )

process.WriteProcessMemory64

::Ntdll.api("NtWow64WriteVirtualMemory64","int(POINTER hProcess,LONG base,struct buf,long size,long & retSize)" )

process.WriteProcessMemoryByString

::Kernel32.api("WriteProcessMemory","int(POINTER hProcess,addr base,string buf,INT size,INT & retSize)" )

process.WriteProcessMemoryByString64

::Ntdll.api("NtWow64WriteVirtualMemory64","int(POINTER hProcess,LONG base,string buf,long size,long & retSize)" )

process.dup(句柄,,目标进程句柄)

复制句柄到目标进程句柄

process.dup(句柄,源进程句柄)

从指定进程复制句柄到当前进程

process.dup(句柄,源进程句柄,目标进程句柄)

进程句柄参数省略则为当前进程句柄
函数支持更多可选参数如下:
(句柄,源进程,目标进程,是否可继承,选项,安全访问级别)
默认可继承,选项默认为_DUPLICATE_CLOSE_SOURCE | _DUPLICATE_SAME_ACCESS
如果不指定最后一个参数

process.each

for processEntry in process.each( ".*.exe" ) {   
//搜索进程，参数指定执行文件名（支持完全匹配与模式匹配，忽略大小写）  
    //io.print( processEntry.szExeFile  )  

}

process.eachModule

for moduleEntry in process.eachModule(/*进程ID*/) {   
//io.print( moduleEntry.szExePath  )  

}

process.eachThread

for threadEntry in process.eachThread(/*进程ID*/) {   
//io.print( threadEntry.th32ThreadID  )  

}

process.eachWindow(执行文件名,类名,标题)

for hwnd in process.eachWindow( ".*.exe" ) {  
    /*搜索进程主窗口，所有参数可选。  
参数 @1 指定应指定进程执行文件名而非文件路径，  
所有参数支持完全匹配与模式匹配，忽略大小写。  
不指定类名或标题时忽略隐藏窗口。*/  
}

process.emptyWorkingSet()

将工作集中的内存尽可能移动到页面文件中,
应发在最小化或程序空闲内存确实暂不需要使用时调用,
不应频繁调用此函数

process.environment()

返回当前进程的所有环境变量组成的字符串
键与值之间使用等号分隔,每个键值对中间以'\0'分隔
尾部没有'\0'

process.execute

运行exe应用程序,成功返回进程ID,
参数详细用法请参考本函数源码以及 WINAPI 中 ShellExecuteEx 函数用法
运行 UWP 应用请使用 com.shell.activateApp 函数

raw.execute 提供了与本函数类似的功能。

个别系统 64 位程序，需要改用 process.wow64.execute 以避免目录重定向。

process.execute("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd)

参数 @1 为程序路径或系统命令。

可选参数 @parameters 可以是字符串或字符串数组，用于指定启动参数。
如果指定数组则由 string.args.join 自动处理转义并支持命名参数。
如果启动参数只指定一个文件路径，为避免可能包含空格或以反斜杆结尾等需要转义的情况，
建议写为 process.execute(exePath,{path}) 这种格式，让 aardio 自动处理转义。

可选参数 @operation 为启动模式
可选参数 @showCmd 使用 SW 前缀常量，与win.show参数用法相同。
可选参数 @workdir 为工作目录
可选参数 @hwnd 可指定父窗口句柄

process.executeEx("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd,fmask)

运行 EXE 应用程序,返回 SHELLEXECUTEINFO 结构体,
参数 @1 指定要运行的执行程序路径,
参数 @2 可用一个字符串或字符串数组指定启动参数。
所有参数用法与 process.execute 函数相同。
关于 @fmask 详细用法请参考本函数源码（一般用不到）。
除参数 @1 以外所有参数可选

process.executeInvoke(path, parameters,operation,showCmd,workDir,hwnd)

创建临时的后台线程运行应用程序
在打开程序前退出主线程可能无法执行操作,
参数与 process.execute 函数用法一样,除指定参数@1或参数@2,其他所有参数可选

process.executeWait("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir=",hwnd=0)

运行exe应用程序
并等待应用程序关闭
除参数@1以外所有参数可选，所有参数用法与 process.execute 相同

process.executeWaitInput("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir=",hwnd=0)

运行exe应用程序
并等待进程初始化完成并接受输入
除参数@1以外所有参数可，所有参数用法与 process.execute 相同

process.explore(path,args,...)

使用资源管理器（Explorer.exe）打开文件或目录。

第一个参数 @path 指定文件路径，可为空值（ null ）。
注意 Explorer.exe 不解析标准的命令行参数转义符，这一点与其他程序不同。
如参数 @path 尾部有双反斜杆\\则为无效路径并打开默认目录（打开我的文档，XP系统报错）。
如参数 @path 指定为 ","或"file:" 则打开“此电脑（This PC）”。
如参数 @path 使用shell:::前缀则可以指定特殊路径的 CLSID。

可用第二个参数 @args 或更多参数指定 Explorer.exe 命令行选项，
例如指定 "/select" 在资源管理器选择指定路径。
注意 "/n" 等选项在新系统中是无意义的，Explorer 将总是打开新窗口。

内置函数 raw.explore 与 process.explore 用法相同

process.exploreSelect("字符串参数")

打开资源管理器，选定参数 @1 指定的文件路径

process.find("字符串参数")

查找进程并返回进程对象。
参数 @1 指定要查找的进程启动文件名,注意应指定文件名而非文件路径,
文件名参数支持完全匹配与模式匹配，忽略大小写

process.find()

返回对象:processObject

process.findExe("字符串参数")

查找文件关联的可执行程序

process.findId("字符串参数")

查找进程并返回进程 ID。
参数 @1 指定要查找的进程启动文件名,注意应指定文件名而非文件路径,
文件名参数支持完全匹配与模式匹配，忽略大小写

process.findWindow

查找进程并返回进程主窗口句柄。

process.findWindow(执行文件名,类名,标题)

所有参数可选。
参数 @1 指定应指定进程执行文件名而非文件路径，
所有参数支持完全匹配与模式匹配，忽略大小写。
不指定类名或标题时忽略隐藏窗口。

process.firstThreadId(进程ID)

返回进程的首个线程 ID

process.getHandle()

获取当前进程伪句柄

process.getId()

获取当前进程 ID

process.getInfo

获取进程信息

process.getInfo()

返回对象:ProcessInfoObject

process.getInfo(handle)

获取进程信息，参数 @1 指定进程句柄

process.getInfo(handle,infoClass,infoStruct)

参数 @1 指定进程句柄。
如果参数 infoClass 指定非 null 数值，
并且 infoStruct 指定结构体。
在 Win8 以及之后系统获取信息到该结构体。
成功返回原结构体

process.getParent()

获取父进程对象。
参数@1可选用一个数值指定请求的权限，
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,
如果失败则尝试以 _SYNCHRONIZE 权限打开进程。

返回对象:processObject

process.getParentId()

获取父进程 ID

process.getPath(进程ID)

返回执行程序文件完整路径

process.is()

传入参数是否 process 对象

process.isExe("字符串参数")

检测目标文件是否可执行文件。
如果是可执行文件返回"PE32"或"PE64"
第二个返回值为子系统,GUI为2,CUI为3
失败或参数为 null 返回 null

process.joinArguments

用于安全地合并命令行参数，并自动处理转义字符。
此函数实际指向 string.args.join 函数。

process.joinArguments(参数表,...)

可传入一个参数表（可包含数组成员）或多个非 null 参数。

如果传入参数是一个表对象（可包含数组），
参数表将自动合并为单个命令行参数并返回一个字符串值。
表中以键名以 - 或 / 开头的名值对自动合并为命令行参数。

数组成员也会合并到命令行，但名值对参数总是置于数组参数之前。
如果数组成员也是表对象，则仍调用此函数直接转换为字符串（不再转义）。
其他数组或命名参数值用 tostring 转换为字符串，按需添加引号进行必要的转义。
不在双引号内、且含空白字符或 ^ | & 等字符的参数转义后置入双引号。

process.kill

查找并关闭进程,
注意有些进程需要管理权限才能找到,
例如资源管理器进程 "explorer.exe" 无管理权限有时会失败,
在代码第一行添加//RUNAS//可申请管理权限

process.kill(exePath,restart)

查找所有同名 exe 文件的进程，并关闭进程。
参数 @exePath 支持完全匹配与模式匹配,忽略大小写。
返回进程的完整路径。

如果 @restart 参数为 true，
则杀进程成功后立即重新启动该进程

process.kill(pid)

使用参数@pid指定进程ID,关闭该进程

process.openUrl()

调用默认浏览器打开网址,用于窗口程序,
如果不用这个方法创建线程去打开网址,可能会出现界面卡顿不流畅的现象,
在打开网址前退出主线程可能无法执行操作
控制台程序应调用 process.execute 以避免后台线程不能阻止控制台关闭

process.regAs(命令参数)

以管理权限执行 reg 命令

process.shell

并运行应用程序，返回 process 进程对象。
个别系统 64 位程序，需要改用 process.wow64.shell 以禁用目录重定向。

process.shell("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd,fmask)

参数 @1 指定要运行的执行程序路径,
参数 @2 可用一个字符串或字符串数组指定启动参数,
所有参数用法与 process.execute 函数相同。
关于 @fmask 详细用法请参考本函数源码（一般用不到）。
除参数 @1 以外所有参数可选

process.shell()

返回对象:processObject

process.shellAs

以管理权限运行 EXE 应用程序,返回进程对象

process.shellAs("字符串参数", parameters="字符串参数",showCmd,workDir,hwnd,fmask)

参数 @1 指定要运行的执行程序路径,
参数 @2 可用一个字符串或字符串数组指定启动参数。
所有参数用法与 process.execute 函数相同。
关于 @fmask 详细用法请参考本函数源码（一般用不到）。
除参数 @1 以外所有参数可选

process.shellAs()

返回对象:processObject

process.workDir

创建进程默认工作目录，
默认值为"/"，也即应用程序根目录。

启动程序路径可直接访问时默认工作目录为应用程序所在目录，
反之启动程序路径传入 io.exist 返回 false 则默认工作目录为 process.workDir，
一般不建议改变默认工作目录，
更好的选择是在创建进程的选项参数中指定 workDir

processObject 成员列表

processObject.asm(机器码数组,函数原型,调用约定)

使用table数组指定任意个机器码参数,使用分号隔开,
机器码可以是字符串,结构体,数值或指针,
函数原型可省略,调用约定默认为"cdecl"

processObject.asmCdecl(函数原型,任意多个机器码参数)

写入机器码返回函数对象
请参考:aardio工具->其他编译器->INTEL汇编语言->汇编转机器码

processObject.asmStdcall(函数原型,任意多个机器码参数)

写入机器码返回函数对象
请参考:aardio工具->其他编译器->INTEL汇编语言->汇编转机器码

processObject.asmThiscall(函数原型,任意多个机器码参数)

写入机器码返回函数对象
请参考:aardio工具->其他编译器->INTEL汇编语言->汇编转机器码

processObject.assignToJobObject(process.job.limitKill)

绑定到作业对象,成功返回 true
作业对象示例请参考标准库 process.job.limitKill 的源码。
也可直接调用 killOnExit 函数绑定 process.job.limitKill

processObject.closeMainWindow()

关闭进程的主窗口，忽略隐藏窗口

processObject.ctrlEvent(0)

发送Ctrl+C(SIGINT信号)
信号将传递到与目标进程控制台连接的所有非分离控制台进程
64位目标进程会导致当前控制台暂时关闭

processObject.ctrlEvent(1)

发送Ctrl+Break(SIGBREAK信号)
信号将传递到与目标进程控制台连接的所有非分离控制台进程
64位目标进程会导致当前控制台暂时关闭

processObject.eachModule

for moduleEntry in processObject.eachModule() {   
//此函数仅支持 32 位进程  

}

processObject.eachQuery(开始地址,搜索内存长度,搜索数据)

for( curMemAddr,curMemSize,strResult,i,j,remainSize in processObject.eachQuery(  , ,"/*搜索模式*/" ) ){  

}

processObject.eachThread

for threadEntry in processObject.eachThread() {   
//io.print( threadEntry.th32ThreadID  )  

}

processObject.emptyWorkingSet()

将工作集中的内存尽可能移动到页面文件中,
可在最小化或程序空闲时调用以释放活动内存，
不建议频繁调用此函数

processObject.free()

释放进程对象。
不是关闭进程,仅仅是释放对进程的控制句柄。

processObject.getExitCode()

该函数调用成功有两个返回值:进程退出代码,进程是否已退出

processObject.getInfo

获取进程信息

processObject.getInfo()

获取进程信息

返回对象:ProcessInfoObject

processObject.getInfo(infoClass,infoStruct)

如果参数 infoClass 指定非 null 数值，
并且 infoStruct 指定结构体。
在 Win8 以及之后系统获取信息到该结构体。
成功返回原结构体。

此用法内部调用 ::Kernel32.GetProcessInformation
细节请参考该 API 文档

processObject.getMainWindow()

返回进程的主窗口以及窗口进程 ID，找不到则搜寻子进程主窗口。
查找时忽略隐藏窗口。

也可以调用 winex.mainWindows 获取主窗口。
winex.mainWindows 查找规则略有不同，请参考源码

processObject.getMainWindow(类名,标题)

返回进程的指定类名的主窗口以及窗口进程 ID，找不到则搜寻子进程主窗口。
类名与标题支持完全匹配与模式匹配，忽略大小写。
所有参数可选，不指定类名或标题时忽略隐藏窗口。

processObject.getModuleBaseAddress(模块名)

返回模块基址。
模块名忽略大小写,
不指定模块名则返回应用程序基址。

此函数仅支持 32 位程序。
64位进程返回 math.size64 对象（暂不支持指定模块名）

processObject.getParent()

获取父进程对象。
参数@1可选用一个数值指定请求的权限，
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,
如果失败则尝试以 _SYNCHRONIZE 权限打开进程。

返回对象:processObject

processObject.getParentId()

获取父进程 ID

processObject.getPath()

返回执行程序文件完整路径。
如果该进程以管理权限运行，
则调用函数的进程也必须以管理权限运行
才能获取到路径

processObject.getPriorityClass()

返回进程优先级

processObject.getUiInfo()

获取UI线程窗口焦点,光标等信息

返回对象:guithreadinfoObject

processObject.handle

进程句柄

processObject.id

进程 ID

processObject.isWow64()

进程是否在64位系统上运行的32进程

processObject.isX64()

是否64位进程

processObject.kill()

杀除进程

processObject.killOnExit()

主进程退出时自动退出此进程

processObject.malloc(长度)

在目标进程分配内存空间

processObject.malloc(长度,访问类型)

在目标进程分配内存空间

processObject.malloc(长度,访问类型,分配类型)

在目标进程分配内存空间

processObject.mfree(指针)

释放malloc成员函数分配的内存指针

processObject.mfree(指针,释放长度,0x4000)

释放malloc成员函数分配的内存指针
不建议手工指定长度

processObject.protect(内存地址,4/*_PAGE_READWRITE*/,1)

修改内存保护属性,返回原来的保护属性,
第三个参数指定内存长度

processObject.query(开始地址,搜索内存长度,搜索数据)

查找下一个有效内存地址,所有参数可选,
搜索数据可以是字符串或结构体
返回值: curMemAddr,curMemSize,strResult,i,j,remainSize

processObject.readNumber(内存地址)

读取一个int整数,32位
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"BYTE")

读取一个字节,8位无符号
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"INT")

读取一个int整数,32位无符号
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"LONG")

读取一个long类型整数,64位无符号
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"WORD")

读取一个word类型整数,16位无符号
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"byte")

读取一个字节,8位
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"long")

读取一个long类型整数,64位
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumber(内存地址,"word")

读取一个word类型整数,16位
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readNumberPtr(内存地址)

读取 int 整数的指针，
然后用在指针指向的内存读取读取数值。
可用参数 @2 指定原生类型，用法同 readNumber 函数。

processObject.readPtr()

读取指针地址。
64 位进程读取 8 字节并返回 math.size64 对象。
32 位进程读取 4 字节并返回数值。

processObject.readString(内存地址,长度)

读取定长字符串
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readStringPtr(内存地址,长度)

在参数指定的地址读取字符串指针，
然后用在指针指向的内存读取字符串。

processObject.readStringUtf16(内存地址,长度)

读取定长 UTF-16 字符串（ustring），
返回字符串转换为 UTF-8 编码。
注意长度以字符为单位
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readStringUtf16Ptr(内存地址,长度)

在参数指定的地址读取字符串指针，
然后用在指针指向的内存读取定长 UTF-16 字符串（ustring）。
返回字符串转换为UTF8编码。
注意长度以字符为单位

processObject.readStruct(内存地址,结构体)

读取定义的结构体
打开进程需要指定 _PROCESS_VM_READ 权限

processObject.readStructPtr(内存地址,结构体)

在参数指定的地址读取结构体指针，
然后用在指针指向的内存读取结构体

processObject.remoteApi

在外部进程内创建远程调用函数

processObject.remoteApi("void()","dll名","函数名")

参数(函数原型,加载DLL模块名,函数名,调用约定)
不指定调用约定时默认使用stdcall调用约定
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

processObject.remoteApi("void()","dll名","函数名","cdecl,borland")

参数(函数原型,加载DLL模块名,函数名,调用约定)
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

processObject.remoteApi("void()",CALL地址,调用约定)

参数(函数原型,CALL地址,调用约定)
不指定调用约定在数时默认使用stdcall调用约定

processObject.remoteApi("void(INT thisAddr)","dll名","函数名","thiscall")

参数(函数原型,加载DLL模块名,函数名,调用约定)
thiscall使用第一个参数指定this指针地址
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

processObject.resume()

恢复运行

processObject.sendMessage(hwnd,message,wParam,lParam)

向外部进程窗口发送消息
lParam如果是结构体则复制到目标进程内存,
结构体如果包含指针应当自行调用 process.malloc 分配内存并复制
发送消息涉及的用法太多,尤其是涉及到访问外部进程内存,
所涉及的知识量不能通过看几句函数说明获得,
普通用户请不要学习或使用此函数

processObject.setAffinity(1)

指定进程运行的CPU内核

processObject.setInfo(infoClass,infoStruct)

设置进程信息，成功返回 true。
infoClass 指定数值，infoStruct 指定结构体。
此函数内部调用 ::Kernel32.SetProcessInformation 。
详细用法请参考 API 文档。
在低于 Win8 的系统不执行操作

processObject.setPriorityClass(0x80/*_HIGH_PRIORITY_CLASS*/)

设置进程优先级

processObject.stillActive()

进程是否仍在运行

processObject.suspend()

暂停进程

processObject.terminate()

强行终止进程
可在参数中指定退出代码

processObject.tid

返回进程的主线程 ID

processObject.wait()

等待进程关闭,
可选使用一个毫秒值参数设定超时
超时或失败返回 false,
进程已退出则返回值1为true,返回值2为退出代码

processObject.waitMainWindow

等待并返回进程主窗口以及窗口进程ID。
也可调用 winex.mainWindows 且指定参数 @2 为 true 以等待主窗口。
winex.mainWindows 查找规则略有不同，请参考源码

processObject.waitMainWindow(类名,等待窗口句柄)

等待并返回进程主窗口以及窗口进程ID。
所有参数可选。
可选指定要等待的类名，类名支持完全匹配与模式匹配，忽略大小写。
不指定类名时忽略隐藏窗口,
可选指定等待窗口句柄,该窗口关闭时些函数不再等待并直接返回结果

processObject.waitOne()

等待进程关闭,不阻塞UI消息循环,
可选使用一个毫秒值参数设定超时
超时或失败返回 false,
进程已退出则返回值1为true,返回值2为退出代码

processObject.write(内存地址,任意个字符串或结构体参数)

写入数据,成功返回写入尾部内存地址,
失败返回空

processObject.writeNumber(内存地址,0)

写入一个int整数,32位

processObject.writeNumber(内存地址,0,"BYTE")

写入一个字节,8位无符号

processObject.writeNumber(内存地址,0,"INT")

写入一个int整数,32位无符号

processObject.writeNumber(内存地址,0,"LONG")

写入一个long类型整数,64位无符号

processObject.writeNumber(内存地址,0,"WORD")

写入一个word类型整数,16位无符号

processObject.writeNumber(内存地址,0,"byte")

写入一个字节,8位

processObject.writeNumber(内存地址,0,"long")

写入一个long类型整数,64位

processObject.writeNumber(内存地址,0,"word")

写入一个word类型整数,16位

processObject.writeString(内存地址,字符串,长度)

写入字符串,长度为可选参数,
省略内存地址参数则自动分配内存,
该函数返回写入内存地址,写入长度

processObject.writeStringUtf16(内存地址,字符串)

写入 UTF-16 字符串（ustring）。
参数可以为默认的UTF8编码文本

processObject.writeStruct(内存地址,结构体)

写入定义的结构体,
省略内存地址参数则自动分配内存,
该函数返回写入内存地址,写入长度

ProcessInfoObject 成员列表

ProcessInfoObject.exitStatus

进程退出代码

ProcessInfoObject.pebBaseAddress

PEB 地址,
注意 64 位进程这里返回 math.size64 对象,
32 位进程返回数值

ProcessInfoObject.prarentId

父进程ID

heapEntry 成员列表

heapEntry.dwAddress

Linear address of start of block

heapEntry.dwBlockSize

Size of block in bytes

heapEntry.dwFlags

dwLockCount =

heapEntry.dwResvd

th32ProcessID = owning process

heapEntry.dwSize

结构体大小;

heapEntry.hHandle

Handle of this heap block

heapEntry.th32HeapID

heap block is in

heapList 成员列表

heapList.dwFlags

heapList.dwSize

结构体大小;

heapList.th32HeapID

heap (in owning process's context!)

heapList.th32ProcessID

owning process

moduleEntry 成员列表

moduleEntry.GlblcntUsage

ProccntUsage =

moduleEntry.dwSize

结构体大小

moduleEntry.modBaseAddr

模块基址;

moduleEntry.modBaseSize

hModule = 模块句柄

moduleEntry.szExePath

moduleEntry.szModule

0;

moduleEntry.th32ModuleID

模块ID;

moduleEntry.th32ProcessID

进程ID,INT数据类型

processEntryObject 成员列表

processEntryObject.cntThreads

此进程开启的线程计数

processEntryObject.dwSize

结构体长度，以字节为单位

processEntryObject.pcPriClassBase

进程优先级,INT数据类型

processEntryObject.szExeFile

进程启动文件名,不是文件完整路径

processEntryObject.th32ParentProcessID

父进程的 ID

processEntryObject.th32ProcessID

进程ID,INT数据类型

startinfoObject 成员列表

startinfoObject.createNoWindow

应用程序不创建控制台窗口

startinfoObject.creationFlag

startinfoObject.creationFlag = CREATE //创建进程的参数,参考API CreateProcess的说明

startinfoObject.desktop

标识启动应用程序所在的桌面的名字

startinfoObject.domain

域名

startinfoObject.environment

新进程的环境变量
以键值对组成的字符串,多个键值对间请以'\0'分隔
键与值之间以=号分隔
也可以传入包含键值对的表对象

startinfoObject.fillAttribute

控制台窗口使用的文本和背景颜色

startinfoObject.flags

startinfoObject.flags = _STARTF_USE //指定结构体中哪些成员生效

startinfoObject.inheritEnvironment

如果此属性的值恒等于false,且同时指定了environment的值,
那么创建的子进程不会继承父进程的环境变量
此属性不指定值时默认值为true

startinfoObject.inheritHandles

默认值为真,所有有可被继承属性的内核对象都会被复制到子进程(实际上是内核对象引用计数加一)

startinfoObject.logonFlags

登录选项,默认为 _LOGON_WITH_PROFILE

startinfoObject.password

登录密码

startinfoObject.processAttributes

SECURITY_ATTRIBUTES结构体指针,一般不建议设置
如需设置请使用raw.malloc将结构体转换为指针

startinfoObject.showWindow

显示参数，
支持以_SW_ 前缀的常量
_SW_HIDE 表示隐藏窗口（默认值）。
此属性用于指定是否显示控制台以外的窗口，
flags 字段必须指定 _STARTF_USESHOWWINDOW 才会生效

startinfoObject.stdError

标准错误输出(可用于创建管道)

startinfoObject.stdInput

标准输入（可用于创建管道）

startinfoObject.stdOutput

标准输出（可用于创建管道）

startinfoObject.suspended

是否休眠创建进程的主线程
如果为真自动添加_CREATE_SUSPENDED参数

startinfoObject.threadAttributess

SECURITY_ATTRIBUTES结构体指针,一般不建议设置
如需设置请使用raw.malloc将结构体转换为指针

startinfoObject.title

控制台标题

startinfoObject.username

登录用户名

startinfoObject.waitInputTimeout

进程启动后等待初始化完成的最大超时
默认为0xFFFFFFFF(无限等待),设为0则不等待

startinfoObject.workDir

进程工作目录,
默认值为 process.workDir

startinfoObject.x

x坐标(子进程使用默认坐标时、或控制台窗口支持)

startinfoObject.xCountChars

控制台宽度(字符单位)

startinfoObject.xSize

窗口宽(子进程使用默认坐标时、或控制台窗口支持)

startinfoObject.y

y坐标(子进程使用默认坐标时、或控制台窗口支持)

startinfoObject.yCountChars

控制台高度(字符单位)

startinfoObject.ySize

窗口高(子进程使用默认坐标时、或控制台窗口支持)

threadEntry 成员列表

threadEntry.cntUsage

引用计数

threadEntry.dwFlags

th32OwnerProcessID = 进程ID

threadEntry.dwSize

结构体大小

threadEntry.th32OwnerProcessID

Process this thread is associated with

threadEntry.th32ThreadID

线程ID

threadEntry.tpBasePri

tpDeltaPri =

自动完成常量

_CREATE_NEW_CONSOLE=0x10
_CREATE_NEW_PROCESS_GROUP=0x200
_CREATE_NO_WINDOW=0x8000000
_CREATE_PROCESS_DEBUG_EVENT=3
_CREATE_SUSPENDED=4
_MEM_4MB_PAGES=0x80000000
_MEM_COMMIT=0x1000
_MEM_DECOMMIT=0x4000
_MEM_FREE=0x10000
_MEM_LARGE_PAGES=0x20000000
_MEM_MAPPED=0x40000
_MEM_PHYSICAL=0x400000
_MEM_PRIVATE=0x20000
_MEM_RELEASE=0x8000
_MEM_RESERVE=0x2000
_MEM_RESET=0x80000
_MEM_ROTATE=0x800000
_MEM_TOP_DOWN=0x100000
_MEM_WRITE_WATCH=0x200000
_PAGE_EXECUTE=0x10
_PAGE_EXECUTE_READ=0x20
_PAGE_EXECUTE_READWRITE=0x40
_PAGE_EXECUTE_WRITECOPY=0x80
_PAGE_GUARD=0x100
_PAGE_NOACCESS=1
_PAGE_NOCACHE=0x200
_PAGE_READONLY=2
_PAGE_READWRITE=4
_PAGE_WRITECOMBINE=0x400
_PAGE_WRITECOPY=8
_PROCESS_ALL_ACCESS=0x1FFFFF
_PROCESS_CREATE_PROCESS=0x80
_PROCESS_CREATE_THREAD=2
_PROCESS_DUP_HANDLE=0x40
_PROCESS_QUERY_INFORMATION=0x400
_PROCESS_QUERY_LIMITED_INFORMATION=0x1000
_PROCESS_SET_INFORMATION=0x200
_PROCESS_SET_QUOTA=0x100
_PROCESS_SET_SESSIONID=4
_PROCESS_SUSPEND_RESUME=0x800
_PROCESS_TERMINATE=1
_PROCESS_VM_OPERATION=8
_PROCESS_VM_READ=0x10
_PROCESS_VM_WRITE=0x20
_STANDARD_RIGHTS_REQUIRED=0xF0000
_SYNCHRONIZE=0x100000
_TH32CS_INHERIT=0x80000000
_TH32CS_SNAPALL=0xF
_TH32CS_SNAPHEAPLIST=1
_TH32CS_SNAPMODULE=8
_TH32CS_SNAPMODULE32=0x10
_TH32CS_SNAPPROCESS=2
_TH32CS_SNAPTHREAD=4

Markdown 格式