VB 获取进程/模块信息 批量结束进程的代码

Attribute VB_Name = "Enume_Task"
Option Explicit
Option Base 0

'Powered by barenx
Private Declare Function GetSystemDirectory()Function GetSystemDirectory Lib "kernel32" Alias "GetSystemDirectoryA" (ByVal lpBuffer As String, ByVal nSize As Long) As Long
Private Declare Sub CopyMemory()Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDest As Any, pSrc As Any, ByVal ByteLen As Long)
Private Declare Sub CloseHandle()Sub CloseHandle Lib "kernel32" (ByVal hPass As Long)
Private Const MAX_PATH As Integer = 260
Private Const MAXLONG = &H7FFFFFFF
Private Const SYNCHRONIZE = &H100000
Private Const READ_CONTROL = &H20000
Private Const STANDARD_RIGHTS_REQUIRED = &HF0000
Private Const STANDARD_RIGHTS_WRITE = (READ_CONTROL)
Private Const INVALID_HANDLE_VALUE = -1
'***************************************************************************************************************
Private Declare Function CreateToolhelp32Snapshot()Function CreateToolhelp32Snapshot Lib "kernel32" (ByVal lFlags As Long, ByVal lProcessID As Long) As Long
Private Const TH32CS_SNAPHEAPLIST = &H1
Private Const TH32CS_SNAPPROCESS = &H2
Private Const TH32CS_SNAPTHREAD = &H4
Private Const TH32CS_SNAPMODULE = &H8
Private Const TH32CS_SNAPALL = (TH32CS_SNAPHEAPLIST Or TH32CS_SNAPPROCESS Or TH32CS_SNAPTHREAD Or TH32CS_SNAPMODULE)
Private Const TH32CS_INHERIT = &H80000000
'***************************************************************************************************************
Private Declare Function Process32Next()Function Process32Next Lib "kernel32" (ByVal hSnapshot As Long, uProcess32 As PROCESSENTRY32) As Long
Private Declare Function Process32First()Function Process32First Lib "kernel32" (ByVal hSnapshot As Long, uProcess32 As PROCESSENTRY32) As Long
Public Type PROCESSENTRY32
    dwSize As Long
    cntUsage As Long
    th32ProcessID As Long
    th32DefaultHeapID As Long
    th32ModuleID As Long
    cntThreads As Long
    th32ParentProcessID As Long
    pcPriClassBase As Long
    dwFlags As Long
    szExeFile As String * MAX_PATH
End Type
Private Declare Function NtSuspendProcess()Function NtSuspendProcess Lib "ntdll" (ByVal Process As Long) As Long
Private Declare Function OpenProcess()Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long
Private Declare Function TerminateProcess()Function TerminateProcess Lib "kernel32" (ByVal hProcess As Long, ByVal uExitCode As Long) As Long
Private Declare Function GetCurrentProcess()Function GetCurrentProcess Lib "kernel32" () As Long
Private Declare Function GetCurrentProcessId()Function GetCurrentProcessId Lib "kernel32" () As Long
Private Declare Function GetPriorityClass()Function GetPriorityClass Lib "kernel32" (ByVal hProcess As Long) As Long
Private Const PROCESS_TERMINATE = &H1
Private Const PROCESS_CREATE_THREAD = &H2
Private Const PROCESS_SET_SESSIONID = &H4
Private Const PROCESS_VM_OPERATION = &H8
Private Const PROCESS_VM_READ = &H10
Private Const PROCESS_VM_WRITE = &H20
Private Const PROCESS_DUP_HANDLE = &H40
Private Const PROCESS_CREATE_PROCESS = &H80
Private Const PROCESS_SET_QUOTA = &H100
Private Const PROCESS_SET_INFORMATION = &H200
Private Const PROCESS_QUERY_INFORMATION = &H400
Private Const PROCESS_SUSPEND_RESUME = &H800
Private Const PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED Or SYNCHRONIZE Or &HFFF
'***************************************************************************************************************
Private Declare Function Thread32First()Function Thread32First Lib "kernel32.dll" (ByVal hSnapshot As Long, ByRef lpte As THREADENTRY32) As Long
Private Declare Function Thread32Next()Function Thread32Next Lib "kernel32.dll" (ByVal hSnapshot As Long, ByRef lpte As THREADENTRY32) As Long
Public Type THREADENTRY32
  dwSize As Long
  cntUsage As Long
  th32ThreadID As Long
  th32OwnerProcessID As Long
  tpBasePri As Long
  tpDeltaPri As Long
  dwFlags As Long
