la force de tout processus en cours d'exécution à un crash

Bien, utilisez CreateRemoteThread sur un processus distant et invoquer quelque chose [1] qui bloque le processus de manière fiable. Je ne suis pas sûr de savoir si CreateRemoteThread protège contre les pointeurs nuls, mais vous pouvez passer d'une adresse dans la page nulle à ce que le processus distant d'exécuter.

[1] pointeur null ou la valeur null à la page d'accès de la division par zéro, l'invocation du privilège de l'instruction, de int3 ...

Exemple:

#include <stdio.h>
#include <tchar.h>
#include <Windows.h>

BOOL setCurrentPrivilege(BOOL bEnable, LPCTSTR lpszPrivilege)
{
    HANDLE hToken = 0;
    if(::OpenThreadToken(::GetCurrentThread(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, FALSE, &hToken)
        || ::OpenProcessToken(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
    {
        TOKEN_PRIVILEGES tp;
        LUID luid;

        if(!::LookupPrivilegeValue(
            NULL,            //lookup privilege on local system
            lpszPrivilege,   //privilege to lookup 
            &luid ) )        //receives LUID of privilege
        {
            ::CloseHandle(hToken);
            return FALSE; 
        }
        tp.PrivilegeCount = 1;
        tp.Privileges[0].Luid = luid;
        tp.Privileges[0].Attributes = (bEnable) ?  SE_PRIVILEGE_ENABLED : 0;

        //Enable the privilege or disable all privileges.
        if(!::AdjustTokenPrivileges(
            hToken,
            FALSE,
            &tp,
            sizeof(TOKEN_PRIVILEGES),
            (PTOKEN_PRIVILEGES) NULL,
            (PDWORD) NULL)
            )
        {
            CloseHandle(hToken);
            return FALSE; 
        }
        ::CloseHandle(hToken);
    }
    return TRUE;
}

int killProcess(DWORD processID)
{
    HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, processID);
    if(hProcess)
    {
        if(!setCurrentPrivilege(TRUE, SE_DEBUG_NAME))
        {
            _tprintf(TEXT("Could not enable debug privilege\n"));
        }
        HANDLE hThread = ::CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)1, NULL, 0, NULL);
        if(hThread)
        {
            ::CloseHandle(hThread);
        }
        else
        {
            _tprintf(TEXT("Error: %d\n"), GetLastError());
            ::CloseHandle(hProcess);
            return 1;
        }
        ::CloseHandle(hProcess);
    }
    return 0;
}

int __cdecl _tmain(int argc, _TCHAR *argv[])
{
    killProcess(3016);
}

Bien sûr, vous aurez envie de régler le PID dans l'appel à killProcess. Compilé avec WNET DDK et testé sur Serveur 2003 R2.

L'essentiel ici est que nous disent les processus distant d'exécuter du code à l'adresse 0x1 ((LPTHREAD_START_ROUTINE)1), qui est à l'intérieur de la page null, mais pas un pointeur null (dans le cas où il y a des vérifications qui). Le crud autour de la fonction, en particulier setCurrentPrivilege est utilisé pour obtenir le débogage complet privilèges afin que nous puissions faire notre maléfique.

OriginalL'auteur 0xC0000022L

Deux étapes mécanisme est nécessaire:

1. injecter le processus de blocage (à l'aide d'une injection de la bibliothèque, à l'aide de Détours, à l'aide d'un Crochet d'installation, etc..). Ce que vous choisissez dépend de l'époque et les connaissances que vous avez, et d'autres conditions préalables (comme les informations d'identification, anti-injection de la protection, de la taille de l'empreinte que vous voulez quitter..)
2. effectuer une opération non valide dans l'injection de processus (comme int 2Eh, diviser par la valeur null, etc..)

OriginalL'auteur mox