asm/asm.c
author Ruben Gonzalez <drifter01620@gmail.com>
Wed Nov 12 08:29:24 2014 -0500 (2014-11-12)
changeset 197 fd967f09ab68
parent 184 7ddf645a50d5
permissions -rw-r--r--
Update CSGO Gamedata
drifter01620@184
     1
#include "asm.h"
drifter01620@184
     2
drifter01620@184
     3
#ifndef WIN32
drifter01620@184
     4
#define _GNU_SOURCE
drifter01620@184
     5
#include <dlfcn.h>
drifter01620@184
     6
#include <string.h>
drifter01620@184
     7
drifter01620@184
     8
#define REG_EAX			0
drifter01620@184
     9
#define REG_ECX			1
drifter01620@184
    10
#define REG_EDX			2
drifter01620@184
    11
#define REG_EBX			3
drifter01620@184
    12
drifter01620@184
    13
#define IA32_MOV_REG_IMM		0xB8	// encoding is +r <imm32>
drifter01620@184
    14
#endif
drifter01620@184
    15
drifter01620@184
    16
extern void Msg( const char *, ... );
drifter01620@184
    17
drifter01620@184
    18
/**
drifter01620@184
    19
* Checks if a call to a fpic thunk has just been written into dest.
drifter01620@184
    20
* If found replaces it with a direct mov that sets the required register to the value of pc.
drifter01620@184
    21
*
drifter01620@184
    22
* @param dest		Destination buffer where a call opcode + addr (5 bytes) has just been written.
drifter01620@184
    23
* @param pc		The program counter value that needs to be set (usually the next address from the source).
drifter01620@184
    24
* @noreturn
drifter01620@184
    25
*/
drifter01620@184
    26
void check_thunks(unsigned char *dest, unsigned char *pc)
drifter01620@184
    27
{
drifter01620@184
    28
#if defined WIN32
drifter01620@184
    29
	return;
drifter01620@184
    30
#else
drifter01620@184
    31
	/* Step write address back 4 to the start of the function address */
drifter01620@184
    32
	unsigned char *writeaddr = dest - 4;
drifter01620@184
    33
	unsigned char *calloffset = *(unsigned char **)writeaddr;
drifter01620@184
    34
	unsigned char *calladdr = (unsigned char *)(dest + (unsigned int)calloffset);
drifter01620@184
    35
drifter01620@184
    36
	/* Lookup name of function being called */
drifter01620@184
    37
	if ((*calladdr == 0x8B) && (*(calladdr+2) == 0x24) && (*(calladdr+3) == 0xC3))
drifter01620@184
    38
	{
drifter01620@184
    39
		//a thunk maybe?
drifter01620@184
    40
		char movByte = IA32_MOV_REG_IMM;
drifter01620@184
    41
drifter01620@184
    42
		/* Calculate the correct mov opcode */
drifter01620@184
    43
		switch (*(calladdr+1))
drifter01620@184
    44
		{
drifter01620@184
    45
		case 0x04:
drifter01620@184
    46
			{
drifter01620@184
    47
				movByte += REG_EAX;
drifter01620@184
    48
				break;
drifter01620@184
    49
			}
drifter01620@184
    50
		case 0x1C:
drifter01620@184
    51
			{
drifter01620@184
    52
				movByte += REG_EBX;
drifter01620@184
    53
				break;
drifter01620@184
    54
			}
drifter01620@184
    55
		case 0x0C:
drifter01620@184
    56
			{
drifter01620@184
    57
				movByte += REG_ECX;
drifter01620@184
    58
				break;
drifter01620@184
    59
			}
drifter01620@184
    60
		case 0x14:
drifter01620@184
    61
			{
drifter01620@184
    62
				movByte += REG_EDX;
drifter01620@184
    63
				break;
drifter01620@184
    64
			}
drifter01620@184
    65
		default:
drifter01620@184
    66
			{
drifter01620@184
    67
				Msg("Unknown thunk: %c\n", *(calladdr+1));
drifter01620@184
    68
				break;
drifter01620@184
    69
			}
drifter01620@184
    70
		}
drifter01620@184
    71
drifter01620@184
    72
		/* Move our write address back one to where the call opcode was */
drifter01620@184
    73
		writeaddr--;
drifter01620@184
    74
drifter01620@184
    75
drifter01620@184
    76
		/* Write our mov */
drifter01620@184
    77
		*writeaddr = movByte;
drifter01620@184
    78
		writeaddr++;
drifter01620@184
    79
drifter01620@184
    80
		/* Write the value - The provided program counter value */
drifter01620@184
    81
		*(void **)writeaddr = (void *)pc;
drifter01620@184
    82
		writeaddr += 4;
drifter01620@184
    83
	}
drifter01620@184
    84
drifter01620@184
    85
	return;
drifter01620@184
    86
#endif
drifter01620@184
    87
}
drifter01620@184
    88
