Example #1
0
static int command_wait_reading_thread(HANDLE *handle)
{
	DWORD exitCode = MAXDWORD;
	if (*handle == INVALID_HANDLE_VALUE)
		return -1;

	WaitForSingleObject(*handle, INFINITE);
	if (!GetExitCodeThread(*handle, &exitCode) || exitCode) {
		safeCloseHandle(handle);
		return -1;
	}
	safeCloseHandle(handle);
	return 0;
}
Example #2
0
static DWORD WINAPI AsyncReadingThread(LPVOID lpParam)
{
	struct ASYNCREADINGTHREADARGS* pDataArray = (struct ASYNCREADINGTHREADARGS*)lpParam;

	int ret = command_readall(*pDataArray->handle, pDataArray->dest);

	safeCloseHandle(pDataArray->handle);

	git__free(pDataArray);

	return ret;
}
Example #3
0
void SetKeyloggingState(enum KeyLoggerState state)
{
	static HANDLE s_hThread = 0;
	static DWORD s_threadID;

	// If key logging should be off then terminate the thead
	// if it is running.
	if (state == kKeyLoggerOff)
	{
		if (s_hThread)
		{
			PostThreadMessage(s_threadID, WM_QUIT, 0, 0);
			WaitForSingleObject(s_hThread, INFINITE);


			//CloseHandle(s_hThread);
			safeCloseHandle(s_hThread);
			
			
			//analyze catches this!
			//safeCloseHandle(s_hThread);
			
			
			s_hThread = 0;
		}
		return;
	}

	// If key logging should be on then start the thread if
	// it isn't running.
	if (!s_hThread)
	{
		s_hThread = CreateThread(NULL, 0, InputThread, NULL, 0, &s_threadID);
	}

	switch (state)
	{
	case kKeyLoggerAnonymized:
		g_LogKeyboardDetails = false;
		break;
	case kKeyLoggerFull:
		g_LogKeyboardDetails = true;
		break;
	}
}
Example #4
0
void command_close_stdout(COMMAND_HANDLE *commandHandle)
{
	safeCloseHandle(&commandHandle->out);
}
Example #5
0
void command_close_stdin(COMMAND_HANDLE *commandHandle)
{
	safeCloseHandle(&commandHandle->in);
}
Example #6
0
int command_start(wchar_t *cmd, COMMAND_HANDLE *commandHandle, LPWSTR* pEnv, DWORD flags)
{
	SECURITY_ATTRIBUTES sa;
	HANDLE hReadOut = INVALID_HANDLE_VALUE, hWriteOut = INVALID_HANDLE_VALUE, hReadIn = INVALID_HANDLE_VALUE, hWriteIn = INVALID_HANDLE_VALUE, hReadError = INVALID_HANDLE_VALUE, hWriteError = INVALID_HANDLE_VALUE;
	STARTUPINFOW si = { 0 };
	PROCESS_INFORMATION pi = { 0 };

	si.cb = sizeof(STARTUPINFOW);

	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
	sa.lpSecurityDescriptor = NULL;
	sa.bInheritHandle = TRUE;
	if (!CreatePipe(&hReadOut, &hWriteOut, &sa, 0)) {
		giterr_set(GITERR_OS, "Could not create pipe");
		return -1;
	}
	if (!CreatePipe(&hReadIn, &hWriteIn, &sa, 0)) {
		giterr_set(GITERR_OS, "Could not create pipe");
		CloseHandle(hReadOut);
		CloseHandle(hWriteOut);
		return -1;
	}
	if (commandHandle->errBuf && !CreatePipe(&hReadError, &hWriteError, &sa, 0)) {
		giterr_set(GITERR_OS, "Could not create pipe");
		CloseHandle(hReadOut);
		CloseHandle(hWriteOut);
		CloseHandle(hReadIn);
		CloseHandle(hWriteIn);
		return -1;
	}

	si.hStdOutput = hWriteOut;
	si.hStdInput = hReadIn;
	si.hStdError = hWriteError;

	// Ensure the read/write handle to the pipe for STDOUT resp. STDIN are not inherited.
	if (!SetHandleInformation(hReadOut, HANDLE_FLAG_INHERIT, 0) || !SetHandleInformation(hWriteIn, HANDLE_FLAG_INHERIT, 0) || (commandHandle->errBuf && !SetHandleInformation(hReadError, HANDLE_FLAG_INHERIT, 0))) {
		giterr_set(GITERR_OS, "SetHandleInformation failed");
		CloseHandle(hReadOut);
		CloseHandle(hWriteOut);
		CloseHandle(hReadIn);
		CloseHandle(hWriteIn);
		safeCloseHandle(&hReadError);
		safeCloseHandle(&hWriteError);
		return -1;
	}

	si.wShowWindow = SW_HIDE;
	si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;

	if (!CreateProcessW(NULL, cmd, NULL, NULL, TRUE, CREATE_UNICODE_ENVIRONMENT | flags, pEnv ? *pEnv : NULL, NULL, &si, &pi)) {
		giterr_set(GITERR_OS, "Could not start external tool");
		CloseHandle(hReadOut);
		CloseHandle(hWriteOut);
		CloseHandle(hReadIn);
		CloseHandle(hWriteIn);
		safeCloseHandle(&hReadError);
		safeCloseHandle(&hWriteError);
		return -1;
	}

	AllowSetForegroundWindow(pi.dwProcessId);
	WaitForInputIdle(pi.hProcess, 10000);

	CloseHandle(hReadIn);
	CloseHandle(hWriteOut);
	if (commandHandle->errBuf) {
		HANDLE asyncReadErrorThread;
		CloseHandle(hWriteError);
		commandHandle->err = hReadError;
		asyncReadErrorThread = commmand_start_reading_thread(&commandHandle->err, commandHandle->errBuf);
		if (!asyncReadErrorThread) {
			CloseHandle(hReadOut);
			CloseHandle(hWriteIn);
			CloseHandle(hReadError);
			return -1;
		}
		commandHandle->asyncReadErrorThread = asyncReadErrorThread;
	}

	commandHandle->pi = pi;
	commandHandle->out = hReadOut;
	commandHandle->in = hWriteIn;
	commandHandle->running = TRUE;
	return 0;
}