End Type
Private Declare Function OpenThread()Function OpenThread Lib "kernel32.dll" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwThreadId As Long) As Long
Private Declare Function TerminateThread()Function TerminateThread Lib "kernel32" (ByVal hThread As Long, ByVal dwExitCode As Long) As Long
Private Declare Function SuspendThread()Function SuspendThread Lib "kernel32" (ByVal hThread As Long) As Long
Private Const THREAD_BASE_PRIORITY_LOWRT = 15
Private Const THREAD_BASE_PRIORITY_MAX = 2
Private Const THREAD_PRIORITY_NORMAL = 0
Private Const THREAD_BASE_PRIORITY_MIN = -2
Private Const THREAD_BASE_PRIORITY_IDLE = -15
Private Const THREAD_PRIORITY_TIME_CRITICAL = THREAD_BASE_PRIORITY_LOWRT
Private Const THREAD_PRIORITY_HIGHEST = THREAD_BASE_PRIORITY_MAX
Private Const THREAD_PRIORITY_LOWEST = THREAD_BASE_PRIORITY_MIN
Private Const THREAD_PRIORITY_IDLE = THREAD_BASE_PRIORITY_IDLE
Private Const THREAD_PRIORITY_BELOW_NORMAL = (THREAD_PRIORITY_LOWEST + 1)
Private Const THREAD_PRIORITY_ABOVE_NORMAL = (THREAD_PRIORITY_HIGHEST - 1)
Private Const THREAD_PRIORITY_ERROR_RETURN = (MAXLONG)
Private Const THREAD_IDLE_TIMEOUT = 10

Private Const THREAD_TERMINATE = (&H1)
Private Const THREAD_SUSPEND_RESUME = (&H2)
Private Const THREAD_GET_CONTEXT = (&H8)
Private Const THREAD_SET_CONTEXT = (&H10)
Private Const THREAD_SET_INFORMATION = (&H20)
Private Const THREAD_QUERY_INFORMATION = (&H40)
Private Const THREAD_SET_THREAD_TOKEN = (&H80)
Private Const THREAD_IMPERSONATE = (&H100)
Private Const THREAD_DIRECT_IMPERSONATION = (&H200)
Private Const THREAD_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED Or SYNCHRONIZE Or &H3FF)
'***************************************************************************************************************
Private Declare Function Module32First()Function Module32First Lib "kernel32.dll" (ByVal hSnapshot As Long, ByRef lpme As MODULEENTRY32) As Long
Private Declare Function Module32Next()Function Module32Next Lib "kernel32.dll" (ByVal hSnapshot As Long, ByRef lpme As MODULEENTRY32) As Long
Public Type MODULEENTRY32
  dwSize As Long
  th32ModuleID As Long
  th32ProcessID As Long
  GlblcntUsage As Long
  ProccntUsage As Long
  modBaseAddr As Long
  modBaseSize As Long
  hModule As Long
  szModule As String * 256
  szExePath As String * 260
End Type
'***************************************************************************************************************
Public Type ProcInfoPart
  ExeFile As String
  ExePath As String
  ProcessID As Long
  ParentProcessID As Long
  PriorityClass As Long
  Threads As Long
End Type

Public Type ProcInfoFull
  PriorityClass As Long
  pProcess32 As PROCESSENTRY32
  pMoudle32() As MODULEENTRY32
  'pThread32() As THREADENTRY32
End Type
'***************************************************************************************************************

'
'Public Function GetProcessThread(ByVal dwPID As Long, ByRef tThread32() As THREADENTRY32, Optional ByVal UptoDebug As Boolean = True) As Boolean
'  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
'  Dim hThreadSnap As Long, uThread32 As THREADENTRY32, i As Long, j As Long
'  hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, dwPID)
'  If hThreadSnap = INVALID_HANDLE_VALUE Then
'    GetProcessThread = False
'  Else
'    i = 0:    j = Len(uThread32)
'    uThread32.dwSize = j
'    uThread32.th32OwnerProcessID = dwPID
'    If Thread32First(hThreadSnap, uThread32) Then
'      Do
'        ReDim Preserve tThread32(i)
'        Call CopyMemory(tThread32(i), uThread32, j)
'        i = i + 1
'      Loop While Thread32Next(hThreadSnap, uThread32)
'      GetProcessThread = True
'    Else
'      GetProcessThread = False
'    End If
'    Call CloseHandle(hThreadSnap)
'  End If
'End Function

