Ich versuche, ein Handle mit NTDLL

Question

zu greifen, zu duplizieren und zu schützen. Also versuche ich im Grunde die Prozesse zu durchlaufen, finde die Prozess-ID meines Prozesses (was funktioniert), öffne dann einen Prozess mit dieser PID (was auch funktioniert) und dann duplizieren Sie es mit NtDuplicateObject und schützen Sie es mit NtSetInformationObject.

Das Problem ist, dass es immer etwas falsch ist. Das erste Mal, als ich es versuchte, wollte es nicht duplizieren, schnell vorwärts bis jetzt und nach dem Auskommentieren des Teils, wo ich versuche, das alte Handle zu schließen (was ich nicht tun kann und das NtDuplicateObject sollte es auch nicht tun) gibt mir ein Handle, aber ich kann es nicht für WriteProcessMemory oder ähnliches verwenden. Ich werde die Funktion hier und den vollständigen Code in einem hastebin Link (falls es Verwirrungen in meinem Code, die einige Nähte müssen) abgeben

HANDLE PROTO_HAND::GrabPerfectHandle(const wchar_t *__processName) 
{ 
    if (__processName == nullptr) 
     return reinterpret_cast<HANDLE>(PRH_ERR_BADPARAM); 

    NTSTATUS __returnError; 

    SYSTEM_PROCESS_INFORMATION *__systemProcessInfo; 
    void *__systemInfo; 
    void *__allocationBuffer; 

    __allocationBuffer = VirtualAlloc(0, 1024 * 1024, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); 

    if (!__allocationBuffer) 
     return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTALLOC); 

    __systemProcessInfo = reinterpret_cast<SYSTEM_PROCESS_INFORMATION*>(__allocationBuffer); 

    if (!NT_SUCCESS(__returnError = NtQuerySystemInformation(SystemProcessInformation, __systemProcessInfo, 1024 * 1024, 0))) 
    { 
     if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
      return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

     return reinterpret_cast<HANDLE>(PRH_ERR_NTQUERYFAIL); 
    } 

    while (__systemProcessInfo->NextEntryOffset) 
    { 
     if (__systemProcessInfo->ImageName.Buffer != nullptr) 
     { 
      if (wcscmp(__systemProcessInfo->ImageName.Buffer, __processName) == 0) 
      { 
       HANDLE __basicHandle = OpenProcess(PROCESS_ALL_ACCESS, false, __systemProcessInfo->UniqueProcessId); 
       HANDLE __perfectHandle{ 0 }; 

       if (!__basicHandle) 
       { 
        if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

        return reinterpret_cast<HANDLE>(PRH_ERR_OPENPROCFAIL); 
       } 

       if (!NT_SUCCESS(NtDuplicateObject(GetCurrentProcess(), __basicHandle, GetCurrentProcess(), &__perfectHandle, PROCESS_ALL_ACCESS, 0, DUPLICATE_SAME_ACCESS))) 
       { 
        if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

        return reinterpret_cast<HANDLE>(PRH_ERR_DUPHANDFAIL); 
       } 

       /*if(!NtClose(__basicHandle)) 
       { 
        if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

        if(!CloseHandle(__basicHandle)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTCLOSEHAND); 

        return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTCLOSEHAND); 
       } 

       if(__basicHandle != nullptr) 
       { 
        if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

        return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTCLOSEHAND); 
       }*/ 

       _OBJECT_HANDLE_FLAG_INFORMATION __objectInformation{ 0 }; 
       __objectInformation.ProtectFromClose = { true }; 

       if (!NT_SUCCESS(NtSetInformationObject(__perfectHandle, ObjectHandleFlagInformation, &__objectInformation, sizeof(_OBJECT_HANDLE_FLAG_INFORMATION)))) 
       { 
        if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
         return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

        return reinterpret_cast<HANDLE>(PRH_ERR_PFCFAIL); 
       } 

       if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
        return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

       return __perfectHandle; 
      } 
     } 

     __systemProcessInfo = reinterpret_cast<SYSTEM_PROCESS_INFORMATION*>(reinterpret_cast<BYTE*>(__systemProcessInfo) + __systemProcessInfo->NextEntryOffset); 
    } 

    if (!VirtualFree(__allocationBuffer, 0, MEM_RELEASE)) 
     return reinterpret_cast<HANDLE>(PRH_ERR_CANNOTDEALLOC); 

    return reinterpret_cast<HANDLE>(PRH_ERR_FELLTROUGH); 
} 

Full: https://hastebin.com/moyehijehe.cpp

Answer 1

Auf einem flüchtigen Blick, ich denken das Problem kann Ihr Anruf GetProcessHandle sein. Das gibt eine pseudo-Griff (eine Konstante), dass das Betriebssystem kennt bedeutet ‚den aktuellen Prozess‘:

A pseudo handle is a special constant, currently (HANDLE)-1, that is interpreted as the current process handle. For compatibility with future operating systems, it is best to call GetCurrentProcess instead of hard-coding this constant value. The calling process can use a pseudo handle to specify its own process whenever a process handle is required. Pseudo handles are not inherited by child processes. 

Jetzt kann ich mich irren, wie ich gerade in Ihrem Code einen Blick zu, aber wenn Sie diese API verwenden, dann können Sie sicherlich kein zurückgegebenes Handle duplizieren (da es kein echtes Handle, nur eine Konstante ist).

Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx

Ich bin über die Unterschiede zwischen Ihrer Beschreibung des Vorsatzes und der Code neugierig. Warum durchlaufen Sie alle Prozesse, nur um Ihren eigenen Prozess zu finden? Sie können die PID mit einem einzigen API-Aufruf erhalten (z. B. GetProcessID).

So könnten Sie Ihren Code, um etwas zu ändern, wie (dies läßt den pseudo-Griff ‚durchgesickert‘, aber da es nicht wirklich ein Griff ist, ist nichts durchgesickert!):

HANDLE hRealHandle=OpenProcess(GetProcesssId(GetCurrentProcess()), ...); 

Natürlich Die Native-API-Entsprechungen von NT sind leicht zu ermitteln, wenn Sie sie bevorzugen, und ich überlasse das Ihnen, wenn dies sogar hilfreich ist.