test.cpp File Reference

test command More...

#include "pch.h"

Functions
VOID	CommandTestHelp ()
	help of the test command
BOOLEAN	CommandTestPerformKernelTestsIoctl ()
	Send an IOCTL to the kernel to run the.
BOOLEAN	CommandTestPerformTest ()
	perform test on the remote process
VOID	CommandTestQueryState ()
	test command for query the state
VOID	CommandTestQueryTrapState ()
	test command for query the trap state
VOID	CommandTestQueryPreAllocPoolsState ()
	test command for query the state of pre-allocated pools
VOID	CommandTestSetTargetTaskToHaltedCores (BOOLEAN Synchronous)
	test command for setting target tasks to halted cores
VOID	CommandTestSetTargetTaskToTargetCore (UINT32 CoreNumber)
	test command for setting target task to the specified core
VOID	CommandTestSetBreakpointState (BOOLEAN State)
	test command for turning on/off the breakpoints (#DB)
VOID	CommandTestSetDebugBreakState (BOOLEAN State)
	test command for turning on/off the debug breaks (#DB)
VOID	CommandTest (vector< string > SplitCommand, string Command)
	test command handler

Variables
BOOLEAN	g_IsSerialConnectedToRemoteDebuggee
	Shows if the debugger was connected to remote debuggee over (A remote guest)

Detailed Description

test command

Author

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

Version

0.1

Date

2020-06-11

Copyright

This project is released under the GNU Public License v3.

Function Documentation

CommandTest()

VOID CommandTest	(	vector< string >	SplitCommand,
		string	Command )

test command handler

Parameters

SplitCommand
Command

Returns

VOID

{
    UINT64 Context = NULL;
 
    if (SplitCommand.size() == 1)
    {
        //
        // For testing functionalities
        //
        CommandTestPerformTest();
    }
    else if (SplitCommand.size() == 2 && !SplitCommand.at(1).compare("query"))
    {
        //
        // Query the state of debuggee in debugger mode
        //
        CommandTestQueryState();
    }
    else if (SplitCommand.size() == 2 && !SplitCommand.at(1).compare("trap-status"))
    {
        //
        // Query the state of trap flag in debugger mode
        //
        CommandTestQueryTrapState();
    }
    else if (SplitCommand.size() == 2 && !SplitCommand.at(1).compare("pool"))
    {
        //
        // Query the state of pre-allocated pools in debugger mode
        //
        CommandTestQueryPreAllocPoolsState();
    }
    else if (SplitCommand.size() == 2 && !SplitCommand.at(1).compare("sync-task"))
    {
        //
        // Send target task to the halted cores in debugger mode (synchronous)
        //
        CommandTestSetTargetTaskToHaltedCores(TRUE);
    }
    else if (SplitCommand.size() == 2 && !SplitCommand.at(1).compare("async-task"))
    {
        //
        // Send target task to the halted cores in debugger mode (asynchronous)
        //
        CommandTestSetTargetTaskToHaltedCores(FALSE);
    }
    else if (SplitCommand.size() == 3 && !SplitCommand.at(1).compare("target-core-task"))
    {
        if (!ConvertStringToUInt64(SplitCommand.at(2), &Context))
        {
            ShowMessages("err, you should enter a valid hex number as the core id\n\n");
            return;
        }
 
        //
        // Send target task to the specific halted core in debugger mode
        //
        CommandTestSetTargetTaskToTargetCore((UINT32)Context);
    }
    else if (SplitCommand.size() == 3 && !SplitCommand.at(1).compare("breakpoint"))
    {
        //
        // Change breakpoint state
        //
        if (!SplitCommand.at(2).compare("on"))
        {
            CommandTestSetBreakpointState(TRUE);
        }
        else if (!SplitCommand.at(2).compare("off"))
        {
            CommandTestSetBreakpointState(FALSE);
        }
        else
        {
            ShowMessages("err, couldn't resolve error at '%s'\n\n", SplitCommand.at(2).c_str());
            return;
        }
    }
    else if (SplitCommand.size() == 3 && !SplitCommand.at(1).compare("trap"))
    {
        //
        // Change debug break state
        //
        if (!SplitCommand.at(2).compare("on"))
        {
            CommandTestSetDebugBreakState(TRUE);
        }
        else if (!SplitCommand.at(2).compare("off"))
        {
            CommandTestSetDebugBreakState(FALSE);
        }
        else
        {
            ShowMessages("err, couldn't resolve error at '%s'\n\n", SplitCommand.at(2).c_str());
            return;
        }
    }
    else
    {
        ShowMessages("incorrect use of the 'test'\n\n");
        CommandTestHelp();
        return;
    }
}

CommandTestHelp()

VOID CommandTestHelp

(

)

help of the test command

Returns

VOID

{
    ShowMessages(
        "test : tests essential features of HyperDbg in current machine.\n");
 
    ShowMessages("syntax : \ttest [Task (string)]\n");
 
    ShowMessages("\n");
    ShowMessages("\t\te.g : test\n");
    ShowMessages("\t\te.g : test query\n");
    ShowMessages("\t\te.g : test trap-status\n");
    ShowMessages("\t\te.g : test pool\n");
    ShowMessages("\t\te.g : test query\n");
    ShowMessages("\t\te.g : test breakpoint on\n");
    ShowMessages("\t\te.g : test breakpoint off\n");
    ShowMessages("\t\te.g : test trap on\n");
    ShowMessages("\t\te.g : test trap off\n");
}

CommandTestPerformKernelTestsIoctl()

BOOLEAN CommandTestPerformKernelTestsIoctl

(

)

Send an IOCTL to the kernel to run the.

Returns

BOOLEAN

{
    BOOL                          Status;
    ULONG                         ReturnedLength;
    DEBUGGER_PERFORM_KERNEL_TESTS KernelTestRequest = {0};
 
    AssertShowMessageReturnStmt(g_DeviceHandle, ASSERT_MESSAGE_DRIVER_NOT_LOADED, AssertReturnFalse);
 
    //
    // By the way, we don't need to send an input buffer
    // to the kernel, but let's keep it like this, if we
    // want to pass some other arguments to the kernel in
    // the future
    //
    Status = DeviceIoControl(
        g_DeviceHandle,                       // Handle to device
        IOCTL_PERFROM_KERNEL_SIDE_TESTS,      // IO Control Code (IOCTL)
        &KernelTestRequest,                   // Input Buffer to driver.
        SIZEOF_DEBUGGER_PERFORM_KERNEL_TESTS, // Input buffer length
        &KernelTestRequest,                   // Output Buffer from driver.
        SIZEOF_DEBUGGER_PERFORM_KERNEL_TESTS, // Length of output buffer in
                                              // bytes.
        &ReturnedLength,                      // Bytes placed in buffer.
        NULL                                  // synchronous call
    );
 
    if (!Status)
    {
        ShowMessages("ioctl failed with code 0x%x\n", GetLastError());
        return FALSE;
    }
 
    if (KernelTestRequest.KernelStatus == DEBUGGER_OPERATION_WAS_SUCCESSFUL)
    {
        //
        // Nothing to show
        //
        return TRUE;
    }
    else
    {
        //
        // Show err message
        //
        ShowErrorMessage(KernelTestRequest.KernelStatus);
        return FALSE;
    }
}

CommandTestPerformTest()

BOOLEAN CommandTestPerformTest

(

)

perform test on the remote process

Returns

BOOLEAN returns true if the results was true and false if the results was not ok

{
    BOOLEAN ResultOfTest = FALSE;
    HANDLE  PipeHandle;
    HANDLE  ThreadHandle;
    HANDLE  ProcessHandle;
    UINT32  ReadBytes;
    CHAR *  Buffer = NULL;
 
    //
    // Allocate memory
    //
    Buffer = (CHAR *)malloc(TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    if (!Buffer)
    {
        ShowMessages("err, enable allocate communication buffer\n");
        return FALSE;
    }
 
    RtlZeroMemory(Buffer, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    //
    // Create tests process to create a thread for us
    //
    if (!CreateProcessAndOpenPipeConnection(&PipeHandle,
                                            &ThreadHandle,
                                            &ProcessHandle))
    {
        ShowMessages("err, enable to connect to the test process\n");
 
        free(Buffer);
 
        return FALSE;
    }
 
    //
    // ***** Perform test specific routines *****
    //
 
    //
    // Wait for the result of test to be received
    //
 
SendCommandAndWaitForResponse:
 
    CHAR TestCommand[] = "this is a test command";
 
    BOOLEAN SentMessageResult = NamedPipeServerSendMessageToClient(
        PipeHandle,
        TestCommand,
        (UINT32)strlen(TestCommand) + 1);
 
    if (!SentMessageResult)
    {
        //
        // error in sending
        //
        return FALSE;
    }
 
    RtlZeroMemory(Buffer, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
    ReadBytes =
        NamedPipeServerReadClientMessage(PipeHandle, (char *)Buffer, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    if (!ReadBytes)
    {
        //
        // Nothing to read
        //
        free(Buffer);
 
        return FALSE;
    }
 
    goto SendCommandAndWaitForResponse;
 
    //
    // Close connection and remote process
    //
    CloseProcessAndClosePipeConnection(PipeHandle, ThreadHandle, ProcessHandle);
 
    free(Buffer);
 
    return ResultOfTest;
}

CommandTestQueryPreAllocPoolsState()

VOID CommandTestQueryPreAllocPoolsState

(

)

test command for query the state of pre-allocated pools

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the query to the debuggee
    //
    KdSendTestQueryPacketToDebuggee(TEST_QUERY_PREALLOCATED_POOL_STATE);
}

CommandTestQueryState()

VOID CommandTestQueryState

(

)

test command for query the state

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the query to the debuggee
    //
    KdSendTestQueryPacketToDebuggee(TEST_QUERY_HALTING_CORE_STATUS);
}

CommandTestQueryTrapState()

VOID CommandTestQueryTrapState

(

)

test command for query the trap state

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the query to the debuggee
    //
    KdSendTestQueryPacketToDebuggee(TEST_QUERY_TRAP_STATE);
}

CommandTestSetBreakpointState()

VOID CommandTestSetBreakpointState

(

BOOLEAN

State

)

test command for turning on/off the breakpoints (#DB)

Parameters

State

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the breakpoint settings to the debuggee
    //
    if (State)
    {
        KdSendTestQueryPacketToDebuggee(TEST_BREAKPOINT_TURN_ON_BPS);
    }
    else
    {
        KdSendTestQueryPacketToDebuggee(TEST_BREAKPOINT_TURN_OFF_BPS);
    }
}

CommandTestSetDebugBreakState()

VOID CommandTestSetDebugBreakState

(

BOOLEAN

State

)

test command for turning on/off the debug breaks (#DB)

Parameters

State

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the debug break settings to the debuggee
    //
    if (State)
    {
        KdSendTestQueryPacketToDebuggee(TEST_BREAKPOINT_TURN_ON_DBS);
    }
    else
    {
        KdSendTestQueryPacketToDebuggee(TEST_BREAKPOINT_TURN_OFF_DBS);
    }
}

CommandTestSetTargetTaskToHaltedCores()

VOID CommandTestSetTargetTaskToHaltedCores

(

BOOLEAN

Synchronous

)

test command for setting target tasks to halted cores

Parameters

Synchronous

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the target tasks to the halted cores
    //
    KdSendTestQueryPacketToDebuggee(Synchronous ? TEST_SETTING_TARGET_TASKS_ON_HALTED_CORES_SYNCHRONOUS : TEST_SETTING_TARGET_TASKS_ON_HALTED_CORES_ASYNCHRONOUS);
}

CommandTestSetTargetTaskToTargetCore()

VOID CommandTestSetTargetTaskToTargetCore

(

UINT32

CoreNumber

)

test command for setting target task to the specified core

Parameters

CoreNumber

Returns

VOID

{
    if (!g_IsSerialConnectedToRemoteDebuggee)
    {
        ShowMessages("err, query state of the debuggee is only possible when you connected "
                     "in debugger mode\n");
        return;
    }
 
    //
    // Send the target task to the target halted core
    //
    KdSendTestQueryPacketWithContextToDebuggee(TEST_SETTING_TARGET_TASKS_ON_TARGET_HALTED_CORES, (UINT64)CoreNumber);
}

Variable Documentation

g_IsSerialConnectedToRemoteDebuggee

BOOLEAN g_IsSerialConnectedToRemoteDebuggee

extern

Shows if the debugger was connected to remote debuggee over (A remote guest)