获得一条指令(opcode and opdata)长度的函数(转)

最新推荐文章于 2022-06-25 13:18:32 发布
最新推荐文章于 2022-06-25 13:18:32 发布
阅读量888 收藏
点赞数
分类专栏： 技术文档 文章标签： c byte hook 汇编 x86
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jarodlau/article/details/337873
版权
eyas在 xhook中提到了在hook的时候，能获取指令长度是一件很有意义的事。

下面是wjl@smth写的一个获取指令长度的函数：

/*
  使用下面的函数可以“反汇编”一条指令，
  可以得到opcode 和 opdata， 以及完整指令的长度
  函数返回1后，disasm_len就是指令的长度
*/
#define C_66           0x00000001       // 66-prefix
#define C_67           0x00000002       // 67-prefix
#define C_LOCK         0x00000004       // lock
#define C_REP          0x00000008       // repz/repnz
#define C_SEG          0x00000010       // seg-prefix
#define C_OPCODE2      0x00000020       // 2nd opcode present (1st==0F)
#define C_MODRM        0x00000040       // modrm present
#define C_SIB          0x00000080       // sib present
#define C_ANYPREFIX    (C_66|C_67|C_LOCK|C_REP|C_SEG)

DWORD disasm_len;                       // 0 if error
DWORD disasm_flag;                      // C_xxx
DWORD disasm_memsize;                   // value = disasm_mem
DWORD disasm_datasize;                  // value = disasm_data
DWORD disasm_defdata;                   // == C_66 ? 2 : 4
DWORD disasm_defmem;                    // == C_67 ? 2 : 4
BYTE  disasm_seg;                       // CS DS ES SS FS GS
BYTE  disasm_rep;                       // REPZ/REPNZ
BYTE  disasm_opcode;                    // opcode
BYTE  disasm_opcode2;                   // used when opcode==0F
BYTE  disasm_modrm;                     // modxxxrm
BYTE  disasm_sib;                       // scale-index-base
BYTE  disasm_mem[8];                    // mem addr value
BYTE  disasm_data[8];                   // data value