Public Function GetProcessModule()Function GetProcessModule(ByVal dwPID As Long, ByRef tMoudle32() As MODULEENTRY32, Optional ByVal UptoDebug As Boolean = True) As Boolean
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim hModuleSnap As Long, uMoudle32 As MODULEENTRY32, i As Long, j As Long
  hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID)
  If hModuleSnap = INVALID_HANDLE_VALUE Then
    GetProcessModule = False
  Else
    i = 0:    j = Len(uMoudle32)
    uMoudle32.dwSize = j
    uMoudle32.th32ProcessID = dwPID
    If Module32First(hModuleSnap, uMoudle32) Then
      Do
        ReDim Preserve tMoudle32(i)
        Call CopyMemory(tMoudle32(i), uMoudle32, j)
        i = i + 1
      Loop While Module32Next(hModuleSnap, uMoudle32)
      GetProcessModule = True
    Else
      GetProcessModule = False
    End If
    Call CloseHandle(hModuleSnap)
  End If
End Function

Public Function GetProcessListF()Function GetProcessListF(ByRef mProcInfo() As ProcInfoFull, Optional ByVal UptoDebug As Boolean = True) As Boolean
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim uProcess32 As PROCESSENTRY32, hSnapshot As Long, hProcess As Long, i As Long, j As Long
  hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0&)
  If hSnapshot = INVALID_HANDLE_VALUE Then
    GetProcessListF = False
  Else
    i = 0: j = Len(uProcess32)
    uProcess32.dwSize = j
    If Process32First(hSnapshot, uProcess32) Then
      Do
        ReDim Preserve mProcInfo(i)
        Call CopyMemory(mProcInfo(i).pProcess32, uProcess32, j)
        ReDim mProcInfo(i).pMoudle32(0)
        Call GetProcessModule(uProcess32.th32ProcessID, mProcInfo(i).pMoudle32(), False)
'        ReDim mProcInfo(i).pThread32(0)
'        Call GetProcessThread(uProcess32.th32ProcessID, mProcInfo(i).pThread32(), False)
        hProcess = OpenProcess(PROCESS_ALL_ACCESS, False, uProcess32.th32ProcessID)
        mProcInfo(i).PriorityClass = GetPriorityClass(hProcess)
        Call CloseHandle(hProcess)
        i = i + 1
      Loop While (Process32Next(hSnapshot, uProcess32))
      GetProcessListF = True
    Else
        GetProcessListF = True
    End If
    CloseHandle hSnapshot
  End If
End Function

Public Function GetProcessListP()Function GetProcessListP(ByRef mProcInfo() As ProcInfoPart, Optional ByVal UptoDebug As Boolean = True) As Boolean
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim hSnapshot As Long, hModuleSnap As Long
  Dim uProcess32 As PROCESSENTRY32, uMoudle32 As MODULEENTRY32
  Dim i As Long, hProcess As Long:      i = 0
  
  hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0&)
  If hSnapshot = INVALID_HANDLE_VALUE Then
    GetProcessListP = False
  Else
    uProcess32.dwSize = Len(uProcess32)
    If Process32First(hSnapshot, uProcess32) Then
        Do
          hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, uProcess32.th32ProcessID)
          If hModuleSnap <> INVALID_HANDLE_VALUE Then
            uMoudle32.dwSize = Len(uMoudle32)
            uMoudle32.th32ProcessID = uProcess32.th32ProcessID
            uMoudle32.th32ModuleID = uProcess32.th32ModuleID
            Call Module32First(hModuleSnap, uMoudle32)
            CloseHandle hModuleSnap
          End If
          ReDim Preserve mProcInfo(i)
          hProcess = OpenProcess(PROCESS_ALL_ACCESS, False, uProcess32.th32ProcessID)
          mProcInfo(i).PriorityClass = GetPriorityClass(hProcess)
          Call CloseHandle(hProcess)
          mProcInfo(i).ExeFile = uMoudle32.szModule
          mProcInfo(i).ExePath = uMoudle32.szExePath
          mProcInfo(i).ProcessID = uProcess32.th32ProcessID
          mProcInfo(i).ParentProcessID = uProcess32.th32ParentProcessID
          mProcInfo(i).Threads = uProcess32.cntThreads
          i = i + 1
        Loop While (Process32Next(hSnapshot, uProcess32))
        GetProcessListP = True
    Else
        GetProcessListP = True
    End If
    CloseHandle hSnapshot
  End If
