ade_asm.c

usb透明加密驱动程序源代码

/* 8F */ C_DATA66+C_REL,
/* 90 */ C_MODRM,
/* 91 */ C_MODRM,
/* 92 */ C_MODRM,
/* 93 */ C_MODRM,
/* 94 */ C_MODRM,
/* 95 */ C_MODRM,
/* 96 */ C_MODRM,
/* 97 */ C_MODRM,
/* 98 */ C_MODRM,
/* 99 */ C_MODRM,
/* 9A */ C_MODRM,
/* 9B */ C_MODRM,
/* 9C */ C_MODRM,
/* 9D */ C_MODRM,
/* 9E */ C_MODRM,
/* 9F */ C_MODRM,
/* A0 */ 0,
/* A1 */ 0,
/* A2 */ 0,
/* A3 */ C_MODRM,
/* A4 */ C_MODRM+C_DATA1,
/* A5 */ C_MODRM,
/* A6 */ C_ERROR,
/* A7 */ C_ERROR,
/* A8 */ 0,
/* A9 */ 0,
/* AA */ 0,
/* AB */ C_MODRM,
/* AC */ C_MODRM+C_DATA1,
/* AD */ C_MODRM,
/* AE */ C_ERROR,
/* AF */ C_MODRM,
/* B0 */ C_MODRM,
/* B1 */ C_MODRM,
/* B2 */ C_MODRM,
/* B3 */ C_MODRM,
/* B4 */ C_MODRM,
/* B5 */ C_MODRM,
/* B6 */ C_MODRM,
/* B7 */ C_MODRM,
/* B8 */ C_ERROR,
/* B9 */ C_ERROR,
/* BA */ C_MODRM+C_DATA1,
/* BB */ C_MODRM,
/* BC */ C_MODRM,
/* BD */ C_MODRM,
/* BE */ C_MODRM,
/* BF */ C_MODRM,
/* C0 */ C_MODRM,
/* C1 */ C_MODRM,
/* C2 */ C_ERROR,
/* C3 */ C_ERROR,
/* C4 */ C_ERROR,
/* C5 */ C_ERROR,
/* C6 */ C_ERROR,
/* C7 */ C_ERROR,
/* C8 */ 0,
/* C9 */ 0,
/* CA */ 0,
/* CB */ 0,
/* CC */ 0,
/* CD */ C_DATA1,
/* CE */ 0,
/* CF */ 0,
/* D0 */ C_ERROR,
/* D1 */ C_ERROR,
/* D2 */ C_ERROR,
/* D3 */ C_ERROR,
/* D4 */ C_ERROR,
/* D5 */ C_ERROR,
/* D6 */ C_ERROR,
/* D7 */ C_ERROR,
/* D8 */ C_ERROR,
/* D9 */ C_ERROR,
/* DA */ C_ERROR,
/* DB */ C_ERROR,
/* DC */ C_ERROR,
/* DD */ C_ERROR,
/* DE */ C_ERROR,
/* DF */ C_ERROR,
/* E0 */ C_ERROR,
/* E1 */ C_ERROR,
/* E2 */ C_ERROR,
/* E3 */ C_ERROR,
/* E4 */ C_ERROR,
/* E5 */ C_ERROR,
/* E6 */ C_ERROR,
/* E7 */ C_ERROR,
/* E8 */ C_ERROR,
/* E9 */ C_ERROR,
/* EA */ C_ERROR,
/* EB */ C_ERROR,
/* EC */ C_ERROR,
/* ED */ C_ERROR,
/* EE */ C_ERROR,
/* EF */ C_ERROR,
/* F0 */ C_ERROR,
/* F1 */ C_ERROR,
/* F2 */ C_ERROR,
/* F3 */ C_ERROR,
/* F4 */ C_ERROR,
/* F5 */ C_ERROR,
/* F6 */ C_ERROR,
/* F7 */ C_ERROR,
/* F8 */ C_ERROR,
/* F9 */ C_ERROR,
/* FA */ C_ERROR,
/* FB */ C_ERROR,
/* FC */ C_ERROR,
/* FD */ C_ERROR,
/* FE */ C_ERROR,
/* FF */ C_ERROR
}; // ade32_table[]

