список объектов ядра Windows

#include <windows.h>
#include <stdio.h>
#include <Sddl.h>
 
#define NT_SUCCESS(inpNumber) ((inpNumber) >= 0)
#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004
 
#define SystemHandleInformation 16
#define ObjectBasicInformation 0
#define ObjectNameInformation 1
#define ObjectTypeInformation 2
 
typedef NTSTATUS (NTAPI *_NtQuerySystemInformation)(
    ULONG SystemInformationClass,
    PVOID SystemInformation,
    ULONG SystemInformationLength,
    PULONG ReturnLength
    );
typedef NTSTATUS (NTAPI *_NtDuplicateObject)(
    HANDLE SourceProcessHandle,
    HANDLE SourceHandle,
    HANDLE TargetProcessHandle,
    PHANDLE TargetHandle,
    ACCESS_MASK DesiredAccess,
    ULONG Attributes,
    ULONG Options
    );
typedef NTSTATUS (NTAPI *_NtQueryObject)(
    HANDLE ObjectHandle,
    ULONG ObjectInformationClass,
    PVOID ObjectInformation,
    ULONG ObjectInformationLength,
    PULONG ReturnLength
    );
 
typedef struct _UNICODE_STRING
{
    USHORT Length;
    USHORT MaximumLength;
    PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
 
typedef struct _SYSTEM_HANDLE
{
    ULONG ProcessId;
    BYTE ObjectTypeNumber;
    BYTE Flags;
    USHORT Handle;
    PVOID Object;
    ACCESS_MASK GrantedAccess;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;
 
typedef struct _SYSTEM_HANDLE_INFORMATION
{
    ULONG HandleCount;
    SYSTEM_HANDLE Handles[1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
 
typedef enum _POOL_TYPE
{
    NonPagedPool,
    PagedPool,
    NonPagedPoolMustSucceed,
    DontUseThisType,
    NonPagedPoolCacheAligned,
    PagedPoolCacheAligned,
    NonPagedPoolCacheAlignedMustS
} POOL_TYPE, *PPOOL_TYPE;
 
typedef struct _OBJECT_TYPE_INFORMATION
{
    UNICODE_STRING Name;
    ULONG TotalNumberOfObjects;
    ULONG TotalNumberOfHandles;
    ULONG TotalPagedPoolUsage;
    ULONG TotalNonPagedPoolUsage;
    ULONG TotalNamePoolUsage;
    ULONG TotalHandleTableUsage;
    ULONG HighWaterNumberOfObjects;
    ULONG HighWaterNumberOfHandles;
    ULONG HighWaterPagedPoolUsage;
    ULONG HighWaterNonPagedPoolUsage;
    ULONG HighWaterNamePoolUsage;
    ULONG HighWaterHandleTableUsage;
    ULONG InvalidAttributes;
    GENERIC_MAPPING GenericMapping;
    ULONG ValidAccess;
    BOOLEAN SecurityRequired;
    BOOLEAN MaintainHandleCount;
    USHORT MaintainTypeList;
    POOL_TYPE PoolType;
    ULONG PagedPoolUsage;
    ULONG NonPagedPoolUsage;
} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PVOID GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName)
{
    return GetProcAddress(GetModuleHandleA(LibraryName), ProcName);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Возвращает строку наоборот
void Reverse(char s[])
{
    int i, j;
    char c;
 
    for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Перевод строки из 10сс в 2сс
char * IntToBinary(int inpNumber)
{
    static char outStr[32];
    memset(outStr, 0, 32);
    outStr[32] = '\0';
 
    outStr[0] = inpNumber & 0xa000000;
 
    for (int step = 0; step <= 31; step++, inpNumber >>= 1)
    {
        if (inpNumber & 0x1 == 1)
            strcat(outStr, "1");
        else
            strcat(outStr, "0");
    }
    Reverse(outStr);
    static char endStr[33];
    memset(endStr, 32, 33);
    strncpy(endStr, outStr, 16);
    strncpy(endStr+17, outStr+16, 16);
    return endStr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Пробуем повысить привилегии
//http://msdn.microsoft.com/en-us/library/windows/desktop/aa446619
BOOL SetPrivilege(
    HANDLE hToken,          //хэндл процесса для установки
    LPCTSTR lpszPrivilege,  //какую будем устанавливать
    BOOL bEnablePrivilege   //установить или снять
    ) 
{
    TOKEN_PRIVILEGES tp;
    LUID luid;
 
    //Получим LUID
    if ( !LookupPrivilegeValue( 
        NULL,
        lpszPrivilege,
        &luid ) )
    {
        printf("LookupPrivilegeValue error: %u\n", GetLastError() ); 
        return FALSE; 
    }
 
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    if (bEnablePrivilege)
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    else
        tp.Privileges[0].Attributes = 0;
 
    if ( !(AdjustTokenPrivileges(
        hToken, 
        FALSE, 
        &tp, 
        sizeof(TOKEN_PRIVILEGES), 
        (PTOKEN_PRIVILEGES) NULL, 
        (PDWORD) NULL) ))
    { 
        printf("AdjustTokenPrivileges GetLastError: %u\n", GetLastError() ); 
        //попробуем дальше без повышения
        return FALSE; 
    } 
    //всё ок, получили повышение!
    return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void PrintToFile(FILE *f, POBJECT_TYPE_INFORMATION objectTypeInfo)
{
    fprintf(f, "GENERIC READ:\t%s\n", IntToBinary(objectTypeInfo->GenericMapping.GenericRead));
    fprintf(f, "GENERIC WRITE:\t%s\n", IntToBinary(objectTypeInfo->GenericMapping.GenericWrite));
    fprintf(f, "GENERIC EXECUTE:%s\n", IntToBinary(objectTypeInfo->GenericMapping.GenericExecute));
    fprintf(f, "GENERIC ALL:\t%s\n", IntToBinary(objectTypeInfo->GenericMapping.GenericAll));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "rights.h"
 
int wmain(int argc, WCHAR *argv[])
{
    //Импортим из библиотек Native-API функции
    _NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)
        GetLibraryProcAddress("ntdll.dll", "NtQuerySystemInformation");
    _NtDuplicateObject NtDuplicateObject = (_NtDuplicateObject)
        GetLibraryProcAddress("ntdll.dll", "NtDuplicateObject");
    _NtQueryObject NtQueryObject = (_NtQueryObject)
        GetLibraryProcAddress("ntdll.dll", "NtQueryObject");
 
    HANDLE hToken = NULL;
    OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &hToken);
    SetPrivilege(hToken, SE_DEBUG_NAME, TRUE);
    //SetPrivilege(hToken, SE_TCB_NAME, TRUE);
 
    NTSTATUS status;
    PSYSTEM_HANDLE_INFORMATION handleInfo;
    ULONG handleInfoSize = 0x10000;
    ULONG pid;
    HANDLE processHandle;
 
    //Получено ли значение требуемого процесса
    if (argc < 2)
    {
        printf("Give me PID through the console\n");
        return 1;
    }
 
    pid = _wtoi(argv[1]);
 
    //Пробуем подсоединиться к процессу, чтобы получить скопировать его хэндл
    if (!(processHandle = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid)))
    {
        DWORD q = GetLastError();
        printf("Could not open PID %d! Error: %d\n", pid, q);
        return 1;
    }
 
    FILE *fToPrint;
    //a - открыть для ДОзаписи, или создать для записи, если файла нет
    //w - перезапись по новой
    fToPrint = fopen("output.txt", "w");
    fprintf(fToPrint, "For process: %d\n", pid);
    handleInfo = (PSYSTEM_HANDLE_INFORMATION)malloc(handleInfoSize);
 
    //Подгнояем размер буфера
    while ((status = NtQuerySystemInformation(
        SystemHandleInformation,
        handleInfo,
        handleInfoSize,
        NULL
        )) == STATUS_INFO_LENGTH_MISMATCH)
        handleInfo = (PSYSTEM_HANDLE_INFORMATION)realloc(handleInfo, handleInfoSize *= 2);
 
    //NtQuerySystemInformation не вернула STATUS_INFO_LENGTH_MISMATCH
    if (!NT_SUCCESS(status))
    {
        printf("NtQuerySystemInformation failed!\n");
        return 1;
    }
 
    for (ULONG i = 0; i < handleInfo->HandleCount; i++)
    {
        SYSTEM_HANDLE handle = handleInfo->Handles[i];
 
        //только если подходит идентификатор - наш процесс
        if (pid != handle.ProcessId)
        {
            continue;
        }
 
        HANDLE dupHandle = NULL;
        POBJECT_TYPE_INFORMATION objectTypeInfo;
        PVOID objectNameInfo;
        UNICODE_STRING objectName;
        ULONG returnLength;
 
        //Копируем объект в свое адресное пространство
        if (!NT_SUCCESS(NtDuplicateObject(
            processHandle,
            (HANDLE)handle.Handle,
            GetCurrentProcess(),
            &dupHandle,
            0,
            0,
            0
            )))
        {
            //Память не выделилась, убираться за собой не нужно, переходим к следующему
            continue;
        }
 
        //Тащим информацию из объекта
        objectTypeInfo = (POBJECT_TYPE_INFORMATION)malloc(0x1000);
        if (!NT_SUCCESS(NtQueryObject(
            dupHandle,
            ObjectTypeInformation,
            objectTypeInfo,
            0x1000,
            NULL
            )))
        {
            //В случае ошибки - чистим память за собой
            CloseHandle(dupHandle);
            continue;
        }
 
        //Извлекаем инфу об имени
        //Если закончится неудачно - в returnLength вернется нужное количество и мы вызовем ещё раз, только уже с адекватной длиной
        objectNameInfo = malloc(0x1000);
        if (!NT_SUCCESS(NtQueryObject(
            dupHandle,
            ObjectNameInformation,
            objectNameInfo,
            0x1000,
            &returnLength
            )))
        {
            //returnLength адекватна для получения
            objectNameInfo = realloc(objectNameInfo, returnLength);
            if (!NT_SUCCESS(NtQueryObject(
                dupHandle,
                ObjectNameInformation,
                objectNameInfo,
                returnLength,
                NULL
                )))
            {
                //Не удалось получить имя
                fprintf(fToPrint, 
                    "[%#x] %.*S: (can't get name)\n",
                    handle.Handle,
                    objectTypeInfo->Name.Length / 2,
                    objectTypeInfo->Name.Buffer
                    );
                PrintToFile(fToPrint, objectTypeInfo);
 
                free(objectTypeInfo);
                free(objectNameInfo);
                CloseHandle(dupHandle);
                continue;
            }
        }
        //Имя есть,
        //переведем в строку Юникода
        objectName = *(PUNICODE_STRING)objectNameInfo;
        
        if (objectName.Length)
        {
            DWORD len;
            long buf[1024];
            PSECURITY_DESCRIPTOR desc = (PSECURITY_DESCRIPTOR)buf;
            DWORD length = sizeof(desc);
 
            fprintf(fToPrint, 
                "[%#x] %.*S: %.*S\n",
                handle.Handle,
                objectTypeInfo->Name.Length / 2,
                objectTypeInfo->Name.Buffer,
                objectName.Length / 2,
                objectName.Buffer
                );
            PrintToFile(fToPrint, objectTypeInfo);
        }
        else
        {
            //Объект безымянен
            fprintf(fToPrint, 
                "[%#x] %.*S: (unnamed)\n",
                handle.Handle,
                objectTypeInfo->Name.Length / 2,
                objectTypeInfo->Name.Buffer
                );
            PrintToFile(fToPrint, objectTypeInfo);
        }
 
        //Подчищаем память
        free(objectTypeInfo);
        free(objectNameInfo);
        CloseHandle(dupHandle);
    }
 
    free(handleInfo);
    CloseHandle(processHandle);
 
    return 0;
}