End Function

Public Sub mEndTask()Sub mEndTask(Aimtask As Variant, Optional ByVal UptoDebug As Boolean = True)
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  If (VarType(Aimtask) And vbString) > 0 Then
    Dim MyID As Long: MyID = GetCurrentProcessId()
    Dim ProcInfo() As ProcInfoPart:  Call GetProcessListP(ProcInfo(), False)
    Dim i As Long
    If (VarType(Aimtask) And vbArray) > 0 Then
      Dim j As Long
      For i = 0 To UBound(ProcInfo)
        ProcInfo(i).ExeFile = UCase$(StrCutNull(ProcInfo(i).ExeFile))
        For j = 0 To UBound(Aimtask)
          If ProcInfo(i).ExeFile = UCase$(Aimtask(j)) And ProcInfo(i).ProcessID <> MyID Then mEndTaskById ProcInfo(i).ProcessID, False
        Next j
      Next i
    Else
      For i = 0 To UBound(ProcInfo)
        ProcInfo(i).ExeFile = UCase$(StrCutNull(ProcInfo(i).ExeFile))
        If ProcInfo(i).ExeFile = UCase$(Aimtask) And ProcInfo(i).ProcessID <> MyID Then mEndTaskById ProcInfo(i).ProcessID, False
      Next i
    End If
  End If
End Sub

Public Sub ScanUnNormalTask()Sub ScanUnNormalTask(Optional ByVal UptoDebug As Boolean = True)
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim MyID As Long: MyID = GetCurrentProcessId()
  Dim SysDir As String, i As Long, L As Long
  i = MAX_PATH
  SysDir = Space(i)
  Call GetSystemDirectory(SysDir, i)
  SysDir = UCase$(StrCutNull(SysDir))
  L = Len(SysDir)

  Dim TaskInfo() As ProcInfoPart
  Call GetProcessListP(TaskInfo(), False)
  For i = 0 To UBound(TaskInfo)
    If TaskInfo(i).ProcessID > 4 And Left(TaskInfo(i).ExePath, 1) <> "" And TaskInfo(i).ProcessID <> MyID Then
      If UCase$(Left(TaskInfo(i).ExePath, L)) <> SysDir Then Call mSuspendTaskById(TaskInfo(i).ProcessID, False)
    End If
  Next i
  
  Call GetProcessListP(TaskInfo(), False)
  For i = 0 To UBound(TaskInfo)
    If TaskInfo(i).ProcessID > 4 And Left(TaskInfo(i).ExePath, 1) <> "" And TaskInfo(i).ProcessID <> MyID Then
      If UCase$(Left(TaskInfo(i).ExePath, L)) <> SysDir Then Call mEndTaskById(TaskInfo(i).ProcessID, False)
    End If
  Next i
  
End Sub

Public Function mEndTaskById()Function mEndTaskById(Id As Long, Optional ByVal UptoDebug As Boolean = True) As Long
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim mHandle As Long
  mHandle = OpenProcess(ByVal PROCESS_ALL_ACCESS, ByVal 0&, Id)
    mEndTaskById = TerminateProcess(mHandle, 0&)
    If TerminateProcess(mHandle, 0&) = 0 Then NtSuspendProcess mHandle
  CloseHandle mHandle
End Function

Public Function mSuspendTaskById()Function mSuspendTaskById(Id As Long, Optional ByVal UptoDebug As Boolean = True) As Long
  On Error Resume Next:  If UptoDebug Then Call EnablePrivileges(GetCurrentProcess(), SE_DEBUG_NAME)
  Dim mHandle As Long
  mHandle = OpenProcess(ByVal PROCESS_ALL_ACCESS, ByVal 0&, Id)
    mSuspendTaskById = NtSuspendProcess(mHandle)
  CloseHandle mHandle
End Function

Private Function StrCutNull()Function StrCutNull(IStr As String) As String
  Dim i As Long
  i = InStr(1, IStr, Chr(0))
  If i <= 1 Then
    StrCutNull = vbNullString
  Else
    StrCutNull = Left$(IStr, i - 1)
  End If
End Function