drifter01620@184
    89
//if dest is NULL, returns minimum number of bytes needed to be copied
drifter01620@184
    90
//if dest is not NULL, it will copy the bytes to dest as well as fix CALLs and JMPs
drifter01620@184
    91
//http://www.devmaster.net/forums/showthread.php?t=2311
drifter01620@184
    92
int copy_bytes(unsigned char *func, unsigned char* dest, int required_len) {
drifter01620@184
    93
	int bytecount = 0;
drifter01620@184
    94
drifter01620@184
    95
	while(bytecount < required_len && *func != 0xCC)
drifter01620@184
    96
	{
drifter01620@184
    97
		// prefixes F0h, F2h, F3h, 66h, 67h, D8h-DFh, 2Eh, 36h, 3Eh, 26h, 64h and 65h
drifter01620@184
    98
		int operandSize = 4;
drifter01620@184
    99
		int FPU = 0;
drifter01620@184
   100
		int twoByte = 0;
drifter01620@184
   101
		unsigned char opcode = 0x90;
drifter01620@184
   102
		unsigned char modRM = 0xFF;
drifter01620@184
   103
		while(*func == 0xF0 ||
drifter01620@184
   104
			  *func == 0xF2 ||
drifter01620@184
   105
			  *func == 0xF3 ||
drifter01620@184
   106
			 (*func & 0xFC) == 0x64 ||
drifter01620@184
   107
			 (*func & 0xF8) == 0xD8 ||
drifter01620@184
   108
			 (*func & 0x7E) == 0x62)
drifter01620@184
   109
		{
drifter01620@184
   110
			if(*func == 0x66)
drifter01620@184
   111
			{
drifter01620@184
   112
				operandSize = 2;
drifter01620@184
   113
			}
drifter01620@184
   114
			else if((*func & 0xF8) == 0xD8)
drifter01620@184
   115
			{
drifter01620@184
   116
				FPU = *func;
drifter01620@184
   117
				if (dest)
drifter01620@184
   118
						*dest++ = *func++;
drifter01620@184
   119
				else
drifter01620@184
   120
						func++;
drifter01620@184
   121
				bytecount++;
drifter01620@184
   122
				break;
drifter01620@184
   123
			}
drifter01620@184
   124
drifter01620@184
   125
			if (dest)
drifter01620@184
   126
				*dest++ = *func++;
drifter01620@184
   127
			else
drifter01620@184
   128
				func++;
drifter01620@184
   129
			bytecount++;
drifter01620@184
   130
		}
drifter01620@184
   131
drifter01620@184
   132
		// two-byte opcode byte
drifter01620@184
   133
		if(*func == 0x0F)
drifter01620@184
   134
		{
drifter01620@184
   135
			twoByte = 1;
drifter01620@184
   136
			if (dest)
drifter01620@184
   137
				*dest++ = *func++;
drifter01620@184
   138
			else
drifter01620@184
   139
				func++;
drifter01620@184
   140
			bytecount++;
drifter01620@184
   141
		}
drifter01620@184
   142
drifter01620@184
   143
		// opcode byte
drifter01620@184
   144
		opcode = *func++;
drifter01620@184
   145
		if (dest) *dest++ = opcode;
drifter01620@184
   146
		bytecount++;
drifter01620@184
   147
drifter01620@184
   148
		// mod R/M byte
drifter01620@184
   149
		modRM = 0xFF;
drifter01620@184
   150
		if(FPU)
drifter01620@184
   151
		{
drifter01620@184
   152
			if((opcode & 0xC0) != 0xC0)
drifter01620@184
   153
			{
drifter01620@184
   154
				modRM = opcode;
drifter01620@184
   155
			}
drifter01620@184
   156
		}
drifter01620@184
   157
		else if(!twoByte)
drifter01620@184
   158
		{
drifter01620@184
   159
			if((opcode & 0xC4) == 0x00 ||
drifter01620@184
   160
			   ((opcode & 0xF4) == 0x60 && ((opcode & 0x0A) == 0x02 || (opcode & 0x09) == 0x09)) ||
drifter01620@184
   161
			   (opcode & 0xF0) == 0x80 ||
drifter01620@184
   162
			   ((opcode & 0xF8) == 0xC0 && (opcode & 0x0E) != 0x02) ||
drifter01620@184
   163
			   (opcode & 0xFC) == 0xD0 ||
drifter01620@184
   164
			   (opcode & 0xF6) == 0xF6)
drifter01620@184
   165
			{
drifter01620@184
   166
				modRM = *func++;
drifter01620@184
   167
				if (dest) *dest++ = modRM;
drifter01620@184
   168
				bytecount++;
drifter01620@184
   169
			}
drifter01620@184
   170
		}
drifter01620@184
   171
		else
drifter01620@184
   172
		{
drifter01620@184
   173
			if(((opcode & 0xF0) == 0x00 && (opcode & 0x0F) >= 0x04 && (opcode & 0x0D) != 0x0D) ||
drifter01620@184
   174
			   (opcode & 0xF0) == 0x30 ||
drifter01620@184
   175
			   opcode == 0x77 ||
drifter01620@184
   176
			   (opcode & 0xF0) == 0x80 ||
drifter01620@184
   177
			   ((opcode & 0xF0) == 0xA0 && (opcode & 0x07) <= 0x02) ||
drifter01620@184
   178
			   (opcode & 0xF8) == 0xC8)
drifter01620@184
   179
			{
drifter01620@184
   180
				// No mod R/M byte
drifter01620@184
   181
			}
drifter01620@184
   182
			else
drifter01620@184
   183
			{
drifter01620@184
   184
				modRM = *func++;
drifter01620@184
   185
				if (dest) *dest++ = modRM;
drifter01620@184
   186
				bytecount++;
drifter01620@184
   187
			}
drifter01620@184
   188
		}
drifter01620@184
   189
drifter01620@184
   190
		// SIB
drifter01620@184
   191
		if((modRM & 0x07) == 0x04 &&
drifter01620@184
   192
		   (modRM & 0xC0) != 0xC0)
drifter01620@184
   193
		{
drifter01620@184
   194
			if (dest)
drifter01620@184
   195
				*dest++ = *func++;   //SIB
drifter01620@184
   196
			else
drifter01620@184
   197
				func++;
drifter01620@184
   198
			bytecount++;
drifter01620@184
   199
		}
drifter01620@184
   200
drifter01620@184
   201
		// mod R/M displacement
drifter01620@184
   202
drifter01620@184
   203
		// Dword displacement, no base
drifter01620@184
   204
	if((modRM & 0xC5) == 0x05) {
drifter01620@184
   205
		if (dest) {
drifter01620@184
   206
			*(unsigned int*)dest = *(unsigned int*)func;
drifter01620@184
   207
			dest += 4;
drifter01620@184
   208
		}
drifter01620@184
   209
		func += 4;
drifter01620@184
   210
		bytecount += 4;
drifter01620@184
   211
	}
drifter01620@184
   212
drifter01620@184
   213
		// Byte displacement
drifter01620@184
   214
	if((modRM & 0xC0) == 0x40) {
drifter01620@184
   215
		if (dest)
drifter01620@184
   216
			*dest++ = *func++;
drifter01620@184
   217
		else
drifter01620@184
   218
			func++;
drifter01620@184
   219
		bytecount++;
drifter01620@184
   220
	}
drifter01620@184
   221
drifter01620@184
   222
		// Dword displacement
drifter01620@184
   223
	if((modRM & 0xC0) == 0x80) {
drifter01620@184
   224
		if (dest) {
drifter01620@184
   225
			*(unsigned int*)dest = *(unsigned int*)func;
drifter01620@184
   226
			dest += 4;
drifter01620@184
   227
		}
drifter01620@184
   228
		func += 4;
drifter01620@184
   229
		bytecount += 4;
drifter01620@184
   230
	}
drifter01620@184
   231
drifter01620@184
   232
		// immediate
drifter01620@184
   233
		if(FPU)
drifter01620@184
   234
		{
drifter01620@184
   235
			// Can't have immediate operand
drifter01620@184
   236
		}
drifter01620@184
   237
		else if(!twoByte)
drifter01620@184
   238
		{
drifter01620@184
   239
			if((opcode & 0xC7) == 0x04 ||
drifter01620@184
   240
			   (opcode & 0xFE) == 0x6A ||   // PUSH/POP/IMUL
drifter01620@184
   241
			   (opcode & 0xF0) == 0x70 ||   // Jcc
drifter01620@184
   242
			   opcode == 0x80 ||
drifter01620@184
   243
			   opcode == 0x83 ||
drifter01620@184
   244
			   (opcode & 0xFD) == 0xA0 ||   // MOV
drifter01620@184
   245
			   opcode == 0xA8 ||			// TEST
drifter01620@184
   246
			   (opcode & 0xF8) == 0xB0 ||   // MOV
drifter01620@184
   247
			   (opcode & 0xFE) == 0xC0 ||   // RCL
drifter01620@184
   248
			   opcode == 0xC6 ||			// MOV
drifter01620@184
   249
			   opcode == 0xCD ||			// INT
drifter01620@184
   250
			   (opcode & 0xFE) == 0xD4 ||   // AAD/AAM
drifter01620@184
   251
			   (opcode & 0xF8) == 0xE0 ||   // LOOP/JCXZ
drifter01620@184
   252
			   opcode == 0xEB ||
drifter01620@184
   253
			   (opcode == 0xF6 && (modRM & 0x30) == 0x00))   // TEST
drifter01620@184
   254
			{
drifter01620@184
   255
				if (dest)
drifter01620@184
   256
					*dest++ = *func++;
drifter01620@184
   257
				else
drifter01620@184
   258
					func++;
drifter01620@184
   259
				bytecount++;
drifter01620@184
   260
			}
drifter01620@184
   261
		else if((opcode & 0xF7) == 0xC2) // RET
drifter01620@184
   262
			{
drifter01620@184
   263
				if (dest) {
drifter01620@184
   264
					*(unsigned short*)dest = *(unsigned short*)func;
drifter01620@184
   265
					dest += 2;
drifter01620@184
   266
				}
drifter01620@184
   267
				func += 2;
drifter01620@184
   268
				bytecount += 2;
drifter01620@184
   269
			}
drifter01620@184
   270
			else if((opcode & 0xFC) == 0x80 ||
drifter01620@184
   271
					(opcode & 0xC7) == 0x05 ||
drifter01620@184
   272
					(opcode & 0xF8) == 0xB8 ||
drifter01620@184
   273
					(opcode & 0xFE) == 0xE8 ||	  // CALL/Jcc
drifter01620@184
   274
					(opcode & 0xFE) == 0x68 ||
drifter01620@184
   275
					(opcode & 0xFC) == 0xA0 ||
drifter01620@184
   276
					(opcode & 0xEE) == 0xA8 ||
drifter01620@184
   277
					opcode == 0xC7 ||
drifter01620@184
   278
					(opcode == 0xF7 && (modRM & 0x30) == 0x00))
drifter01620@184
   279
			{
drifter01620@184
   280
				if (dest) {
drifter01620@184
   281
					//Fix CALL/JMP offset
drifter01620@184
   282
					if ((opcode & 0xFE) == 0xE8) {
drifter01620@184
   283
						if (operandSize == 4)
drifter01620@184
   284
						{
drifter01620@184
   285
							*(long*)dest = ((func + *(long*)func) - dest);
drifter01620@184
   286
drifter01620@184
   287
							//pRED* edit. func is the current address of the call address, +4 is the next instruction, so the value of $pc
drifter01620@184
   288
							check_thunks(dest+4, func+4);
drifter01620@184
   289
						}
drifter01620@184
   290
						else
drifter01620@184
   291
							*(short*)dest = ((func + *(short*)func) - dest);
drifter01620@184
   292
drifter01620@184
   293
					} else {
drifter01620@184
   294
						if (operandSize == 4)
drifter01620@184
   295
							*(unsigned long*)dest = *(unsigned long*)func;
drifter01620@184
   296
						else
drifter01620@184
   297
							*(unsigned short*)dest = *(unsigned short*)func;
drifter01620@184
   298
					}
drifter01620@184
   299
					dest += operandSize;
drifter01620@184
   300
				}
drifter01620@184
   301
				func += operandSize;
drifter01620@184
   302
				bytecount += operandSize;
drifter01620@184
   303
drifter01620@184
   304
			}
drifter01620@184
   305
		}
drifter01620@184
   306
		else
drifter01620@184
   307
		{
drifter01620@184
   308
			if(opcode == 0xBA ||			// BT
drifter01620@184
   309
			   opcode == 0x0F ||			// 3DNow!
drifter01620@184
   310
			   (opcode & 0xFC) == 0x70 ||   // PSLLW
drifter01620@184
   311
			   (opcode & 0xF7) == 0xA4 ||   // SHLD
drifter01620@184
   312
			   opcode == 0xC2 ||
drifter01620@184
   313
			   opcode == 0xC4 ||
drifter01620@184
   314
			   opcode == 0xC5 ||
drifter01620@184
   315
			   opcode == 0xC6)
drifter01620@184
   316
			{
drifter01620@184
   317
				if (dest)
drifter01620@184
   318
					*dest++ = *func++;
drifter01620@184
   319
				else
drifter01620@184
   320
					func++;
drifter01620@184
   321
			}
drifter01620@184
   322
			else if((opcode & 0xF0) == 0x80) // Jcc -i
drifter01620@184
   323
			{
drifter01620@184
   324
				if (dest) {
drifter01620@184
   325
					if (operandSize == 4)
drifter01620@184
   326
						*(unsigned long*)dest = *(unsigned long*)func;
drifter01620@184
   327
					else
drifter01620@184
   328
						*(unsigned short*)dest = *(unsigned short*)func;
drifter01620@184
   329
drifter01620@184
   330
					dest += operandSize;
drifter01620@184
   331
				}
drifter01620@184
   332
				func += operandSize;
drifter01620@184
   333
				bytecount += operandSize;
drifter01620@184
   334
			}
drifter01620@184
   335
		}
drifter01620@184
   336
	}
drifter01620@184
   337
drifter01620@184
   338
	return bytecount;
drifter01620@184
   339
}
drifter01620@184
   340
