16位汇编学习mov指令反汇编

于 2024-03-30 10:40:41 发布
阅读量353 收藏 5
点赞数 6
文章标签： 汇编 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74197261/article/details/137167466
版权

8086手册mov指令图

手册比较简陋,需要自己去写些代码找些规律.

八大常用寄存器表

段寄存器表

高低位寄存器表

基址变址寄存器表

代码

MyTransfer.h头文件

#pragma once
#include<string>
#include <iostream>
#include <iomanip>
#include<map>
#include<share.h>
#include<sstream>
#include<vector>
#define BIT(a,start,end) ((a)&0xff)>>((end-start))
int GetBit(unsigned char num, int n, int m);//第n位开始的m个位数

enum RegType
{
	/*八大常用寄存器*/
	AX=0,AL=0,AH=4,
	CX=1,CL=1,CH=5,
	DX=2,DL=2,DH=6,
	BX=3,BL=3,BH=7,
	SP=4,
	BP=5,
	SI=6,
	DI=7,
	/*段寄存器*/
	ES=0,
	CS = 1,
	SS=2,
	DS=3,
	/*基址和变址寄存器*/
	BXSI=0,
	BXDI=1,
	BPSI=2,
	BPDI=3,
	IRSI=4,
	IRDI=5,
	BRBP=6,
	BRBX=7
};
class MovType
{
public:
	virtual bool cmp(unsigned char Key) = 0;//如果键值匹配返回true
	virtual std::string Decode(const char* ptr, int& offset) = 0;
	static std::string getSmallReg(int reg );//小的寄存器 ah,al...
	static std::string getGeneralReg(int reg);//八大常用寄存器
	static std::string getSegementReg(int reg);//段寄存器
	static std::string getBrIrReg(int reg);//基址变址寄存器
	static std::string getHex(unsigned char data);//获取一字节16进制数据
private:

};
class MovType1:public MovType
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short w : 1;
	unsigned short d : 1;
	unsigned short key : 6;
