communication.h File Reference

Go to the source code of this file.

Macros
#define	COM1_PORT   0x03F8
#define	COM2_PORT   0x02F8
#define	COM3_PORT   0x03E8
#define	COM4_PORT   0x02E8

Functions
int	CommunicationServerCreateServerAndWaitForClient (PCSTR Port, SOCKET *ClientSocketArg, SOCKET *ListenSocketArg)
	Create server and wait for a client to connect.
int	CommunicationServerReceiveMessage (SOCKET ClientSocket, char *recvbuf, int recvbuflen)
	listen and receive message as the server
int	CommunicationServerSendMessage (SOCKET ClientSocket, const char *sendbuf, int length)
	send message as the server
int	CommunicationServerShutdownAndCleanupConnection (SOCKET ClientSocket, SOCKET ListenSocket)
	Shutdown and cleanup connection as server.
int	CommunicationClientConnectToServer (PCSTR Ip, PCSTR Port, SOCKET *ConnectSocketArg)
	communication for client, connecting to the server
int	CommunicationClientSendMessage (SOCKET ConnectSocket, const char *sendbuf, int buflen)
	Send message a client.
int	CommunicationClientShutdownConnection (SOCKET ConnectSocket)
	shutdown the connection as a client
int	CommunicationClientReceiveMessage (SOCKET ConnectSocket, CHAR *RecvBuf, UINT32 MaxBuffLen, PUINT32 BuffLenRecvd)
	Receive message as a client.
int	CommunicationClientCleanup (SOCKET ConnectSocket)
	cleanup the connection as client
VOID	RemoteConnectionListen (PCSTR Port)
	Listen of a port and wait for a client connection.
VOID	RemoteConnectionConnect (PCSTR Ip, PCSTR Port)
	Connect to a remote debuggee (guest) as a client (host)
int	RemoteConnectionSendCommand (const char *sendbuf, int len)
	send the command as a client (debugger, host) to the server (debuggee, guest)
int	RemoteConnectionSendResultsToHost (const char *sendbuf, int len)
	Send the results of executing a command from deubggee (server, guest) to the debugger (client, host)
int	RemoteConnectionCloseTheConnectionWithDebuggee ()
	Close the connect from client side to the debuggee.

Macro Definition Documentation

COM1_PORT

#define COM1_PORT   0x03F8

COM2_PORT

#define COM2_PORT   0x02F8

COM3_PORT

#define COM3_PORT   0x03E8

COM4_PORT

#define COM4_PORT   0x02E8

Function Documentation

CommunicationClientCleanup()

int CommunicationClientCleanup

(

SOCKET

ConnectSocket

)

cleanup the connection as client

Parameters

ConnectSocket

Returns

int

{
    //
    // cleanup
    //
    closesocket(ConnectSocket);
    WSACleanup();
 
    return 0;
}

CommunicationClientConnectToServer()

int CommunicationClientConnectToServer	(	PCSTR	Ip,
		PCSTR	Port,
		SOCKET *	ConnectSocketArg )

communication for client, connecting to the server

Parameters

Ip
Port
ConnectSocketArg

Returns

int

{
    WSADATA          wsaData;
    SOCKET           ConnectSocket = INVALID_SOCKET;
    struct addrinfo *result = NULL, *ptr = NULL, hints;
    int              iResult;
 
    //
    // Initialize Winsock
    //
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0)
    {
        ShowMessages("err, WSAStartup failed (%x)\n", iResult);
        return 1;
    }
 
    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
 
    //
    // Resolve the server address and port
    //
    iResult = getaddrinfo(Ip, Port, &hints, &result);
    if (iResult != 0)
    {
        ShowMessages("getaddrinfo failed (%x)\n", iResult);
        WSACleanup();
        return 1;
    }
 
    //
    // Attempt to connect to an address until one succeeds
    //
    for (ptr = result; ptr != NULL; ptr = ptr->ai_next)
    {
        //
        // Create a SOCKET for connecting to server
        //
        ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
        if (ConnectSocket == INVALID_SOCKET)
        {
            ShowMessages("socket failed with error: %ld\n", WSAGetLastError());
            WSACleanup();
            return 1;
        }
 
        //
        // Connect to server.
        //
        iResult = connect(ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (iResult == SOCKET_ERROR)
        {
            closesocket(ConnectSocket);
            ConnectSocket = INVALID_SOCKET;
            continue;
        }
        break;
    }
 
    freeaddrinfo(result);
 
    if (ConnectSocket == INVALID_SOCKET)
    {
        ShowMessages("unable to connect to the server\n");
        WSACleanup();
        return 1;
    }
 
    //
    // Store the arguments
    //
    *ConnectSocketArg = ConnectSocket;
 
    return 0;
}