drifter01620@184
   341
//insert a specific JMP instruction at the given location
drifter01620@184
   342
void inject_jmp(void* src, void* dest) {
drifter01620@184
   343
	*(unsigned char*)src = OP_JMP;
drifter01620@184
   344
	*(long*)((unsigned char*)src+1) = (long)((unsigned char*)dest - ((unsigned char*)src + OP_JMP_SIZE));
drifter01620@184
   345
}
drifter01620@184
   346
drifter01620@184
   347
//fill a given block with NOPs
drifter01620@184
   348
void fill_nop(void* src, unsigned int len) {
drifter01620@184
   349
	unsigned char* src2 = (unsigned char*)src;
drifter01620@184
   350
	while (len) {
drifter01620@184
   351
		*src2++ = OP_NOP;
drifter01620@184
   352
		--len;
drifter01620@184
   353
	}
drifter01620@184
   354
}
drifter01620@184
   355
drifter01620@184
   356
void* eval_jump(void* src) {
drifter01620@184
   357
	unsigned char* addr = (unsigned char*)src;
drifter01620@184
   358
drifter01620@184
   359
	if (!addr) return 0;
drifter01620@184
   360
drifter01620@184
   361
	//import table jump
drifter01620@184
   362
	if (addr[0] == OP_PREFIX && addr[1] == OP_JMP_SEG) {
drifter01620@184
   363
		addr += 2;
drifter01620@184
   364
		addr = *(unsigned char**)addr;
drifter01620@184
   365
		//TODO: if addr points into the IAT
drifter01620@184
   366
		return *(void**)addr;
drifter01620@184
   367
	}
drifter01620@184
   368
drifter01620@184
   369
	//8bit offset
drifter01620@184
   370
	else if (addr[0] == OP_JMP_BYTE) {
drifter01620@184
   371
		addr = &addr[OP_JMP_BYTE_SIZE] + *(char*)&addr[1];
drifter01620@184
   372
		//mangled 32bit jump?
drifter01620@184
   373
		if (addr[0] == OP_JMP) {
drifter01620@184
   374
			addr = addr + *(int*)&addr[1];
drifter01620@184
   375
		}
drifter01620@184
   376
		return addr;
drifter01620@184
   377
	}
drifter01620@184
   378
	/*
drifter01620@184
   379
	//32bit offset
drifter01620@184
   380
	else if (addr[0] == OP_JMP) {
drifter01620@184
   381
		addr = &addr[OP_JMP_SIZE] + *(int*)&addr[1];
drifter01620@184
   382
	}
drifter01620@184
   383
	*/
drifter01620@184
   384
drifter01620@184
   385
	return addr;
drifter01620@184
   386
}
drifter01620@184
   387