public:
	
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType2 :public MovType
{
	unsigned short rm : 3;
	unsigned short z3:3;
	unsigned short mod : 2;
	unsigned short w : 1;
	unsigned  short key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType3:public MovType
{
	unsigned char reg : 3;
	unsigned char w : 1;
	unsigned char key : 4;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType4 :public MovType
{
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType5 :public MovType
{
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType6 :public MovType
{
	unsigned short rm : 3;
	unsigned short reg : 2;
	unsigned short z1 : 1;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
class MovType7 :public MovType
{
	unsigned short rm : 3;
	unsigned short reg : 2;
	unsigned short z1 : 1;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const char* ptr, int& offset);
};
#define PMT std::shared_ptr<MovType>

class MovTransfer
{

	 
public:
	MovTransfer();
	std::string Decode(char* ptr, int& offset);
private:
	std::vector<PMT>mVec;
	//MovType* mVec[7];
private:
};
class MyTransfer
{
public:
	static  std::string Decode(char *ptr,int& offset);//解析字符串  返回
};

mytransfer.cpp

#include "MyTransfer.h"

std::string MyTransfer::Decode(char* ptr, int& index)
{
	return std::string();
}

std::string MovType::getSmallReg(int reg)
{
	switch (reg)
	{
	case AL:
		return "AL";
	case CL:
		return "CL";
	case DL:
		return "DL";
	case BL:
		return "BL";
	case AH:
		return "AH";
	case CH:
		return "CH";
	case DH:
		return "DH";
	case BH:
		return "BH";
	}
	return std::string();
}

std::string MovType::getGeneralReg(int reg)
{
	switch (reg)
	{
	case AX:
		return "AX";
	case CX:
		return "CX";
	case DX:
		return "DX";
	case BX:
		return "BX";
	case SP:
		return "SP";
	case BP:
		return "BP";
	case SI:
		return "SI";
	case DI:
		return "DI";
	}
	return std::string();
}

std::string MovType::getSegementReg(int reg)
{
	switch (reg)
	{
	case ES:
		return "ES";
	case CS:
		return "CS";
	case SS:
		return "SS";
	case DS:
		return "DS";
	}
	return std::string();
}

std::string MovType::getBrIrReg(int reg)
{
	switch (reg)
	{
	case BXSI:
		return "BX+SI";
	case BXDI:
		return "BX+DI";
	case BPSI:
		return "BP+SI";
	case BPDI:
		return "BP+DI";
	case IRSI:
		return "SI";
	case IRDI:
		return "DI";
	case BRBX:
		return "BX";
	case BRBP:
		return "BP";
	}
	return std::string();
}

std::string MovType::getHex(unsigned char data)
{
	static char a[] = { "0123456789ABCDEF" };
	std::string ret;
	do
	{
		//ret.insert(ret.begin(), a[data%16]);
		ret .insert(ret.begin(), a[data % 16]);
		data /= 16;
	} while (data > 0);
	if (ret.size() == 1)
		ret .insert(ret.begin(), '0');
	return ret;
}



bool MovType1::cmp(unsigned char Key)
{
	if (Key >= 0x88 && Key <= 0x8B)
	{
		return true;
	}
	
	return false;
}
/**/
//mod 2位
//00 表示基址变址
//01相对基址变址+1字节偏移
//10相对基址变址+2字节偏移
//11寄存器到寄存器

//w
//1 2字节寄存器
//0 1字节寄存器
//d
//0 到[reg]
//1到reg
std::string MovType1::Decode(const char* ptr, int& offset)
{
	//unsigned char 

	std::string hex_str;
	std::string ret="mov ";
	key = GetBit(ptr[0], 2, 6);
	d = GetBit(ptr[0], 1, 1);
	w = GetBit(ptr[0], 0, 1);
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1],3,3 );
	rm = GetBit(ptr[1], 0, 3);
	std::string Rm;
	std::string Reg;
	if (mod == 3)
	{
		Rm = w == 1 ? getGeneralReg(rm) : getSmallReg(rm);
		Reg=w==1? getGeneralReg(reg) : getSmallReg(reg);
		offset = 2;
	}
	else if (mod == 0)
	{
		Reg = w == 1 ? getGeneralReg(reg) : getSmallReg(reg);
		if (BRBP != rm)
		{
			Rm = w == 1 ? " [" + getBrIrReg(rm) + "]"
				: "[" + getBrIrReg(rm) + "]";
			offset = 2;
		}
		else
		{
			hex_str = getHex(ptr[3]) + getHex(ptr[2]);
			Rm = "[" + hex_str+"]";
			offset = 4;
		}
	}
	else if (mod == 1)
	{
		Reg = w == 1 ? getGeneralReg(reg) : getSmallReg(reg);
		hex_str = getHex(ptr[2]);
		Rm = "[" + getBrIrReg(rm)+ "+"+hex_str + "]";
		offset = 3;
	}
	else
	{
		Reg = w == 1 ? getGeneralReg(reg) : getSmallReg(reg);
		hex_str = getHex(ptr[3])+getHex(ptr[2]);
		Rm = "[" + getBrIrReg(rm) + "+" + hex_str + "]";
		offset = 4;
	}
	if (d)
	{
		ret += Reg + "," + Rm;
	}
	else
	{
		ret += Rm + "," + Reg;
	}
	return ret;
}

bool MovType2::cmp(unsigned char Key)
{
	if (Key == 0xc7 || Key == 0xc6)
		return true;
	return false;
}
// w 1两字节偏移 0一字节偏移
std::string MovType2::Decode(const char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	rm = GetBit(ptr[1], 0, 3);
	mod = GetBit(ptr[1], 6, 2);
	std::string ret = "mov ";
	std::string hex_str;
	std::string Rm= getBrIrReg(rm);
	std::string Reg;
	ret += w == 1 ? "word ptr[" : "byte ptr[";
	if (mod == 0)
	{
		//基址变址 变址表 1/2字节数据
		if (rm!= BRBP)
		{
			ret += Rm+"],";
			hex_str = (w == 1 ? getHex(ptr[3]) : "") + getHex(ptr[2]);
			ret += hex_str;
			offset = w == 1 ? 4 : 3;
		}
		// mov [1234],1234
		else
		{
			hex_str = getHex(ptr[3]) + getHex(ptr[2]);
			ret += hex_str + "],";
			hex_str = (w == 1 ? getHex(ptr[5]) : "")+getHex(ptr[4]);
			ret += hex_str;
			offset = w == 1 ? 6: 5;
		}
	}
	else if (mod == 1)
	{
		hex_str = getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "],";
		hex_str= (w == 1 ? getHex(ptr[4]) : "") + getHex(ptr[3]);
		ret += hex_str;
		offset = w == 1 ? 5 : 4;
	}
	else if (mod == 2)
	{
		hex_str = getHex(ptr[3])+getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "],";
		hex_str = (w == 1 ? getHex(ptr[5]) : "") + getHex(ptr[4]);
		ret += hex_str;
		offset = w == 1 ? 6 : 5;
	}
	//mov reg ,imm
	else
	{
		Reg = w == 1 ? getGeneralReg(rm) : getSmallReg(rm);
		ret += Reg + ",";
		hex_str = (w == 1 ? getHex(ptr[3]) : "") + getHex(ptr[2]);
		ret += hex_str;
		offset = w == 1 ? 4 : 3;
	}

	return ret;
}

bool MovType3::cmp(unsigned char Key)
{
	if (Key >= 0xB0 && Key <= 0xBF)
		return true;
	return false;
}
//w 1 2字节立即数 0 1字节立即数 
std::string MovType3::Decode(const char* ptr, int& offset)
{
	w = GetBit(ptr[0], 3, 1);
	reg = GetBit(ptr[0], 0, 3);
	std::string ret="mov ";
	if (w == 1)
	{
		ret += getGeneralReg(reg)+","+getHex(ptr[2])+getHex(ptr[1]);
		offset = 3;
	}
	else
	{
		ret += getSmallReg(reg) + "," + getHex(ptr[1]) ;
		offset = 2;
	}
	return ret;
}
//内存到累加器
//w =1 ax
//w =0 al
bool MovType4::cmp(unsigned char Key)
{
	if (Key == 0xa1||Key==0xa0)
		return true;
	return false;
}

std::string MovType4::Decode(const char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	std::string ret = "mov ";
	if (w == 1)
	{
		ret += "ax ,["+getHex(ptr[2])+getHex(ptr[1])+']';
		offset = 3;
	}
	else
	{
		ret += "al ,[" + getHex(ptr[1]) + ']';
		offset = 2;
	}
	return ret;
}

bool MovType5::cmp(unsigned char Key)
{
	if (Key == 0xa2 || Key == 0xa3)
		return true;
	return false;
}

std::string MovType5::Decode(const char* ptr, int& offset)
{
	std::string ret = "mov ";
	w = GetBit(ptr[0], 0, 1);
	if (w == 1)
	{
		ret += '[' + getHex(ptr[2]) + getHex(ptr[1])+"],ax";
		offset = 3;
	}
	else
	{
		ret += '[' + getHex(ptr[1]) + "],al";
		offset = 2;
	}
	return ret;
}

bool MovType6::cmp(unsigned char Key)
{
	if (Key == 0x8E)
		return true;
	return false;
}

std::string MovType6::Decode(const char* ptr, int& offset)
{
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 2);
	rm = GetBit(ptr[1], 0, 3);
	std::string ret = "mov ";
	std::string Reg = getSegementReg(reg);
	std::string Rm = getBrIrReg(rm);
	std::string hex_str;
	ret += Reg + ",";
	if (mod == 3)
	{
		Rm = getGeneralReg(rm);
		ret += Rm;
		offset = 2;
	}
	else if (mod == 2)
	{
		hex_str = getHex(ptr[3]) + getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "],";
		offset = 4;
	}
	else if (mod == 1)
	{
		hex_str = getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "]";
		offset = 3;
	}
	else
	{
		if (rm == BRBP)
		{
			hex_str += getHex(ptr[3]) + getHex(ptr[2]);
			ret += "[" + hex_str + "]";
			offset = 4;
		}
		else
		{
			ret += "[" + Rm + "]";
			offset = 2;

		}
	}

	return ret;
}

bool MovType7::cmp(unsigned char Key)
{
	if (Key == 0x8c)
		return true;
	return false;
}

std::string MovType7::Decode(const char* ptr, int& offset)
{
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 2);
	rm = GetBit(ptr[1], 0, 3);
	std::string ret = "mov ";
	std::string Reg = getSegementReg(reg);
	std::string Rm = getBrIrReg(rm);
	std::string hex_str;
	if (mod == 3)
	{
		Rm = getGeneralReg(rm);
		ret += Rm + ",";
		offset = 2;
	}
	else if (mod == 2)
	{
		hex_str = getHex(ptr[3]) + getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "],";
		offset = 4;
	}
	else if (mod == 1)
	{
		hex_str = getHex(ptr[2]);
		ret += "[" + Rm + "+" + hex_str + "],";
		offset = 3;
	}
	else
	{
		if (rm == BRBP)
		{
			hex_str += getHex(ptr[3]) + getHex(ptr[2]);
			ret += "[" + hex_str + "],";
			offset = 4;
		}
		else
		{
			ret += "[" + Rm + "],";
			offset = 2;

		}
	}
	ret += Reg;
	return ret;

	
}