CommunicationClientReceiveMessage()

int CommunicationClientReceiveMessage	(	SOCKET	ConnectSocket,
		CHAR *	RecvBuf,
		UINT32	MaxBuffLen,
		PUINT32	BuffLenRecvd )

Receive message as a client.

Parameters

ConnectSocket
RecvBuf
MaxBuffLen
BuffLenRecvd

Returns

int

{
    int Result;
 
    //
    // Receive until the peer closes the connection
    //
    Result = recv(ConnectSocket, RecvBuf, MaxBuffLen, 0);
    if (Result > 0)
    {
        //
        // Set recvd buff len
        //
        *BuffLenRecvd = Result;
 
        /*
    ShowMessages("bytes received: %d\n", iResult);
        */
    }
    else if (Result == 0)
    {
        //
        // Last packet
        //
    }
    else
    {
        ShowMessages("\nrecv failed with error: %d\n", WSAGetLastError());
        ShowMessages("the remote system closes the connection.\n\n");
 
        return 1;
    }
 
    return 0;
}

CommunicationClientSendMessage()

int CommunicationClientSendMessage	(	SOCKET	ConnectSocket,
		const char *	sendbuf,
		int	buflen )

Send message a client.

Parameters

ConnectSocket
sendbuf
buflen

Returns

int

{
    int iResult;
 
    //
    // Send an initial buffer
    //
    iResult = send(ConnectSocket, sendbuf, buflen, 0);
    if (iResult == SOCKET_ERROR)
    {
        ShowMessages("err, send failed (%x)\n", WSAGetLastError());
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }
 
    return 0;
}

CommunicationClientShutdownConnection()

int CommunicationClientShutdownConnection

(

SOCKET

ConnectSocket

)

shutdown the connection as a client

Parameters

ConnectSocket

Returns

int

{
    int iResult;
 
    //
    // shutdown the connection since no more data will be sent
    //
    iResult = shutdown(ConnectSocket, SD_SEND);
    if (iResult == SOCKET_ERROR)
    {
        //
        // We comment this line because the connection might be removed;
        // thus, we don't need to show error
        //
 
        /*
    ShowMessages("err, shutdown failed (%x)\n", WSAGetLastError());
    */
 
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }
    return 0;
}

CommunicationServerCreateServerAndWaitForClient()

int CommunicationServerCreateServerAndWaitForClient	(	PCSTR	Port,
		SOCKET *	ClientSocketArg,
		SOCKET *	ListenSocketArg )

Create server and wait for a client to connect.

this function only accepts one client not multiple clients

Parameters

Port
ClientSocketArg
ListenSocketArg

Returns

int