int len_disasm(BYTE* opcode0)
{
  BYTE* opcode = opcode0;

  disasm_len = 0;
  disasm_flag = 0;
  disasm_datasize = 0;
  disasm_memsize = 0;
  disasm_defdata = 4;
  disasm_defmem = 4;

retry:
  disasm_opcode = *opcode++;

  switch (disasm_opcode)
  {
    case 0x00: case 0x01: case 0x02: case 0x03:
    case 0x08: case 0x09: case 0x0A: case 0x0B:
    case 0x10: case 0x11: case 0x12: case 0x13:
    case 0x18: case 0x19: case 0x1A: case 0x1B:
    case 0x20: case 0x21: case 0x22: case 0x23:
    case 0x28: case 0x29: case 0x2A: case 0x2B:
    case 0x30: case 0x31: case 0x32: case 0x33:
    case 0x38: case 0x39: case 0x3A: case 0x3B:
    case 0x62: case 0x63:
    case 0x84: case 0x85: case 0x86: case 0x87:
    case 0x88: case 0x89: case 0x8A: case 0x8B:
    case 0x8C: case 0x8D: case 0x8E: case 0x8F:
    case 0xC4: case 0xC5:
    case 0xD0: case 0xD1: case 0xD2: case 0xD3:
    case 0xD8: case 0xD9: case 0xDA: case 0xDB:
    case 0xDC: case 0xDD: case 0xDE: case 0xDF:
    case 0xFE: case 0xFF:
               disasm_flag |= C_MODRM;
               break;
    case 0xCD: disasm_datasize += *opcode==0x20 ? 1+4 : 1;
               break;
    case 0xF6:
    case 0xF7: disasm_flag |= C_MODRM;
               if (*opcode & 0x38) break;
               // continue if <test ..., xx>
    case 0x04: case 0x05: case 0x0C: case 0x0D:
    case 0x14: case 0x15: case 0x1C: case 0x1D:
    case 0x24: case 0x25: case 0x2C: case 0x2D:
    case 0x34: case 0x35: case 0x3C: case 0x3D:
               if (disasm_opcode & 1)
                 disasm_datasize += disasm_defdata;
               else
                 disasm_datasize++;
               break;
    case 0x6A:
    case 0xA8:
    case 0xB0: case 0xB1: case 0xB2: case 0xB3:
    case 0xB4: case 0xB5: case 0xB6: case 0xB7:
    case 0xD4: case 0xD5:
    case 0xE4: case 0xE5: case 0xE6: case 0xE7:
    case 0x70: case 0x71: case 0x72: case 0x73:
    case 0x74: case 0x75: case 0x76: case 0x77:
    case 0x78: case 0x79: case 0x7A: case 0x7B:
    case 0x7C: case 0x7D: case 0x7E: case 0x7F:
    case 0xEB:
    case 0xE0: case 0xE1: case 0xE2: case 0xE3:
               disasm_datasize++;
               break;
    case 0x26: case 0x2E: case 0x36: case 0x3E:
    case 0x64: case 0x65:
               if (disasm_flag & C_SEG) return 0;
               disasm_flag |= C_SEG;
               disasm_seg = disasm_opcode;
               goto retry;
    case 0xF0:
               if (disasm_flag & C_LOCK) return 0;
               disasm_flag |= C_LOCK;
               goto retry;
    case 0xF2: case 0xF3:
               if (disasm_flag & C_REP) return 0;
               disasm_flag |= C_REP;
               disasm_rep = disasm_opcode;
               goto retry;
    case 0x66:
               if (disasm_flag & C_66) return 0;
               disasm_flag |= C_66;
               disasm_defdata = 2;
               goto retry;
    case 0x67:
               if (disasm_flag & C_67) return 0;
               disasm_flag |= C_67;
               disasm_defmem = 2;
               goto retry;
    case 0x6B:
    case 0x80:
    case 0x82:
    case 0x83:
    case 0xC0:
    case 0xC1:
    case 0xC6: disasm_datasize++;
               disasm_flag |= C_MODRM;

               break;
    case 0x69:
    case 0x81:
    case 0xC7:
               disasm_datasize += disasm_defdata;
               disasm_flag |= C_MODRM;
               break;
    case 0x9A:
    case 0xEA: disasm_datasize += 2 + disasm_defdata;

               break;
    case 0xA0:
    case 0xA1:
    case 0xA2:
    case 0xA3: disasm_memsize += disasm_defmem;
               break;
    case 0x68:
    case 0xA9:
    case 0xB8: case 0xB9: case 0xBA: case 0xBB:
    case 0xBC: case 0xBD: case 0xBE: case 0xBF:
    case 0xE8:
    case 0xE9:
               disasm_datasize += disasm_defdata;
               break;
    case 0xC2:
    case 0xCA: disasm_datasize += 2;
               break;
    case 0xC8:
               disasm_datasize += 3;
               break;
    case 0xF1:
               return 0;
    case 0x0F:
      disasm_flag |= C_OPCODE2;
      disasm_opcode2 = *opcode++;
      switch (disasm_opcode2)
      {
        case 0x00: case 0x01: case 0x02: case 0x03:
        case 0x90: case 0x91: case 0x92: case 0x93:
        case 0x94: case 0x95: case 0x96: case 0x97:
        case 0x98: case 0x99: case 0x9A: case 0x9B:
        case 0x9C: case 0x9D: case 0x9E: case 0x9F:
        case 0xA3:
        case 0xA5:
        case 0xAB:

        case 0xAD:
        case 0xAF:
        case 0xB0: case 0xB1: case 0xB2: case 0xB3:
        case 0xB4: case 0xB5: case 0xB6: case 0xB7:
        case 0xBB:
        case 0xBC: case 0xBD: case 0xBE: case 0xBF:
        case 0xC0:
        case 0xC1:
                   disasm_flag |= C_MODRM;
                   break;
        case 0x06:
        case 0x08: case 0x09: case 0x0A: case 0x0B:
        case 0xA0: case 0xA1: case 0xA2: case 0xA8:
        case 0xA9:
        case 0xAA:
        case 0xC8: case 0xC9: case 0xCA: case 0xCB:
        case 0xCC: case 0xCD: case 0xCE: case 0xCF:
                   break;
        case 0x80: case 0x81: case 0x82: case 0x83:
        case 0x84: case 0x85: case 0x86: case 0x87:
        case 0x88: case 0x89: case 0x8A: case 0x8B:
        case 0x8C: case 0x8D: case 0x8E: case 0x8F:
                   disasm_datasize += disasm_defdata;

                   break;
        case 0xA4:
        case 0xAC:
        case 0xBA:
                   disasm_datasize++;
                   disasm_flag |= C_MODRM;
                   break;
        default:
                   return 0;
      } // 0F-switch
      break;

  } //switch

  if (disasm_flag & C_MODRM)
  {
    disasm_modrm = *opcode++;
    BYTE mod = disasm_modrm & 0xC0;
    BYTE rm  = disasm_modrm & 0x07;
    if (mod != 0xC0)
    {
      if (mod == 0x40) disasm_memsize++;
      if (mod == 0x80) disasm_memsize += disasm_defmem;
      if (disasm_defmem == 2)           // modrm16
      {
        if ((mod == 0x00)&&(rm == 0x06)) disasm_memsize+=2;
      }
      else                              // modrm32
      {
        if (rm==0x04)
        {
          disasm_flag |= C_SIB;
          disasm_sib = *opcode++;
          rm = disasm_sib & 0x07;

        }
        if ((rm==0x05)&&(mod==0x00)) disasm_memsize+=4;
      }
    }
  } // C_MODRM
    disasm_mem[i] = *opcode++;
  for(i=0; i<disasm_datasize; i++)
    disasm_data[i] = *opcode++;

  disasm_len = opcode - opcode0;

  return 1;
} //disasm
jarodlau
关注
专栏目录
汇编指令长度计算方法
chenghuo9876的博客
07-02 1376
一、没有操作数的指令，指令长度为1字节。如 es: ds: cbw xlat 等。 二、操作数只涉及寄存器的指令，指令长度为2字节。如 mov al,[si] mov ax,[bx+si] mov ds,ax 等。 三、操作数涉及内存地...
汇编代码操作寄存器不同，得到不同长度的opcode，从而对程序性能造成影响
k5722166的博客
04-13 913
在分析spec cpu 2017中，汇编指令得到不同的opcode长度，从而对程序性能有影响。差别仅是操作的寄存器不同，一个为%rsp，一个为%rbp： // 使用%rsp寄存器 849d49: 48 8b 84 24 f8 17 00 mov 0x17f8(%rsp),%rax 849d50: 00 // 使用%rbp寄存器 835cfb: 48 8b 85 58 03 00 00 mov 0x358(%rbp),%rax opcode 操作码(Operation Code
OpCode 笔记
wansichao的专栏
11-29 788
OpCode的6个域： PrefixescodeModR/MSIBDisplacementImmediate 记住： 在实际的使用中，并不是这所有的6个域都会被用到的，但是有一项却是一定会有的，那就是第2项：code，有些指令甚至只会用到code这一项。这6个域的排列顺序绝对不能乱，必须严格按照上面的顺序进行。有些域也许不会出现，但是只要出现了，编号小的域就绝对不允许出现在编号大
PHP获取Opcode及C源码
烟草的香味的博客
06-25 1352
在开始之前, 必须要先介绍一下是什么.众所周知, 在执行的时候, 会将后缀的文件预先编译为字节码文件, 加载字节码文件进行解释执行. 而字节码文件存在的意义, 就是为了加速执行.那么的与之类似, 也是从文件到执行的过程中, 所生成的预编译中间文件.或者也可以这样粗鲁的理解, 程序是由写的二进制程序, 就是将文件翻译为代码的结果.有什么用我们最后再说, 先让我们看一下它长什么样子如何获得文件的呢? 在的源码中, 可以通过函数获取代码解析后的. 但是我们要是为了获取得深入到, 是在有些得不偿失. 好在, 已经有
opdata:机会数据库前端
07-11
操作数据 机会数据库前端。
Intel指令格式与长度反汇编引擎ADE32分析
Kendiv's Box
04-04 5803
标 题: 【翻译】intel指令格式与长度反汇编引擎ADE32分析 作 者: 火影 时 间: 2007-10-31,20:31 链 接: http://bbs.pediy.com/showthread.php?t=54180 我翻译的29A#7的一篇文章： ********************************    ***                          ***
cpu怎么知道(判断)一条指令有多少个字节？
qq_40627648的博客
11-05 7483
指令译码一般有几个过程（部件）：指令预取、指令预分析（预解码）、解码。预取是从cache或者内存取一系列的字节（大小可以保证至少包含一条指令），并设置一个待分析的位置，预分析从此位置逐字节分析，如果是前缀就设置分析状态（因为前缀可能改变默认地址尺寸和操作数的大小，影响后续指令长度），直到不是前缀，就认为是操作码，x86的op code长度一般为1字节，某些2字节，查表就可以直接找出指令长度了。 ...
23、指令的格式及其操作尺寸
张登雨的博客
12-14 1526
01、80286的16位保护模式 02、16位处理器的指令操作尺寸 03、32位处理器的指令操作尺寸 04、x86的指令格式--操作码和立即数部分 05、x86的指令格式--ModRM和偏移量部分 06、x86指令格式--SIB部分 07、x86指令格式--指令前缀部分 08、处理器默认操作尺寸和相关指令前缀 09、使用伪指令bits生成16位和32位模块 10、描述符和段描述符高速缓存器的D位 11、进入保护模式并切换到32位模块使用32位默认操作尺寸
disasm_反汇编——逆向
06-08
转，自己写的反汇编引擎——intel编码学习报告
APIHOOK演示
03-16
我在文档中心写的APIHOOK的例子程序。谢谢大家的使用。
x86/x64 指令长度的解码
u012377031的专栏
10-28 5914
转载与http://www.mouseos.com/x64/puzzle01.html 最近在帮肖博士搞X86指令提取，搜了一些好的x86指令解码相关的文章全部出自此人之手（ mik ），分享给大家。 在 《x86/x64 指令编码内幕之指令格式》 一文，见 http://www.mouseos.com/x64/format.html 中说过：指令长度为 15 bytes 那么
用c语言写易语言Linux库,【C语言】 用C写了个常用的代码注入库
weixin_33183792的博客
05-14 215
[C] 纯文本查看 复制代码#include #include #include #include "beaengine/BeaEngine.h"#include "keystone/keystone.h"#include "cheatlib.h"HANDLE GetHandleByTitle(const char *pszTitle){assert(pszTitle!=NULL);HWND hW...
Intel硬编码（一）：Opcode Map、定长指令与指令前缀
Apollon_krj的博客
08-23 7723
IntelCPU的机器指令（硬编码）格式如下图所示： 一个指令由：指令前缀（Instruction Prefixes） + 操作码（Opcode） + ModR/M + SIB + 偏移（displacement） + 立即数（Immediate data）几部分组成，一条指令至少需要有Opcode，其它几部分，在不同指令中可能存在可能不存在。今天我们主要来看Opcode、Instruction
汇编指令长度的判断
Apelpoo的博客
07-10 4870
汇编语言（王爽）中，讲CS:I[寄存器的地方有这样一则图示： 其中IP=IP+所读指令的字节数。 那么，所读指令的字节数应该怎么判断呢？ 汇编指令长度与寻址方式有关，规律或原则如下： 一、没有操作数的指令，指令长度为1个字节 二、操作数只涉及寄存器的的指令，指令长度为2个字节     如：mov bx,ax 三、操作数涉及内存地址的指令，指令长度为3个
OPCode详解及汇编与反汇编原理
热门推荐
sqzxwq的博客
08-19 2万+
1. 何为OPCode 在计算机科学领域中，操作码(Operation Code, OPCode)被用于描述机器语言指令中，指定要执行某种操作的那部分机器码，构成OPCode的指令格式和规范由处理器的指令规范指定。除了指令本身以外通常还有指令所需要的操作数，可能有的指令不需要显示的操作数。这些操作数可能是寄存器中的值，堆栈中的值，某块内存的值或者IO端口中的值等等。 OPCod
快速理解汇编指令：OpCode的长短奥秘
汇编指令之OpCode快速入门是一篇针对初学者的教程，主要讲解汇编指令中的操作码（OpCode）这一概念。OpCode是汇编语言中的关键组成部分，它代表了特定的机器指令，指示处理器执行特定的操作。在汇编中，指令的长度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值