MovTransfer::MovTransfer():mVec{
PMT(new MovType1()),PMT(new MovType2()),PMT(new MovType3())
,PMT(new MovType4()),PMT(new MovType5()),PMT(new MovType6()),PMT(new MovType7()) }
{
}

std::string MovTransfer::Decode(char* ptr, int& offset)
{
	int len = mVec.size();
	for (int i = 0; i < len; i++)
	{
		if(mVec[i].use_count())
		if (mVec[i].get()->cmp(ptr[0]))
		{
			return mVec[i]->Decode(ptr, offset);
		}
	}

	return std::string();
}

int GetBit(unsigned char num, int n, int m)
{
	return (num >> n) & ((1 << m) - 1);
}

测试main函数

// disassemble.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include"MyTransfer.h"
#include<Windows.h>
int main()
{
	MovTransfer type ;
	std::string szPath = "TEST7.BIN";
	HANDLE hFile = CreateFileA(
		szPath.c_str(),
		GENERIC_READ,
		FILE_SHARE_READ,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL
	);
	// 文件大小
	DWORD dwFileSize = GetFileSize(hFile, NULL);
	// 根据文件大小创建堆空间
	unsigned char* pBuf = new unsigned char[dwFileSize];
	DWORD dwBytesReaded = 0;
	// 读取文本内容
	BOOL bRet = ReadFile(
		hFile,
		pBuf,
		dwFileSize,
		&dwBytesReaded,
		NULL
	);
	char* ptr = (char*)pBuf;
	int offset = 0;
	int index = 0;
	while (index < dwFileSize)
	{
		std::cout<<type.Decode(ptr, offset)<<std::endl;
		index += offset;
		ptr += offset;
	}
		

	return 0;
}

