Windows 10上不成功的TerminateProcess

Question

Our C++ app launches a separate .exe ( which may start its own sub-processes) using CreateProcess as below.

BOOL started = ::CreateProcess(NULL,      // application
                p,         // parameters
                NULL,        // process security
                NULL,        // thread security
                TRUE,        // inherit handles flag
                0,           // flags
                NULL,        // inherit environment
                dirLP,      // inherit directory
                &startup,    // STARTUPINFO
                &procinfo);  // PROCESS_INFORMATIO

In case we need cancel the "job" we use CreateToolhelp32Snapshot to iterate through the process list to find any child processes of the one we launched.

static BOOL TerminateProcessTree (HANDLE parentProcess,UINT exitCode) 
{ 
    BOOL            result=TRUE;
    HANDLE         hProcessSnap = NULL; 
    PROCESSENTRY32 pe32      = {0}; 
    //  Take a snapshot of all processes in the system. 

    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 

    if (hProcessSnap == INVALID_HANDLE_VALUE) 
        return (FALSE); 
     pe32.dwSize = sizeof(PROCESSENTRY32); 

    //  Walk the snapshot of the processes
    DWORD parentID=GetProcessId(parentProcess);
    if(parentID==0){
        PrintLastError("GetProcessId");
        return FALSE;
    }
   if (Process32First(hProcessSnap, &pe32)) { 
        do{ 
            if(pe32.th32ParentProcessID==parentID){

               HANDLE hProcess = OpenProcess (PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, pe32.th32ProcessID); 
               if(hProcess!=NULL){
                    BOOL terminateChildren=TerminateProcessTree(hProcess,exitCode);
                    BOOL terminatedChild = TerminateProcess(hProcess, exitCode);
                    if (!terminatedChild){
                        PrintLastError("TerminateProcess");
                    }
                    CloseHandle(hProcess);
                    if(!terminatedChild || !terminateChildren){
                        result=FALSE;
                        break;
                    }
               } else{
                   PrintLastError("OpenProcess");
               }
            }

        }while (Process32Next(hProcessSnap, &pe32)); 
    }
    CloseHandle (hProcessSnap); 
    DWORD checkCode=0;
    BOOL terminated;
    if(GetExitCodeProcess(parentProcess,&checkCode) && checkCode==STILL_ACTIVE){
        terminated=TerminateProcess(parentProcess,exitCode);
        if (!terminated){
            PrintLastError("TerminateProcess");
            result= FALSE;
        }
    }
    return result;
}

As noted, this works fine on Windows 7. Windows 10 fails with "Access Denied" on the first call "TerminateProcess". Clearly something has changed in the Windows security model when it comes to processes.

Answer 1

The robust way to deal with controlling a process tree of objects is to use Job objects as noted in the comment threads.

The one thing to keep in mind is that a process can only belong to a single job, and by default any EXE that the OS determines needs appcompat help is put into a job object automatically managed by the "Program Compatibility Assistant". This makes using a Job object to manage arbitrary 3rd party EXEs a little bit more complicated (ie AssignProcessToJobObject fails for these processes).

If you are using CreateProcess you can make use of the flag CREATE_BREAKAWAY_FROM_JOB . See this blog post . This works fine as long as the target EXE has the same rights as the calling object.

For a Standard User EXE to run an EXE that might need Administrator rights (ie they contain a manifest which marks it as requireAdministrator ), you have to use ShellExecute or ShellExecuteEx as calling CreateProcess in this case will fail. If your target EXEs are all using the proper manifest elements then it won't be put into a PCA Job object.. You can use the trick of passing SEE_MASK_FLAG_NO_UI which will have the side-effect of avoiding the PCA job behavior. If you are launching arbitrary 3rd party EXEs, you should use ShellExecuteEx and not CreateProcess .

bool SpawnProcess( const WCHAR* szExePath, const WCHAR* szExeArgs )
{
    if( !szExePath )
        return false;

    // NOTE: szExeArgs can be nullptr.

    // Get working directory from executable path.    
    WCHAR szDirectory[MAX_PATH] = {0};
    wcscpy_s( szDirectory, szExePath );
    PathRemoveFileSpec( szDirectory );

    // ShellExecute or ShellExecuteEx must be used instead of CreateProcess
    // to permit the shell to display a UAC prompt asking for consent to
    // elevate when the target executable's manifest specifies a run level
    // of "requireAdministrator".
    //
    // You can only use CreateProcess if you know that the application you
    // are spawning will be at the same run level as the current process.
    // Otherwise, you will receive ERROR_ACCESS_DENIED if the elevation
    // consent could not be obtained.
    SHELLEXECUTEINFO info = {};
    info.cbSize = sizeof( info );
    info.lpVerb = L"open";
    info.fMask = SEE_MASK_FLAG_NO_UI;
    info.lpFile = szExePath;
    info.lpParameters = szExeArgs;
    info.lpDirectory = szDirectory;
    info.nShow = SW_SHOW;
    if( !ShellExecuteEx( &info ) )
        return false;

    return true;
}

Note that if you want to wait until this process exits, you can use:

bool SpawnProcessAndWait( const WCHAR *szExePath, const WCHAR *szExeArgs, DWORD *pdwExitCode )
{
    if( !szExePath )
        return false;

    // NOTE: szExeArgs and pExitCode can be nullptr.

    // Get working directory from executable path.    
    WCHAR szDirectory[MAX_PATH] = {0};
    wcscpy_s( szDirectory, szExePath );
    PathRemoveFileSpec( szDirectory );

    // See SpawnProcess for information why ShellExecute or ShellExecuteEx
    // must be used instead of CreateProcess.
    SHELLEXECUTEINFO info = {};
    info.cbSize = sizeof( info );
    info.lpVerb = L"open";
    info.fMask = SEE_MASK_FLAG_NO_UI | SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS;
    info.lpFile = szExePath;
    info.lpParameters = szExeArgs;
    info.lpDirectory = szDirectory;
    info.nShow = SW_SHOW;
    if( !ShellExecuteEx( &info ) )
        return false;

    // Wait for process to finish.
    WaitForSingleObject( info.hProcess, INFINITE );

    // Return exit code from process, if requested by caller.
    if( pdwExitCode )
        GetExitCodeProcess( info.hProcess, pdwExitCode );

    CloseHandle( info.hProcess );
    return true;
}

You haven't noted if your "master" application here is using administrator or Standard User rights. Ideally it is using Standard User rights per the User Account Control guidelines dating back to Windows Vista. If your app is running as Standard User, then it's likely that your code no longer works due to security improvements to keep non-Administrator malware from doing this kind of thing to other processes.

For general appcompat questions about Windows 10, be sure to read the Windows and Windows Server compatibility cookbook and look back at the Windows 8.0 and Windows 8.1 material if you are jumping directly from Windows 7 to Windows 10.