示例#1
0
/*!
 * Test the PIN_SafeCopy() function in the following scenarios:
 * A. Successful copy of an entire memory region
 * B. Partial copy of a memory region, whose tail is inaccessible
 * C. Failure to copy an inaccessible memory region
 */
VOID SafeCopyTest()
{
    size_t pageSize = GetPageSize();

    CHAR * src = (CHAR *)MemAlloc(2*pageSize);
    ASSERTX(src != 0);
    CHAR * srcBuf = src + 1; // +1 for testing unaligned access


    CHAR * dst = (CHAR *)MemAlloc(2*pageSize);
    ASSERTX(dst != 0);
    CHAR * dstBuf = dst + 1; // +1 for testing unaligned access

    size_t bufSize = 2*pageSize - 1;
    size_t halfBufSize = pageSize - 1;
    size_t copySize;

    //A.
    for (unsigned int i = 0; i < bufSize; ++i)
    {
        src[i] = i/256;
        dst[i] = 0;
    }
    copySize = PIN_SafeCopy(dstBuf, srcBuf, bufSize); 
    ASSERT(((copySize == bufSize) && (memcmp(dstBuf, srcBuf, bufSize) == 0)), "SafeCopy (A) failed.\n");
    out << "SafeCopy (A): Entire buffer has been copied successfully." << endl << flush;

    //B.
    for (unsigned int i = 0; i < pageSize; ++i)
    {
        dst[i] = 0;
    }
    MemProtect(src + pageSize, pageSize, FALSE); // second half of src is inaccessible
    copySize = PIN_SafeCopy(dstBuf, srcBuf, bufSize); 
    ASSERT(((copySize == halfBufSize) && (memcmp(dstBuf, srcBuf, halfBufSize) == 0)), "SafeCopy (B) failed.\n");

    // Check to see that all accessible bytes near the end of the first page are copied successfully
    for (unsigned int sz = 1; sz < 16; ++sz)
    {
        for (unsigned int i = 0; i < sz; ++i)
        {
            dstBuf[i] = 0;
        }
        copySize = PIN_SafeCopy(dstBuf, src + pageSize - sz, pageSize); 
        ASSERT(((copySize == sz) && (memcmp(dstBuf, src + pageSize - sz, sz) == 0)), "SafeCopy (B) failed.\n");
    }

    out << "SafeCopy (B): Accessible part of the buffer has been copied successfully."  << endl << flush;

    //C.
    MemProtect(dst, pageSize, FALSE); // dst is inaccessible
    copySize = PIN_SafeCopy(dstBuf, srcBuf, bufSize); 
    ASSERT((copySize == 0), "SafeCopy (C) failed.\n");
    out << "SafeCopy (C): Inaccessible buffer has not been copied."  << endl << flush;

    MemFree(src, 2*pageSize);
    MemFree(dst, 2*pageSize);
}
示例#2
0
//return the entropy value of the entire program
float ProcInfo::GetEntropy(){
	IMG binary_image = APP_ImgHead();
	// trick in order to convert a ln in log2
	const double d1log2 = 1.4426950408889634073599246810023;
	double Entropy = 0.0;
	unsigned long Entries[256];
	unsigned char* Buffer;
	//calculate the entropy only on the main module address space
	ADDRINT start_address = IMG_LowAddress(binary_image);
	ADDRINT end_address = IMG_HighAddress(binary_image);
	UINT32 size = end_address - start_address;
	// copy the main module in a buffer in order to analyze it
	Buffer = (unsigned char *)malloc(size);
	PIN_SafeCopy(Buffer , (void const *)start_address , size);
	// set to all zero the matrix of the bytes occurrence
	memset(Entries, 0, sizeof(unsigned long) * 256);
	// increment the counter of the current read byte (Buffer[i])in the occurence matrix (Entries)
	for (unsigned long i = 0; i < size; i++)
		Entries[Buffer[i]]++;
	// do the shannon formula on the occurence matrix ( H = sum(P(i)*log2(P(i)) )
	for (unsigned long i = 0; i < 256; i++)
	{
		double Temp = (double) Entries[i] / (double) size;
		if (Temp > 0)
			Entropy += - Temp*(log(Temp)*d1log2); 
	}
	return Entropy;
}
示例#3
0
//--------------------------------------------------------------------------
static VOID app_start_cb(VOID *v)
{
  IMG img = APP_ImgHead();
  for( SEC sec= IMG_SecHead(img); SEC_Valid(sec); sec = SEC_Next(sec) )
  {
    ADDRINT sec_ea = SEC_Address(sec);
    if ( sec_ea != 0 )
    {
      ADDRINT check;
      size_t bytes = PIN_SafeCopy(&check, (void*)sec_ea, sizeof(ADDRINT));
      if ( bytes == sizeof(ADDRINT) )
      {
        if ( min_ea > sec_ea || min_ea == 0 )
          min_ea = sec_ea;
        if ( max_ea < sec_ea || max_ea == (unsigned)-1 )
          max_ea = sec_ea;

        segdata_t seg;
        seg.size = SEC_Size(sec);
        seg.check = check;
        seg.written = false;
        seg_bytes[sec_ea] = seg;
        //cerr << "Monitoring segment " << SEC_Name(sec) << " " << hexstr(sec_ea)
        //     << ":" << hexstr(sec_ea+SEC_Size(sec)) << endl;
      }
    }
  }
}
示例#4
0
VOID EmitWrite(THREADID threadid, UINT32 size) {
	assert(size <= 100);
	char bytes[101];
	struct timeval tv;
	VOID *ea = WriteEa[threadid];
	if(MemregionTracker::address_mapped(ea)) {
		gettimeofday(&tv, NULL);
		PIN_SafeCopy(&bytes[0], static_cast<char *>(ea), size);
		bytes[size] = '\0';

		m_dump_bytes(bytes, size);
		if(mwrite_tracker[threadid].next_location == ea && 
			time_diff(tv, mwrite_tracker[threadid].last_time) < coalesce_microsecs) {
			mwrite_tracker[threadid].size += size;
		} else {
			flush_mwrite(threadid);
			PrintTime(&tv);
			output_stacktrace();
			if(print_chars) {
				char tmp[100];
				printable_string(bytes, tmp, 100);
				mprintf("mwrite(%p, \"%s\"..., ", ea, tmp);
			} else {
				mprintf("mwrite(%p, \"\"..., ", ea);
			}
			mwrite_tracker[threadid].size = size;
		}

		mwrite_tracker[threadid].next_location = (UINT8 *)ea + size;
		mwrite_tracker[threadid].last_time = tv;
	}
}
示例#5
0
static VOID SyscallEntry(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
{
    if (PIN_GetSyscallNumber(ctxt, std) != SYS_sysarch)
        return;

    ADDRINT pc = PIN_GetContextReg(ctxt, REG_INST_PTR);
    ADDRINT op = PIN_GetSyscallArgument(ctxt, std, 0);
    ADDRINT addr = PIN_GetSyscallArgument(ctxt, std, 1);
    ADDRINT value = 0;

    if (op == AMD64_SET_FSBASE || op == AMD64_SET_GSBASE)
    {
        if (PIN_SafeCopy(&value, Addrint2VoidStar(addr), sizeof(ADDRINT)) != sizeof(ADDRINT))
        {
            Out << Header(threadIndex, pc) << "Failed to read actual TLS pointer" << endl;
        }
    }
    else
    {
        // Remember the location where to write the segment register in REG_INST_G0
        PIN_SetContextReg(ctxt, REG_INST_G0, addr);
        value = addr;
    }

    Out << Header(threadIndex, pc) << "sysarch(" << SysArchFunc(op) << ", 0x" << std::hex << value << ")" << std::endl;
}
ADDRINT PIN_FAST_ANALYSIS_CALL memoryCallback(PIN_MEM_TRANS_INFO* memTransInfo, VOID *v) 
{
    icountMemCall++;

    lastIp = memTransInfo->ip;

    if (memTransInfo->memOpType == PIN_MEMOP_STORE )
    {
        lastWriteAddr = memTransInfo->addr;

        // Verify that we can call PIN API functions inside PIN
        PIN_SafeCopy((void*)memTransInfo->addr,
            (void*)memTransInfo->addr,
            memTransInfo->bytes);
    }
    else
        lastReadAddr = memTransInfo->addr;

    // Check void parameter
    if ((ADDRINT)v != 0xa5a5a5a5)
    {
        OutFile << "v incorrect inside callback: " << hex << v << endl;
        errors++;
    }

    //OutFile << "callback addresses: " << hex << (memTransInfo->addr)  << " " << (memTransInfo->addr & mask) << " " <<memTransInfo->ip  << endl;

    return (memTransInfo->addr & mask);
}
示例#7
0
// Move from memory to register
ADDRINT DoLoad(REG reg, ADDRINT * addr)
{
    *out << "Emulate loading from addr " << addr << " to " << REG_StringShort(reg) << endl;
    ADDRINT value;
    PIN_SafeCopy(&value, addr, sizeof(ADDRINT));
    return value;
}
示例#8
0
/******************************************************************
 Title:getMemAddress
 Function:Get the memory address
 Input:
 int value:Memory address
 Output:
******************************************************************/
VOID getMemAddress(ADDRINT addr)
{
	//memAddr = (int)addr;
	fprintf(log,"Address ins:0x%x\n",addr);
	PIN_SafeCopy(&memAddr, &addr, sizeof(ADDRINT));

}
示例#9
0
文件: rop_vec.cpp 项目: llubu/ROP
VOID LeaAdd(THREADID tid, ADDRINT sp, ADDRINT eip, ADDRINT bp ) 
{
    size_t sizeread1, sizeread2, sizeread3;
    ADDRINT value, bpval, bp18 = bp + 0x18, bp18val;

    PIN_LockClient();

    sizeread1 = PIN_SafeCopy(&value, (const VOID *)sp, sizeof(uint64_t));
    sizeread2 = PIN_SafeCopy(&bpval, (const VOID *)bp, sizeof(uint64_t));
    sizeread3 = PIN_SafeCopy(&bp18val, (const VOID *)bp18, sizeof(uint64_t));

    if ( sizeread1 != sizeof(uint64_t) || sizeread2 != sizeof(uint64_t) || sizeread3 != sizeof(uint64_t) )
	OutFile << "Incorrect Size read from stack for sp: " << hex << sp << " " << sizeread1 << " " << sizeread2 << endl;
    else 
	OutFile << tid << " Stack " << hex << sp << " Val " << value << " BP " << bp << " BPVAL " << bpval << 
	    " BP+18 " << bp18 <<" Valbp+18 " << bp18val << endl;

    PIN_UnlockClient();

    OutFile << dec << tid << " LEA " << hex << eip << " " << sp << " "<< bp << endl;
}
static VOID DoSafeCopy()
{
    // Before the bug was fixed in Pin, the first SafeCopy() would work, but would
    // reset the internal SEGV handler (because of SA_RESETHAND).  This caused the
    // second SafeCopy() to fail.  That's why we call SafeCopy() twice.
    //
    int word;
    size_t sz = PIN_SafeCopy(&word, 0, sizeof(word));
    if (sz != 0)
    {
        std::cerr << "SafeCopy should fail (1)\n";
        std::exit(1);
    }
    sz = PIN_SafeCopy(&word, 0, sizeof(word));
    if (sz != 0)
    {
        std::cerr << "SafeCopy should fail (2)\n";
        std::exit(1);
    }
    std::exit(0);
}
示例#11
0
  void handle_analyze (PIN_REGISTER * pGdx, PIN_REGISTER * pGax, ADDRINT pDivisor, unsigned int opSize, CONTEXT * ctxt, THREADID thr_id)
  {
    ADDRINT divisor = 0;
    PIN_SafeCopy (&divisor, (VOID *)pDivisor, opSize);
    Divide_Handler div_handler (thr_id, ctxt);

    UINT64 dividend = *((ADDRINT *)pGdx);
    dividend <<= 32;
    dividend += *((ADDRINT *)pGax);

    *((ADDRINT *)pGax) = static_cast <ADDRINT> (dividend / divisor);
    *((ADDRINT *)pGdx) = static_cast <ADDRINT> (dividend % divisor);
  }
示例#12
0
VOID EmulateMemDivide(ADDRINT * pGdx, ADDRINT * pGax, ADDRINT *pDivisor, unsigned int opSize, CONTEXT * ctxt, THREADID tid)
{
    ADDRINT divisor = 0;
    PIN_SafeCopy(&divisor, pDivisor, opSize);
    
    PIN_TryStart(tid, DivideHandler, ctxt);

    UINT64 dividend = *pGdx;
    dividend <<= 32;
    dividend += *pGax;
    *pGax = dividend / divisor;
    *pGdx = dividend % divisor;

    PIN_TryEnd(tid);
}
示例#13
0
文件: rop_vec.cpp 项目: llubu/ROP
VOID Branch( THREADID tid, ADDRINT sp, ADDRINT target, ADDRINT eip ) {

    if ( target >= (start+FFI_CALL_UNIX64) && (target <= start+FF64END) ) {
	OutFile << tid << " BRANCH" << hex <<" "<< eip << " " <<  target << " " << sp << endl;
	leaflag = true;

	size_t sizeread;
	ADDRINT value;

	PIN_LockClient();

	sizeread = PIN_SafeCopy(&value, (const VOID *)sp, sizeof(uint64_t));

	if ( sizeread != sizeof(uint64_t) )
	    OutFile << "Incorrect Size read from stack for sp: " << hex << sp << " " << sizeread << endl;
	else 
	    OutFile << tid << " Stack " << hex << sp << " Val " << value << endl;

	PIN_UnlockClient();

    }

    if ( target == (start+FF64PLT) ) 
	OutFile << tid << " J-PLT64 " << hex <<" "<< eip << " " <<  target << " " << sp << endl;

    if ( eip >= (start+FFI_CALL_UNIX64) && eip <= (start+FF64END) ) {
	OutFile << tid << " J-FF64 " << hex << eip << " " << target << " " << sp << endl;

    }




    // Reading value on threads stack



/*
   if ( eip >= (ANONST) && eip <= (ANONEND) ) {
	OutFile << tid << " BRANCH-I " << hex << eip << " " << target << " " << sp << endl;
   }
   if ( target >= (ANONST) && target <= (ANONEND) ) {
	OutFile << tid << " BRANCH-T " << hex << eip << " " << target << " " << sp << endl;
   }
*/
}
    static void copy_from_aligned_store_buffer(ADDRINT store_addr, 
                                               ADDRINT byte_len,
                                               ADDRINT ip,
                                               THREADID tid,
                                               sse_aligner_t* pthis)
    {
        thread_data_t* tdata = pthis->get_tls(tid);
        ADDRINT copied = PIN_SafeCopy(reinterpret_cast<uint8_t*>(store_addr), 
                                      tdata->write, 
                                      byte_len);

        if (copied != byte_len)
        {
            // The copy failed, this happens if the data is accessing an unmapped page.
            // To cause a similar fault we access the faulting data here...
            *(reinterpret_cast<uint8_t*>(store_addr) + copied) = tdata->write[copied];
        }
    }
示例#15
0
static VOID SyscallExit(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
{
    ADDRINT addr = PIN_GetContextReg(ctxt, REG_INST_G0);
    if (!addr)
        return;

    // Reset REG_INST_G0
    PIN_SetContextReg(ctxt, REG_INST_G0, 0);

    ADDRINT pc = PIN_GetContextReg(ctxt, REG_INST_PTR);
    ADDRINT ret = PIN_GetSyscallReturn(ctxt, std);
    ADDRINT value = 0;
    if (ret == (ADDRINT)-1 || PIN_SafeCopy(&value, Addrint2VoidStar(addr), sizeof(ADDRINT)) != sizeof(ADDRINT))
    {
        Out << Header(threadIndex, pc) << "Failed to read actual TLS pointer" << endl;
    }
    Out << Header(threadIndex, pc) << "sysarch returned: " << ", 0x" << std::hex << value << "" << std::endl;
}
示例#16
0
	//by default memory buffers have direct access
    Handle<Value> MemoryBuffer(const Arguments& args) {
	  HandleScope scope;

	  if (args.Length() < 2) {
		return ThrowException(
			String::New("MemoryBuffer constructor must have two parameters (address and size)."));
	  }

	  TryCatch try_catch;
	  uint32_t address = NumberToUint32(args[0], &try_catch);
	  uint32_t length = convertToUint(args[1], &try_catch);
	  uint8_t* data;
	  bool is_external = false;

	  if (try_catch.HasCaught()) return try_catch.Exception();

	  static const int32_t kMaxSize = 0x7fffffff;
	  // Make sure the total size fits into a (signed) int.
	  if (length < 0 || length > kMaxSize) {
		return ThrowException(String::New("ArrayBuffer exceeds maximum size (2G)"));
	  }

	  //check if we should snapshot the value
	  if (args.Length() > 2 && args[2]->IsTrue()) {
		  data = new uint8_t[length];
		  if (data == NULL) {
			return ThrowException(String::New("Memory allocation failed."));
		  }
		  V8::AdjustAmountOfExternalAllocatedMemory(length);

		  PIN_SafeCopy(data, reinterpret_cast<uint8_t *>(address), length);
	  } else {
		  data = reinterpret_cast<uint8_t *>(address);
		  is_external = true;
	  }

	  Handle<Value> buffer = CreateExternalArrayBuffer(length, data);
	  buffer->ToObject()->Set(String::New("snapshot"), (is_external ? False() : True()), ReadOnly);

	  if (is_external)
		buffer->ToObject()->Set(String::New("externalBuffer"), True(), ReadOnly);

	  return scope.Close(buffer);
    }
 static ADDRINT copy_to_aligned_load_buffer_and_return_pointer(ADDRINT load_addr, 
                                                               ADDRINT byte_len,
                                                               ADDRINT ip,
                                                               THREADID tid,
                                                               sse_aligner_t* pthis)
 {
     // return the address to use for the SSEx operation
     thread_data_t* tdata = pthis->get_tls(tid);
     ADDRINT copied = PIN_SafeCopy(tdata->read, 
                                   reinterpret_cast<uint8_t*>(load_addr), 
                                   byte_len);
     if (copied != byte_len)
     {
         // The copy failed, this happens if the data is accessing an unmapped page
         // to cause a similar fault we access the faulting data here...
         (void)*(reinterpret_cast<uint8_t*>(load_addr) + copied);
     }
     return reinterpret_cast<ADDRINT>(tdata->read);
 }
示例#18
0
void push_log( memorylog_entry* memlogs,
               UINT32* pLogcnt,
               ADDRINT addr,
               UINT32 size,
               bool storePrev )
{
    memlogs[*pLogcnt].addr = addr;

    if ( storePrev )
        assert( PIN_SafeCopy( &memlogs[*pLogcnt].val[0],
                              (const void*) addr,
                              size ) == size );
    else {}

    memlogs[*pLogcnt].size = (UINT16) size;

    *pLogcnt += 1;
    assert( *pLogcnt < MAX_ENTRY );
}
示例#19
0
/*!
 * Test SafeCopy in the trace instrumentation callback
 */
VOID Trace(TRACE trace, VOID *v)
{
    static BOOL first = TRUE;
    if (first)
    {
        first = FALSE;
        out << "Test SafeCopy in the trace instrumentation callback." << endl << flush;
        SafeCopyTest();
        TRACE_InsertCall(trace, IPOINT_BEFORE, (AFUNPTR)SafeCopyTestInTrace, IARG_END);
    }

    // Verify that pin-inserted probes are not visible through PIN_SafeCopy
    if (probeAddr != 0)
    {
        out << "Test SafeCopy in a region overwritten by probe." << endl << flush;
        CHAR buffer[8];
        size_t copySize = PIN_SafeCopy(buffer, probeAddr, sizeof(buffer)); 
        ASSERT((copySize == sizeof(buffer)), "SafeCopy failed in a region overwritten by probe.\n");
        ASSERT((memcmp(buffer, probeAddr, copySize) != 0), "Pin inserted probes are visible through SafeCopy.\n");
        probeAddr = 0;
    }
}
示例#20
0
//log the mem write value,addr and ip
static ADDRINT RecordMemWrite(VOID* addr)
{
	PIN_SafeCopy(&mem_value, MEMWR_addr, 8);
	//printf("%lu r\n",mem_value);
	
	//buf_ref->value=mem_value;
	//buf_ref=buf_ref+1;
	
	buffer[index].value=(UINT64)mem_value;
	printf("%lu\n",mem_value);
	
	//just for test
	if(index==MAX_SIZE-1)
	{
		StoreToFile(index);//buffer is full,store the content to file tem
		index=0;
	}
	else
		index=index+1;
    //fprintf(trace,"%lu \n", mem_value);
    	
    return 0;
}
float ProcInfo::GetEntropy(){

	IMG binary_image = APP_ImgHead();

	const double d1log2 = 1.4426950408889634073599246810023;
	double Entropy = 0.0;
	unsigned long Entries[256];
	unsigned char* Buffer;

	ADDRINT start_address = IMG_LowAddress(binary_image);
	ADDRINT end_address = IMG_HighAddress(binary_image);
	UINT32 size = end_address - start_address;

	Buffer = (unsigned char *)malloc(size);

	MYLOG("size to dump is %d" , size);
	MYLOG("Start address is %08x" , start_address);
	MYLOG("Start address is %08x" , end_address);
	MYLOG("IMAGE NAME IS %s" , IMG_Name(binary_image));

	PIN_SafeCopy(Buffer , (void const *)start_address , size);

	memset(Entries, 0, sizeof(unsigned long) * 256);

	for (unsigned long i = 0; i < size; i++)
		Entries[Buffer[i]]++;
	for (unsigned long i = 0; i < 256; i++)
	{
		double Temp = (double) Entries[i] / (double) size;
		if (Temp > 0)
			Entropy += - Temp*(log(Temp)*d1log2); 
	}

	MYLOG("ENTROPY IS %f" , Entropy);

	return Entropy;
}
示例#22
0
unsigned int PinExecutionContext::setMemory(char *addr, size_t size, char *buffer) {
	return (unsigned int) PIN_SafeCopy(addr, buffer, size);
}
示例#23
0
/*!
 * Touch (read) the specified memory address.
 */
VOID TouchMemory(CHAR * addr)
{
    CHAR value;
    PIN_SafeCopy(&value, addr, sizeof(CHAR));
}
instruction::instruction(const INS& ins)
{
  this->address     = INS_Address(ins);
  this->next_address = INS_NextAddress(ins);

//  this->opcode      = INS_Mnemonic(ins);
  this->opcode_size = static_cast<uint8_t>(INS_Size(ins));
  this->opcode_buffer = std::shared_ptr<uint8_t>(new uint8_t[this->opcode_size], std::default_delete<uint8_t[]>());
  PIN_SafeCopy(opcode_buffer.get(), reinterpret_cast<const VOID*>(this->address), this->opcode_size);

  this->disassemble = INS_Disassemble(ins);

  // including image, routine
  auto img                = IMG_FindByAddress(this->address);
  this->including_image   = IMG_Valid(img) ? IMG_Name(img) : "";
//  this->including_routine = RTN_FindNameByAddress(this->address);

  PIN_LockClient();
  auto routine = RTN_FindByAddress(this->address);
  PIN_UnlockClient();

  if (RTN_Valid(routine)) {
    auto routine_mangled_name = RTN_Name(routine);
    this->including_routine_name = PIN_UndecorateSymbolName(routine_mangled_name, UNDECORATION_NAME_ONLY);
  }
  else this->including_routine_name = "";

  // has fall through
  this->has_fall_through = INS_HasFallThrough(ins);

  // is call, ret or syscall
  this->is_call    = INS_IsCall(ins);
  this->is_branch  = INS_IsBranch(ins);
  this->is_ret     = INS_IsRet(ins);
  this->is_syscall = INS_IsSyscall(ins);

  this->category = static_cast<xed_category_enum_t>(INS_Category(ins));
  this->iclass = static_cast<xed_iclass_enum_t>(INS_Opcode(ins));

  // read registers
  auto read_reg_number = INS_MaxNumRRegs(ins);
  for (decltype(read_reg_number) reg_id = 0; reg_id < read_reg_number; ++reg_id) {
    this->src_registers.push_back(INS_RegR(ins, reg_id));
  }

  // written registers
  auto written_reg_number = INS_MaxNumWRegs(ins);
  for (decltype(written_reg_number) reg_id = 0; reg_id < written_reg_number; ++reg_id) {
    this->dst_registers.push_back(INS_RegW(ins, reg_id));
  }

  auto is_special_reg = [](const REG& reg) -> bool {
    return (reg >= REG_MM_BASE);
  };

  this->is_special =
      std::any_of(std::begin(this->src_registers), std::end(this->src_registers), is_special_reg) ||
      std::any_of(std::begin(this->dst_registers), std::end(this->dst_registers), is_special_reg) ||
      (this->category == XED_CATEGORY_X87_ALU) || (this->iclass == XED_ICLASS_XEND) || (this->category == XED_CATEGORY_LOGICAL_FP) ||
      (this->iclass == XED_ICLASS_PUSHA) || (this->iclass == XED_ICLASS_PUSHAD) || (this->iclass == XED_ICLASS_PUSHF) ||
      (this->iclass == XED_ICLASS_PUSHFD) || (this->iclass == XED_ICLASS_PUSHFQ);


  // is memory read, write
  this->is_memory_read  = INS_IsMemoryRead(ins);
  this->is_memory_write = INS_IsMemoryWrite(ins);
  this->is_memory_read2 = INS_HasMemoryRead2(ins);
}
示例#25
0
// Move from memory to register
ADDRINT MovRM(ADDRINT op0, ADDRINT * op1)
{ 
    ADDRINT value;
    PIN_SafeCopy(&value, op1, sizeof(ADDRINT));
    return value;
}
示例#26
0
// Move a register or literal to memory
VOID MovMV(ADDRINT * op0, ADDRINT op1)
{
    PIN_SafeCopy(op0, &op1, sizeof(ADDRINT));
}
示例#27
0
unsigned int PinExecutionContext::getMemory(const char *addr, size_t size, char *buffer) const {
	return (unsigned int) PIN_SafeCopy(buffer, addr, size);
}
示例#28
0
VOID Test(ADDRINT * sp)
{
    ADDRINT value;
    PIN_SafeCopy(&value, sp, sizeof(ADDRINT));
    TraceFile << value << endl;
}