/*
drifter01620@184
   388
from ms detours package
drifter01620@184
   389
static bool detour_is_imported(PBYTE pbCode, PBYTE pbAddress)
drifter01620@184
   390
{
drifter01620@184
   391
	MEMORY_BASIC_INFORMATION mbi;
drifter01620@184
   392
	VirtualQuery((PVOID)pbCode, &mbi, sizeof(mbi));
drifter01620@184
   393
	__try {
drifter01620@184
   394
		PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)mbi.AllocationBase;
drifter01620@184
   395
		if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) {
drifter01620@184
   396
			return false;
drifter01620@184
   397
		}
drifter01620@184
   398
drifter01620@184
   399
		PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((PBYTE)pDosHeader +
drifter01620@184
   400
														  pDosHeader->e_lfanew);
drifter01620@184
   401
		if (pNtHeader->Signature != IMAGE_NT_SIGNATURE) {
drifter01620@184
   402
			return false;
drifter01620@184
   403
		}
drifter01620@184
   404
drifter01620@184
   405
		if (pbAddress >= ((PBYTE)pDosHeader +
drifter01620@184
   406
						  pNtHeader->OptionalHeader
drifter01620@184
   407
						  .DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress) &&
drifter01620@184
   408
			pbAddress < ((PBYTE)pDosHeader +
drifter01620@184
   409
						 pNtHeader->OptionalHeader
drifter01620@184
   410
						 .DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress +
drifter01620@184
   411
						 pNtHeader->OptionalHeader
drifter01620@184
   412
						 .DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size)) {
drifter01620@184
   413
			return true;
drifter01620@184
   414
		}
drifter01620@184
   415
		return false;
drifter01620@184
   416
	}
drifter01620@184
   417
	__except(EXCEPTION_EXECUTE_HANDLER) {
drifter01620@184
   418
		return false;
drifter01620@184
   419
	}
drifter01620@184
   420
}
drifter01620@184
   421
*/