int ade32_disasm(IN BYTE* opcode0, IN OUT disasm_struct* diza)
{
  BYTE* opcode = opcode0;
  DWORD flag = 0, t, a, d, i;
  BYTE c, mod, rm;
  disasm_struct temp_diza; // comment if NULL is never passed

  if (diza == NULL) diza = &temp_diza; //


  memset(diza, 0x00, sizeof(disasm_struct)); // comment these lines,

  diza->disasm_defdata = 4; // and fill structure before call

  diza->disasm_defaddr = 4; // -- to 允许 16/32-bit disasm


  if (*(WORD*)opcode == 0x0000) return 0;
  if (*(WORD*)opcode == 0xFFFF) return 0;
  
repeat_prefix:
  //按字节取出操作码

  c = *opcode++;
  //查表,取出特征码

  t = ade32_table[ c ];
  //是否是已知前缀

  if (t & C_ANYPREFIX)
  {
    //是否为两次相同前缀

    if (flag & t) return 0; // twice LOCK,SEG,REP,66,67

    //标志

    flag |= t;
    //如果含有C_67，需要16位地址

    if (t & C_67)
    { 
      //???

      diza->disasm_defaddr ^= 2^4;
    }
    //如果含有C_66，使用16位操作数

    else
    if (t & C_66)
    {
      //???

      diza->disasm_defdata ^= 2^4;
    }
    else
    //含有段标志

    if (t & C_SEG)
    {
      //保存段前缀

      diza->disasm_seg = c;
    }
    else
    if (t & C_REP)
    {
      //原理同上

      diza->disasm_rep = c;
    }
    // LOCK


    goto repeat_prefix;

  } // C_ANYPREFIX

  //保存标志

  flag |= t;
  //保存操作码

  diza->disasm_opcode = c;
  //操作码是否含有第二个字节

  if (c == 0x0F)
  {
    c = *opcode++;
    //取出第二个字节

    diza->disasm_opcode2 = c;
    //根据第二字节取得指令特征

    flag |= ade32_table[ 256 + c ]; // 2nd flagtable half


    if (flag == C_ERROR) return 0;
  }
  //操作码大概为F7xx

  else
  if (c == 0xF7)
  {
    //opcode已经自加1

    if (((*opcode) & 0x38)==0)
      //xx为数据（立即数？？)

      flag |= C_DATA66;
  }
  //不详，同上

  else
  if (c == 0xF6)
  {
    if (((*opcode) & 0x38)==0)
      flag |= C_DATA1;
  }
  //如果设置C_MODRM标志

  if (flag & C_MODRM)
  {
    c = *opcode++;
    //保存值

    diza->disasm_modrm = c;
    //在MorR/M右边含有一个SIB字节

    if ((c & 0x38) == 0x20)
        if (diza->disasm_opcode == 0xFF)
              flag |= C_STOP;
    //MorR/M的高2位

    mod = c & 0xC0;
    //MorR/M的低3位

    rm = c & 0x07;
    //如果高2位不为11

    if (mod != 0xC0)
    {
      if (diza->disasm_defaddr == 4)
      {
        //寄存器参与地址计算

        if (rm == 4)
        {
          ////在MorR/M右边含有一个SIB字节

          flag |= C_SIB;
          //取出SIB

          c = *opcode++;
          //保存

          diza->disasm_sib = c;
          //取出SIB的低3位，为base寄存器

          rm = c & 0x07;
        }
        //操作数为内存地址+字节偏移量，且地址在寄存器中

        if (mod == 0x40)
        {
          flag |= C_ADDR1;
        }
        //操作数为内存地址+双字偏移量，同上

        else
        if (mod == 0x80)
        {
          flag |= C_ADDR4;
        }
        //mod高2位为00

        else
        {
          //且mod低3位为101，则不使用寄存器计算地址

          if (rm == 5)
            flag |= C_ADDR4;
        }
      }
      else // MODRM 16-bit

      {

        if (mod == 0x40)
        {
          flag |= C_ADDR1;
        }
        else
        if (mod == 0x80)
        {
          flag |= C_ADDR2;
        }
        else
        {
          if (rm == 6)
            flag |= C_ADDR2;
        }
      }
    }
  } // C_MODRM

   //保存标志

  diza->disasm_flag = flag;
  //取出标志

  a = flag & (C_ADDR1 | C_ADDR2 | C_ADDR4);
  //#define C_DATA1 0x00000100 

  //#define C_DATA2 0x00000200

  //#define C_DATA4 0x00000400

  //移动到低四位

  d = (flag & (C_DATA1 | C_DATA2 | C_DATA4)) >> 8;
  //全部地址长度

  if (flag & C_ADDR67) a += diza->disasm_defaddr;
  //全都立即数长度

  if (flag & C_DATA66) d += diza->disasm_defdata;
  //???

  diza->disasm_addrsize = a;
  diza->disasm_datasize = d;
  //取出偏移量

  i;
  for(i=0; i<a; i++)
    diza->disasm_addr_b[i] = *opcode++;
  //取出立即数

  for(i=0; i<d; i++)
    diza->disasm_data_b[i] = *opcode++;
  //长度

  diza->disasm_len = opcode - opcode0;
  
  return diza->disasm_len;

} // ade32_disasm()


// ade32_asm() -- returns assembled opcode length


int ade32_asm(OUT BYTE* opcode, IN OUT disasm_struct* s)
{
  BYTE* opcode0 = opcode;
  DWORD i;
  
  if (s->disasm_flag & C_SEG) *opcode++ = s->disasm_seg;
  if (s->disasm_flag & C_LOCK) *opcode++ = 0xF0;
  if (s->disasm_flag & C_REP) *opcode++ = s->disasm_rep;
  if (s->disasm_flag & C_67) *opcode++ = 0x67;
  if (s->disasm_flag & C_66) *opcode++ = 0x66;
  *opcode++ = s->disasm_opcode;
  if (s->disasm_flag & C_OPCODE2) *opcode++ = s->disasm_opcode2;
  if (s->disasm_flag & C_MODRM) *opcode++ = s->disasm_modrm;
  if (s->disasm_flag & C_SIB) *opcode++ = s->disasm_sib;
  for (i=0; i<s->disasm_addrsize; i++)
    *opcode++ = s->disasm_addr_b[i];
  for (i=0; i<s->disasm_datasize; i++)
    *opcode++ = s->disasm_data_b[i];

  return opcode - opcode0;
}

DWORD 
DisassembleProlog(
	PBYTE      pbCode,
	DWORD      cbMinimumRequired
	)
{
	DWORD size = 0;
	while(size < cbMinimumRequired)
	{
		int op_size = ade32_disasm(pbCode + size, NULL);
		if (op_size <= 0)
			return 0;
		else
			size += op_size;
	}
	return size;
}