那个叔叔
关注
反汇编工具IDA使用详解（使用IDA查看二进制文件的汇编代码以及使用IDA分析崩溃问题实例分享）
dvlinker的技术专栏
10-07 5万+
本文详细介绍一下IDA反汇编工具，介绍如何使用IDA反汇编工具查看二进制文件的汇编代码，并分享一个使用IDA排查程序崩溃的实例。
使用反汇编工具IDA查看发生异常的汇编代码的上下文去辅助分析C++软件异常
热门推荐
dvlinker的技术专栏
08-08 3万+
详细讲述如何使用IDA查看发生异常的汇编代码的上下文，去辅助分析C++软件异常。
机器指令反汇编表（中文）
02-01
机器代码与汇编助记符及其参数的快速查找表
逆向-汇编基础
megaparsec
09-19 406
汇编基础 进制 二(B) 八(O) 十(D) 十六(H) 进制的本质就是找对应数值，每个进制都是一个独立体系，并不需要转换成其他形式做运算。 数据宽度 常见的单位有如下几个： 位 Bit 只存一位二进制 字节 Byte 可存储八位二进制0~FF 字 Word 可存储十六位二进制0~FFFF 双字 Dword 可存储三十二位二进制0~FFFFFFFF 数据溢出 如果数据超出存储范围，就会抛弃数据，默认抛弃左边的（高端）数据 有无符号数 二进制开头0和1，有符号时，0代表正数，1代表负数 原码：符号位不变，其余
部分C库函数重写以及反汇编分析之memmov()
yuanlanjun
07-29 154
/*///////////////////////////////////////////////////////////////////////////////////// 功能：由src所指内存区域复制count个字节到dest所指内存区域。 　　 说明：src和dest所指内存区域可以重叠，但复制后dest内容会被更改。函数返回指向dest的指针。 //////////////////...
反汇编代码格式
drinkingcode
10-10 1831
005CF969  |.  8BF8          mov     edi, eax   第一列就是指令的物理地址,由程序每次装入的不同而可能不同,若在不同机器上大多时候是不相同的,就是在内存中的地址,也就是所谓的"地址编号",可以这样理解的.第二列就是指令字,也就是说二进制才是机器所认识的编码的,由于其计数较难,用十六进制表示,这个十六进行就是说机器码的.比如51就是将ECX入栈.等等,
反汇编笔记
百里杨的博客
09-11 1571
1.OD中ctrl+f9:运行到返回，就是运行到当前断点所在的函数末尾"retn xxx"处，若xxx=10，那么 10等于10进制的16，就是说这个函数有4个参数，一个参数默认是占4字节，所以就是retn 10。 2.调试程序时，在OD内部小窗口左上角会显示当前断点所在的函数层，是在系统领空还是某个应用程序领空。 3.call前出现lea edx,dword ptr ss:[ebp
反汇编
William的blog
11-16 705
00401028   push        edi                                                        00401027   push        esi   00401026   push        ebx   00401029   lea         edi,[ebp-40h]
汇编指令查询器，汇编指令搜索器
最新发布
04-04
- 查找指令：用户可以通过关键词搜索特定的汇编指令，如`MOV`（数据传输）、`ADD`（加法）、`JMP`（无条件跳转）等。 - 参数解释：查询器会解释指令的操作数类型和数量，以及它们在指令中的作用。 - 示例代码：...
16位与32位汇编语言常用指令总结
qq_43556776的博客
04-02 2823
对汇编指令的一些总结
电脑32位反汇编指令大全
03-13
电脑32位反汇编指令大全，用于电脑反汇编后的代码读取
反汇编指令与机器码对照表.zip
09-05
反汇编指令与机器码对照表，按字母排序，有索引，有对应的英文解释，非常方便，可以用360极速浏览器打开
反汇编指令与机器码对照表
07-20
反汇编指令与机器码对照表，按字母排序，有索引，非常方便
汇编学习笔记——汇编指令
aketoshknight的博客
04-09 4998
mov、add指令 定义：mov A,B将B中的数据移入A；add A,B将A与B相加的结果存入A 示例1：mov与add指令对应到高级编程语言中 PS:汇编指令不区分大小写，即MOV等效与mov 示例2：使用高低8位寄存器的情况下的指令执行结果 PS:最后一条指令中，C5H与93H相加的结果为158，但因为al寄存器只能存储8位数据，因此最高位1因为数据溢出而被舍弃（因使用的是al寄存器进行独立运算，故该进位不会进入ah寄存器中） ...
[免杀]初·反汇编指令大全
m0_68702501的博客
11-18 894
反汇编入门，汇编指令大全
反汇编---汇编指令及相关例子分析
li_xiang_li的博客
03-12 1176
0x1>反汇编代码中一些确定的模式 push   0 push   1 push   2 call      xxx 函数调用语句，与相关的调用约定有关 push   ebp mov    ebp, esp push   xxx ... 保护堆栈，出现在函数的开头，之后会有一些push操作来保护寄存器 label: cmp    ecx,  10 je  
【ARMv7-A】——常用反汇编命令
tyustli
07-22 4896
gcc 反汇编 arm-none-eabi-objdump.exe -d .\rtthread.elf > rtthread.asm arm-none-eabi-objdump.exe：反汇编用到的编译器 -d ：disassemble 表示反汇编 rtthread.elf：表示需要反汇编的文件 rtthread.asm：生成的汇编文件的名称(注意前面的 > 符号) armcc 反汇编 D:\SoftWare_Application\Keil_MDK_5.32\ARM\ARMCC\bin
Win32反汇编（二）几种常见的指令反汇编详解：EAX、MOVSX与MOVZX、LEA、SUB、CMP与转移指令
浪子花梦
08-09 6040
前言 作者：浪子花梦，一个有趣的程序员 ~ 此系列文章都是一些基础的文章，每篇文章都通过几个小例子快速的了解 Win32反汇编与OD的使用，在此作个笔记 如若对您有帮助，记得三连哟 ~ 前文链接 Win32反汇编（一） 初步探索Win32反汇编 与 Ollydbg的简单使用 文章目录 EAX相关寄存器的结构 MOVSX与MOVZX扩展转移指令 LEA取地址指令 SUB减法指令 CMP与转移指令的配合使用 OD 使用情况小结 ...
mips反汇编命令
c2h5oh2012的博客
05-26 1107
mips-linux-gnu-objdump -d vmlinux > 1.txt
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值