'  If TerminateProcess(mHandle, 0&) = 0 Then
'    Dim mThread() As THREADENTRY32
'    ReDim mThread(0)
'    Call GetProcessThread(Id, mThread(), False)
'    Dim i As Long, hThread As Long
'    For i = 0 To UBound(mThread)
'      hThread = OpenThread(THREAD_ALL_ACCESS, False, mThread(i).th32ThreadID)
'      If TerminateThread(hThread, 0&) = 0 Then SuspendThread (hThread)
'      CloseHandle hThread
'    Next i
' End If
'***************************************************************************************************************

'#include <windows.h>
'#include <tlhelp32.h>
'#include <stdio.h>
'
'BOOL GetProcessListP()
'{
'    HANDLE         hProcessSnap = NULL;
'    BOOL           bRet      = FALSE;
'    PROCESSENTRY32 pe32      = {0};
'
'    //  Take a snapshot of all processes in the system.
'
'    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
'
'    if (hProcessSnap == INVALID_HANDLE_VALUE)
'        return (FALSE);
'
'    //  Fill in the size of the structure before using it.
'
'    pe32.dwSize = sizeof(PROCESSENTRY32);
'
'    //  Walk the snapshot of the processes, and for each process,
'    //  display information.
'
'    if (Process32First(hProcessSnap, &pe32))
'    {
'        DWORD         dwPriorityClass;
'        BOOL          bGotModule = FALSE;
'        MODULEENTRY32 uMoudle32       = {0};
'
'        Do
'        {
'            bGotModule = GetProcessModule(pe32.th32ProcessID,
'                pe32.th32ModuleID, &uMoudle32, sizeof(MODULEENTRY32));
'
'            if (bGotModule)
'            {
'                HANDLE hProcess;
'
'                // Get the actual priority class.
'                hProcess = OpenProcess (PROCESS_ALL_ACCESS,
'                    FALSE, pe32.th32ProcessID);
'                dwPriorityClass = GetPriorityClass (hProcess);
'                CloseHandle (hProcess);
'
'                // Print the process's information.
'                printf( " Priority Class Base %d ",
'                    pe32.pcPriClassBase);
'                printf( "PID %d ", pe32.th32ProcessID);
'                printf( "Thread Count %d ", pe32.cntThreads);
'                printf( "Module Name %s ", uMoudle32.szModule);
'                printf( "Full Path %s ", uMoudle32.szExePath);
'            }
'        }
'        while (Process32Next(hProcessSnap, &pe32));
'        bRet = TRUE;
'    }
'    Else
'        bRet = FALSE;    // could not walk the list of processes
'
'    // Do not forget to clean up the snapshot object.
'
'    CloseHandle (hProcessSnap);
'    return (bRet);
'}
'***************************************************************************************************************

'#include <windows.h>
'#include <tlhelp32.h>
'
'BOOL GetProcessModule (DWORD dwPID, DWORD dwModuleID,
'     LPMODULEENTRY32 lpuMoudle32, DWORD cbuMoudle32)
'{
'    BOOL          bRet        = FALSE;
'    BOOL          bFound      = FALSE;
'    HANDLE        hModuleSnap = NULL;
'    MODULEENTRY32 uMoudle32        = {0};
'
'    // Take a snapshot of all modules in the specified process.
'
'    hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
'    if (hModuleSnap == INVALID_HANDLE_VALUE)
'        return (FALSE);
'
'    // Fill the size of the structure before using it.
'
'    uMoudle32.dwSize = sizeof(MODULEENTRY32);
'
'    // Walk the module list of the process, and find the module of
'    // interest. Then copy the information to the buffer pointed
'    // to by lpuMoudle32 so that it can be returned to the caller.
'
'    if (Module32First(hModuleSnap, &uMoudle32))
'    {
'        Do
'        {
'            if (uMoudle32.th32ModuleID == dwModuleID)
'            {
'                CopyMemory (lpuMoudle32, &uMoudle32, cbuMoudle32);
'                bFound = TRUE;
'            }
'        }
'        while (!bFound && Module32Next(hModuleSnap, &uMoudle32));
'
'        bRet = bFound;   // if this sets bRet to FALSE, dwModuleID
'                         // no longer exists in specified process
'    }
'    Else
'        bRet = FALSE;           // could not walk module list
'
'    // Do not forget to clean up the snapshot object.
'
'    CloseHandle (hModuleSnap);
'
'    return (bRet);
'}