{
    WSADATA wsaData;
    int     iResult;
 
    SOCKET ListenSocket = INVALID_SOCKET;
    SOCKET ClientSocket = INVALID_SOCKET;
 
    struct addrinfo * result = NULL;
    struct addrinfo   hints;
 
    //
    // Initialize Winsock
    //
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0)
    {
        ShowMessages("err, WSAStartup failed (%x)\n", iResult);
        return 1;
    }
 
    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family   = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags    = AI_PASSIVE;
 
    //
    // Resolve the server address and port
    //
    iResult = getaddrinfo(NULL, Port, &hints, &result);
    if (iResult != 0)
    {
        ShowMessages("err, getaddrinfo failed (%x)\n", iResult);
        WSACleanup();
        return 1;
    }
 
    //
    // Create a SOCKET for connecting to server
    //
    ListenSocket =
        socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (ListenSocket == INVALID_SOCKET)
    {
        ShowMessages("socket failed with error: %ld\n", WSAGetLastError());
        freeaddrinfo(result);
        WSACleanup();
        return 1;
    }
 
    //
    // Setup the TCP listening socket
    //
    iResult = ::bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);
    if (iResult == SOCKET_ERROR)
    {
        ShowMessages("err, bind failed (%x)\n", WSAGetLastError());
        freeaddrinfo(result);
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
 
    freeaddrinfo(result);
 
    iResult = listen(ListenSocket, SOMAXCONN);
    if (iResult == SOCKET_ERROR)
    {
        ShowMessages("err, listen failed (%x)\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
 
    //
    // Accept a client socket
    //
    sockaddr_in name    = {0};
    int         addrlen = sizeof(name);
 
    ClientSocket = accept(ListenSocket, (struct sockaddr *)&name, &addrlen);
 
    if (ClientSocket == INVALID_SOCKET)
    {
        ShowMessages("err, accept failed (%x)\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
 
    //
    // Show that we connected to a client
    //
    ShowMessages("connected to : %s:%d\n", inet_ntoa(name.sin_addr), ntohs(name.sin_port));
 
    //
    // Set the argument
    //
    *ClientSocketArg = ClientSocket;
    *ListenSocketArg = ListenSocket;
 
    return 0;
}

CommunicationServerReceiveMessage()

int CommunicationServerReceiveMessage	(	SOCKET	ClientSocket,
		char *	recvbuf,
		int	recvbuflen )

listen and receive message as the server

Parameters

ClientSocket
recvbuf
recvbuflen

Returns

int

{
    int iResult;
 
    //
    // Receive until the peer shuts down the connection
    //
    iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
    if (iResult > 0)
    {
        //
        // ShowMessages("bytes received: %d\n", iResult);
        //
    }
    else if (iResult == 0)
    {
        //
        // ShowMessages("connection closing...\n");
        //
    }
    else
    {
        ShowMessages("err, recv failed (%x)\n", WSAGetLastError());
        closesocket(ClientSocket);
        WSACleanup();
 
        return 1;
    }
 
    return 0;
}

CommunicationServerSendMessage()

int CommunicationServerSendMessage	(	SOCKET	ClientSocket,
		const char *	sendbuf,
		int	length )

send message as the server

Parameters

ClientSocket
sendbuf
length

Returns

int

{
    int iSendResult;
 
    //
    // Echo the buffer back to the sender
    //
    iSendResult = send(ClientSocket, sendbuf, length, 0);
    if (iSendResult == SOCKET_ERROR)
    {
        /*
    ShowMessages("err, send failed (%x)\n", WSAGetLastError());
    closesocket(ClientSocket);
    WSACleanup();
        */
        return 1;
    }
    return 0;
}

CommunicationServerShutdownAndCleanupConnection()

int CommunicationServerShutdownAndCleanupConnection	(	SOCKET	ClientSocket,
		SOCKET	ListenSocket )

Shutdown and cleanup connection as server.

Parameters

ClientSocket
ListenSocket

Returns

int

{
    int iResult;
 
    //
    // No longer need server socket
    //
    closesocket(ListenSocket);
 
    //
    // shutdown the connection since we're done
    //
    iResult = shutdown(ClientSocket, SD_SEND);
    if (iResult == SOCKET_ERROR)
    {
        //
        // We comment this line because the connection might be removed;
        // thus, we don't need to show error
        //
 
        /*
    ShowMessages("err, shutdown failed (%x)\n", WSAGetLastError());
    */
 
        closesocket(ClientSocket);
        WSACleanup();
        return 1;
    }
 
    //
    // cleanup
    //
    closesocket(ClientSocket);
    WSACleanup();
 
    return 0;
}

RemoteConnectionCloseTheConnectionWithDebuggee()

int RemoteConnectionCloseTheConnectionWithDebuggee

(

)

Close the connect from client side to the debuggee.

Returns

int returning 0 means that there was no error in executing the function and 1 shows there was an error

{
    CommunicationClientShutdownConnection(g_ClientConnectSocket);
    CommunicationClientCleanup(g_ClientConnectSocket);
 
    return 0;
}

RemoteConnectionConnect()

VOID RemoteConnectionConnect	(	PCSTR	Ip,
		PCSTR	Port )

Connect to a remote debuggee (guest) as a client (host)

this routine is supposed to be called by .connect command

Parameters

Ip
Port

Returns

VOID

{
    DWORD  ThreadId;
    CHAR   Recv[3]  = {0};
    UINT32 BuffRecv = 0;
 
    //
    // Check if the debugger or debuggee is already active
    //
    if (IsConnectedToAnyInstanceOfDebuggerOrDebuggee())
    {
        return;
    }
 
    //
    // Connect to server
    //
    if (CommunicationClientConnectToServer(Ip, Port, &g_ClientConnectSocket) == 1)
    {
        //
        // There was an error
        //
 
        //
        // Indicate that debugger is not connected
        //
        g_IsConnectedToHyperDbgLocally = FALSE;
 
        //
        // Indicate that it's not a remote  debuggee
        //
        g_IsConnectedToRemoteDebuggee = FALSE;
 
        //
        // Shutdown connection
        //
        CommunicationClientShutdownConnection(g_ClientConnectSocket);
 
        //
        // Cleanup
        //
        CommunicationClientCleanup(g_ClientConnectSocket);
    }
    else
    {
        //
        // Connection was successful
        //
 
        //
        // Check to see whether the version of debugger and debuggee matches together or not
        //
        if (CommunicationClientSendMessage(g_ClientConnectSocket, (const char *)BuildSignature, sizeof(BuildSignature)) != 0)
        {
            //
            // Failed
            //
            ShowMessages("err, failed to communicate with debuggee\n");
            return;
        }
 
        //
        // Receive the handshake results
        //
        if (CommunicationClientReceiveMessage(g_ClientConnectSocket, Recv, sizeof(Recv), &BuffRecv) != 0)
        {
            //
            // Failed, break
            //
            ShowMessages("err, failed to receive message from debuggee\n");
            return;
        }
 
        //
        // Check if the handshake was successful or not
        //
        if (strcmp((const char *)"OK", Recv) != 0)
        {
            //
            // Build version not matched
            //
            ShowMessages(ASSERT_MESSAGE_BUILD_SIGNATURE_DOESNT_MATCH);
            return;
        }
 
        //
        // Indicate that local debugger is not connected
        //
        g_IsConnectedToHyperDbgLocally = FALSE;
 
        //
        // Indicate that it's a remote debuggee
        //
        g_IsConnectedToRemoteDebuggee = TRUE;
 
        //
        // Create an event to show signature when the messages finished
        //
        if (g_EndOfMessageReceivedEvent == NULL)
        {
            g_EndOfMessageReceivedEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
        }
 
        //
        // Now, we should create a thread, which always listens to
        // the remote debuggee for new messages
        // Listen for upcoming messages
        //
        g_RemoteDebuggeeListeningThread = CreateThread(
            NULL,
            0,
            RemoteConnectionThreadListeningToDebuggee,
            NULL,
            0,
            &ThreadId);
 
        ShowMessages("connected to %s:%s\n", Ip, Port);
    }
}

RemoteConnectionListen()

VOID RemoteConnectionListen

(

PCSTR

Port

)

Listen of a port and wait for a client connection.

this routine is supposed to be called by .listen command

Parameters

Port

Returns

VOID

{
    char recvbuf[COMMUNICATION_BUFFER_SIZE] = {0};
 
    //
    // Check if the debugger or debuggee is already active
    //
    if (IsConnectedToAnyInstanceOfDebuggerOrDebuggee())
    {
        return;
    }
 
    //
    // Start server and wait for client
    //
    CommunicationServerCreateServerAndWaitForClient(Port, &g_SeverSocket, &g_ServerListenSocket);
 
    //
    // Check the version of debuggee and debugger
    //
    if (CommunicationServerReceiveMessage(g_SeverSocket, recvbuf, COMMUNICATION_BUFFER_SIZE) != 0)
    {
        //
        // Failed
        //
        ShowMessages("err, unable to handshake with the remote debugger\n");
 
        //
        // Close the connection
        //
        CommunicationServerShutdownAndCleanupConnection(g_SeverSocket, g_ServerListenSocket);
 
        return;
    }
 
    //
    // Check whether the signature of debuggee and debugger match or not
    //
    if (strcmp((const char *)BuildSignature, recvbuf) != 0)
    {
        //
        // Build version not matched
        //
        ShowMessages(ASSERT_MESSAGE_BUILD_SIGNATURE_DOESNT_MATCH);
 
        //
        // Send unsuccessful handshake (version match) message
        //
        if (CommunicationServerSendMessage(g_SeverSocket, "NO", 3) != 0)
        {
            //
            // Failed
            //
            ShowMessages("err, unable to handshake with the remote debugger\n");
        }
 
        //
        // Close the connection
        //
        CommunicationServerShutdownAndCleanupConnection(g_SeverSocket, g_ServerListenSocket);
 
        return;
    }
    else
    {
        //
        // Send successful handshake (version match) message
        //
        if (CommunicationServerSendMessage(g_SeverSocket, "OK", 3) != 0)
        {
            //
            // Failed
            //
            ShowMessages("err, unable to handshake with the remote debugger\n");
 
            //
            // Close the connection
            //
            CommunicationServerShutdownAndCleanupConnection(g_SeverSocket, g_ServerListenSocket);
 
            return;
        }
    }
 
    //
    // Indicate that it's a remote debugger
    //
    g_IsConnectedToRemoteDebugger = TRUE;
 
    //
    // And also, make it a local debugger
    //
    g_IsConnectedToHyperDbgLocally = TRUE;
 
    //
    // Zero the buffer for next command
    //
    RtlZeroMemory(recvbuf, COMMUNICATION_BUFFER_SIZE);
 
    while (true)
    {
        //
        // Receive message (this loop works as a command executer,
        // we don't send the results to the remote machine by using
        // this tools
        //
        if (CommunicationServerReceiveMessage(g_SeverSocket, recvbuf, COMMUNICATION_BUFFER_SIZE) != 0)
        {
            //
            // Failed, break
            //
            break;
        }
 
        //
        // Execute the command
        //
        int CommandExecutionResult = HyperDbgInterpreter(recvbuf);
 
        //
        // Send end of buffer
        //
        RemoteConnectionSendResultsToHost((const char *)g_EndOfBufferCheckTcp, sizeof(g_EndOfBufferCheckTcp));
 
        //
        // if the debugger encounters an exit state then the return will be 1
        //
        if (CommandExecutionResult == 1)
        {
            //
            // Exit from the debugger
            //
            exit(0);
        }
 
        //
        // Zero the buffer for next command
        //
        RtlZeroMemory(recvbuf, COMMUNICATION_BUFFER_SIZE);
    }
 
    //
    // Indicate that debugger is not connected
    //
    g_IsConnectedToHyperDbgLocally = FALSE;
 
    //
    // Indicate that it's note a remote debugger
    //
    g_IsConnectedToRemoteDebugger = FALSE;
 
    //
    // Indicate that we're not in remote debugger anymore
    //
    ShowMessages("closing the conntection...\n");
 
    //
    // Close the connection
    //
    CommunicationServerShutdownAndCleanupConnection(g_SeverSocket,
                                                    g_ServerListenSocket);
}

RemoteConnectionSendCommand()

int RemoteConnectionSendCommand	(	const char *	sendbuf,
		int	len )

send the command as a client (debugger, host) to the server (debuggee, guest)

Parameters

sendbuf	address of message buffer
len	length of buffer

Returns

int returning 0 means that there was no error in executing the function and 1 shows there was an error

{
    //
    // Send Message
    //
    if (CommunicationClientSendMessage(g_ClientConnectSocket, sendbuf, len) != 0)
    {
        //
        // Failed
        //
        return 1;
    }
 
    //
    // We wait for the debuggee to send the message
    //
    WaitForSingleObject(
        g_EndOfMessageReceivedEvent,
        INFINITE);
 
    //
    // Successful
    //
    return 0;
}

RemoteConnectionSendResultsToHost()

int RemoteConnectionSendResultsToHost	(	const char *	sendbuf,
		int	len )

Send the results of executing a command from deubggee (server, guest) to the debugger (client, host)

Parameters

sendbuf	buffer address
len	length of buffer

Returns

int returning 0 means that there was no error in executing the function and 1 shows there was an error

{
    //
    // Send the message
    //
    if (CommunicationServerSendMessage(g_SeverSocket, sendbuf, len) != 0)
    {
        //
        // Failed
        //
        return 1;
    }
 
    return 0;
}