tests.h File Reference

headers for test functions More...

Go to the source code of this file.

Macros
#define	TEST_PROCESS_NAME   "hyperdbg-test.exe"
	exe name of test process

Functions
BOOLEAN	CreateProcessAndOpenPipeConnection (PHANDLE ConnectionPipeHandle, PHANDLE ThreadHandle, PHANDLE ProcessHandle)
	Create a Process And Open Pipe Connection object.
VOID	CloseProcessAndClosePipeConnection (HANDLE ConnectionPipeHandle, HANDLE ThreadHandle, HANDLE ProcessHandle)
	Close the pipe connection and the remote process.

Detailed Description

headers for test functions

Author

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

Version

0.1

Date

2020-05-27

Copyright

This project is released under the GNU Public License v3.

Macro Definition Documentation

TEST_PROCESS_NAME

#define TEST_PROCESS_NAME   "hyperdbg-test.exe"

exe name of test process

Function Documentation

CloseProcessAndClosePipeConnection()

VOID CloseProcessAndClosePipeConnection	(	HANDLE	ConnectionPipeHandle,
		HANDLE	ThreadHandle,
		HANDLE	ProcessHandle )

Close the pipe connection and the remote process.

Parameters

ConnectionPipeHandle	Handle of remote pipe connection
ThreadHandle	Handle of test thread
ProcessHandle	Handle of test process

Returns

VOID

{
    //
    // Close the connection and handles
    //
    NamedPipeServerCloseHandle(ConnectionPipeHandle);
    CloseHandle(ThreadHandle);
    CloseHandle(ProcessHandle);
}

CreateProcessAndOpenPipeConnection()

BOOLEAN CreateProcessAndOpenPipeConnection	(	PHANDLE	ConnectionPipeHandle,
		PHANDLE	ThreadHandle,
		PHANDLE	ProcessHandle )

Create a Process And Open Pipe Connection object.

Parameters

ConnectionPipeHandle	Pointer to receive Pipe Handle
ThreadHandle	Pointer to receive Thread Handle
ProcessHandle	Pointer to receive Process Handle

Returns

BOOLEAN

{
    HANDLE              PipeHandle;
    BOOLEAN             SentMessageResult;
    UINT32              ReadBytes;
    char *              BufferToRead;
    char *              BufferToSend;
    char                HandshakeBuffer[] = "Hello, Dear Test Process... Yes, I'm HyperDbg Debugger :)";
    PROCESS_INFORMATION ProcessInfo;
    STARTUPINFO         StartupInfo;
    char                CmdArgs[] = TEST_PROCESS_NAME " im-hyperdbg";
 
    PipeHandle = NamedPipeServerCreatePipe("\\\\.\\Pipe\\HyperDbgTests",
                                           TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE,
                                           TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
    if (!PipeHandle)
    {
        //
        // Error in creating handle
        //
        return FALSE;
    }
 
    BufferToRead = (char *)malloc(TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    if (!BufferToRead)
    {
        //
        // Enable to allocate buffer
        //
        return FALSE;
    }
 
    BufferToSend = (char *)malloc(TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    if (!BufferToSend)
    {
        //
        // Enable to allocate buffer
        //
        free(BufferToSend);
        return FALSE;
    }
 
    RtlZeroMemory(BufferToRead, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
    RtlZeroMemory(BufferToSend, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
    strcpy(BufferToSend, HandshakeBuffer);
 
    //
    // Create the Test Process
    //
 
    ZeroMemory(&StartupInfo, sizeof(StartupInfo));
 
    //
    // the only compulsory field
    //
    StartupInfo.cb = sizeof StartupInfo;
 
    //
    // Set-up path
    //
    if (!SetupTestName(g_TestLocation, sizeof(g_TestLocation)))
    {
        //
        // Test process not found
        //
        free(BufferToRead);
        free(BufferToSend);
 
        return FALSE;
    }
 
    if (CreateProcess(g_TestLocation, CmdArgs, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &StartupInfo, &ProcessInfo))
    {
        //
        // Wait for message from the target process
        //
        if (!NamedPipeServerWaitForClientConntection(PipeHandle))
        {
            //
            // Error in connection
            //
            free(BufferToRead);
            free(BufferToSend);
 
            return FALSE;
        }
 
        ReadBytes =
            NamedPipeServerReadClientMessage(PipeHandle, BufferToRead, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
        if (!ReadBytes)
        {
            //
            // Nothing to read
            //
 
            free(BufferToRead);
            free(BufferToSend);
 
            return FALSE;
        }
 
        if (strcmp(BufferToRead, "Hey there, Are you HyperDbg?") == 0)
        {
            //
            // *** Connected to the remote process ***
            //
 
            //
            // Send the hand shake message
            //
            SentMessageResult = NamedPipeServerSendMessageToClient(
                PipeHandle,
                BufferToSend,
                (UINT32)strlen(BufferToSend) + 1);
 
            if (!SentMessageResult)
            {
                //
                // error in sending
                //
 
                free(BufferToRead);
                free(BufferToSend);
 
                return FALSE;
            }
 
            //
            // Receive the request for the test case number
            //
            RtlZeroMemory(BufferToRead, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
            ReadBytes = NamedPipeServerReadClientMessage(PipeHandle, BufferToRead, TEST_CASE_MAXIMUM_BUFFERS_TO_COMMUNICATE);
 
            if (!ReadBytes)
            {
                //
                // Nothing to read
                //
 
                free(BufferToRead);
                free(BufferToSend);
 
                return FALSE;
            }
 
            if (strcmp(BufferToRead, "Wow! I miss you... Would you plz send test cases?") == 0)
            {
                //
                // Set the output handles
                //
                *ConnectionPipeHandle = PipeHandle;
                *ThreadHandle         = ProcessInfo.hThread;
                *ProcessHandle        = ProcessInfo.hProcess;
 
                free(BufferToRead);
                free(BufferToSend);
 
                return TRUE;
            }
 
            ShowMessages("err, could not handshake with the test process\n");
 
            free(BufferToRead);
            free(BufferToSend);
 
            return FALSE;
        }
        else
        {
            ShowMessages("err, the process could not be started\n");
 
            free(BufferToRead);
            free(BufferToSend);
 
            return FALSE;
        }
    }
 
    free(BufferToRead);
    free(BufferToSend);
 
    return FALSE;
}