/********************************************************/

/*  ntapi: Native API core library                      */

/*  Copyright (C) 2013--2016  Z. Gilboa                 */

/*  Released under GPLv2 and GPLv3; see COPYING.NTAPI.  */

/********************************************************/

#include <psxtypes/psxtypes.h>

#include <ntapi/nt_memory.h>

#include <ntapi/nt_process.h>

#include <ntapi/ntapi.h>

#include "ntapi_impl.h"

typedef struct _nt_process_basic_information nt_pbi;

int32_t __stdcall __ntapi_tt_create_remote_runtime_data(

	__in		void *			hprocess,

	__in_out	nt_runtime_data_block *	rtblock)

{

	int32_t			status;

	size_t			bytes_written;

	nt_pbi			rpbi;

	nt_process_parameters *	rprocess_params;

	nt_unicode_string	rcmd_line;

	uint32_t		runtime_arg_hash;

	nt_runtime_data *	rtdata;

	void *			srv_ready;

	#if defined (__NT32)

	wchar16_t		runtime_arg[8] = {

		'i','n','t','e','g','r','a','l'};

	#elif defined (__NT64)

	wchar16_t		runtime_arg[16] = {

		'i','n','t','e','g','r','a','l',

		'-','r','u','n','t','i','m','e'};

	#endif

	/* validation */

	if (!hprocess)

		return NT_STATUS_INVALID_PARAMETER_1;

	else if (!rtblock)

		return NT_STATUS_INVALID_PARAMETER_2;

	else if (!rtblock->addr)

		return NT_STATUS_INVALID_PARAMETER_2;

	else if (!rtblock->size)

		return NT_STATUS_INVALID_PARAMETER_2;

	runtime_arg_hash = __ntapi->tt_buffer_crc32(

		0,

		(char *)runtime_arg,

		sizeof(runtime_arg));

	/* obtain process information */

	if ((status = __ntapi->zw_query_information_process(

			hprocess,

			NT_PROCESS_BASIC_INFORMATION,

			(void *)&rpbi,

			sizeof(nt_process_basic_information),

			0)))

		return status;

	if ((status = __ntapi->zw_read_virtual_memory(

			hprocess,

			pe_va_from_rva(

				rpbi.peb_base_address,

				(uintptr_t)&(((nt_peb *)0)->process_params)),

			(char *)&rprocess_params,

			sizeof(uintptr_t),

			&bytes_written)))

		return status;

	if ((status = __ntapi->zw_read_virtual_memory(

			hprocess,

			&rprocess_params->command_line,

			(char *)&rcmd_line,

			sizeof(nt_unicode_string),

			&bytes_written)))

		return status;

	if (rcmd_line.buffer == 0)

		return NT_STATUS_BUFFER_TOO_SMALL;

	if (rcmd_line.strlen < sizeof(runtime_arg) + 4*sizeof(wchar16_t))

		return NT_STATUS_INVALID_USER_BUFFER;

	if ((status = __ntapi->zw_read_virtual_memory(

			hprocess,

			pe_va_from_rva(

				rcmd_line.buffer,

				rcmd_line.strlen - sizeof(runtime_arg)),

			(char *)&runtime_arg,

			sizeof(runtime_arg),

			&bytes_written)))

		return status;

	/* verify remote process compatibility */

	runtime_arg_hash ^= __ntapi->tt_buffer_crc32(

		0,(char *)runtime_arg,

		sizeof(runtime_arg));

	if (runtime_arg_hash)

		return NT_STATUS_INVALID_SIGNATURE;

	/* remote block */

	rtblock->remote_size = rtblock->size;

	if ((status = __ntapi->zw_allocate_virtual_memory(

			hprocess,

			&rtblock->remote_addr,

			0,

			&rtblock->remote_size,

			NT_MEM_RESERVE | NT_MEM_COMMIT,

			NT_PAGE_READWRITE)))

		return status;

	/* session handles */

	rtdata    = 0;

	srv_ready = 0;

	if (rtblock->flags & NT_RUNTIME_DATA_DUPLICATE_SESSION_HANDLES) {

		rtdata    = (nt_runtime_data *)rtblock->addr;

		srv_ready = rtdata->srv_ready;

		if ((status = __ntapi->zw_duplicate_object(

				NT_CURRENT_PROCESS_HANDLE,

				srv_ready,

				hprocess,

				&rtdata->srv_ready,

				0,0,

				NT_DUPLICATE_SAME_ATTRIBUTES

				|NT_DUPLICATE_SAME_ACCESS)))

			return status;

	}

	/* copy local block to remote process */

	status = __ntapi->zw_write_virtual_memory(

		hprocess,

		rtblock->remote_addr,

		(char *)rtblock->addr,

		rtblock->size,

		&bytes_written);

	/* restore rtdata */

	if (rtdata)

		rtdata->srv_ready = srv_ready;

	/* verify above remote write */

	if (status)

		return status;

	/* runtime_arg */

	__ntapi->tt_uintptr_to_hex_utf16(

		(uintptr_t)rtblock->remote_addr,

		runtime_arg);

	/* update remote runtime arg */

	status = __ntapi->zw_write_virtual_memory(

		hprocess,

		pe_va_from_rva(

			rcmd_line.buffer,

			rcmd_line.strlen - sizeof(runtime_arg)),

		(char *)&runtime_arg,

		sizeof(runtime_arg),

		&bytes_written);

	if (status)

		__ntapi->zw_free_virtual_memory(

			hprocess,

			&rtblock->remote_addr,

			&rtblock->remote_size,

			NT_MEM_RELEASE);

	return status;

}