tests.cpp File Reference

perform tests More...

#include "pch.h"

Functions
BOOLEAN	SetupTestName (_Inout_updates_bytes_all_(BufferLength) PCHAR TestLocation, ULONG BufferLength)
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.

Variables
TCHAR	g_TestLocation [MAX_PATH]
	Holds the location test-hyperdbg.exe.

Detailed Description

perform tests

Author

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

Version

0.1

Date

2020-09-14

Copyright

This project is released under the GNU Public License v3.

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;
}

SetupTestName()

BOOLEAN SetupTestName	(	_Inout_updates_bytes_all_(BufferLength) PCHAR	TestLocation,
		ULONG	BufferLength )

Parameters

BufferLength

Setup test process name

Returns

BOOLEAN

{
    HANDLE  fileHandle;
    DWORD   driverLocLen = 0;
    HMODULE ProcHandle   = GetModuleHandle(NULL);
    char *  Pos;
 
    //
    // Get the current directory.
    //
 
    //
    // We use the location of running exe instead of
    // finding driver based on current directory
    //
 
    /*
  driverLocLen = GetCurrentDirectory(BufferLength, DriverLocation);
 
  if (driverLocLen == 0) {
 
    ShowMessages("err, GetCurrentDirectory failed (%x)\n", GetLastError());
 
    return FALSE;
  }
  */
 
    GetModuleFileName(ProcHandle, TestLocation, BufferLength);
 
    Pos = strrchr(TestLocation, '\\');
    if (Pos != NULL)
    {
        //
        // this will put the null terminator here. you can also copy to
        // another string if you want, we can also use PathCchRemoveFileSpec
        //
        *Pos = '\0';
    }
 
    //
    // Setup path name to driver file.
    //
    if (FAILED(StringCbCat(TestLocation, BufferLength, "\\" TEST_PROCESS_NAME)))
    {
        return FALSE;
    }
 
    //
    // Insure driver file is in the specified directory.
    //
    if ((fileHandle = CreateFile(TestLocation, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) ==
        INVALID_HANDLE_VALUE)
    {
        ShowMessages("%s.exe is not loaded.\n", TEST_PROCESS_NAME);
 
        //
        // Indicate failure.
        //
        return FALSE;
    }
 
    //
    // Close open file handle.
    //
    if (fileHandle)
    {
        CloseHandle(fileHandle);
    }
 
    //
    // Indicate success.
    //
    return TRUE;
}

Variable Documentation

g_TestLocation

TCHAR g_TestLocation[MAX_PATH]

extern

Holds the location test-hyperdbg.exe.

{0};