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.fromWindowHandle() #

返回对象:processObject

process.fromWindowHandle(hwnd) #

自参数 @1 指定的窗口句柄获取进程对象。
返回进程的 pid 属性为进程 ID，tid 属性为窗口线程所在线程 ID。
失败返回 null 。

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。
raw.pefile 对象的 isPe32 属性也可用于区分 32 位与 64 位执行文件。

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.waitForInputIdle(超时间隔) #

等待进程完成初始化并等待用户输入的空闲状态（没有待处理输入）。
超时间隔以毫秒为单位，省略参数则一直等待。

默认会在创建进程时被自动调用此函数，
除非创建进程的 startInfo 参数的 waitInputTimeout 字段为 0,
或者 startInfo 参数的 suspended字段为 true 。

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 #

进程启动后自动调用 waitForInputIdle 等待进入输入空闲状态的最大超时。
默认为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 格式