写一个虚拟机的模型

最新推荐文章于 2024-05-07 15:59:19 发布
最新推荐文章于 2024-05-07 15:59:19 发布
阅读量1.4k 收藏 1
点赞数 2
分类专栏： C/C++ 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19459853/article/details/50756088
版权
代码虚拟化：

我认为代码虚拟化是将native转换为字节码，但是字节码是不能被机器识别的，所以就需要有对应的解释器来解释他。因为字节码是我们定义的，所以一般的工具不能正确的识别它。就因为这样，虚拟机保护的代码比较难以识别破解，但是解释器一般情况下都是native 因为这样才能使解释器运行起来并解释字节码。

#define EXor 0x77//xor
#define ERetn 0xCC//retn
#define ECmp 0x78//cmp
#define EJnz 0x79//jnz
#define EJmp 0x80//jmp
#define EMov 0xC4//mov
#define ECall 0xEE//call
#define ERetn 0xFE//retn
#define EAdd 0xFF//add
#define ENot 0xEC//not
然后是虚拟寄存器的值（用来判断寄存器的）
因为数值可能被占用，所以我选的都是些不常用的。 

#define VMyEax 0xF1//eax
#define VMyEcx 0xF2//ecx
#define VMyEdx 0xF3//edx
#define VMyEbx 0xF4//ebx
#define VMyEsp 0xF5//esp
#define VMyEbp 0xF6//ebp
#define VMyEsi 0xF7//esi
#define VMyEdi 0xF8//edi
#define VMyEip 0xF9//eip
然后定义虚拟寄存器（16位） 
struct MyVM
{
        DWORD MyEax;
        DWORD MyEcx;
        DWORD MyEdx;
        DWORD MyEbx;
        DWORD MyEsp;
        DWORD MyEbp;
        DWORD MyEsi;
        DWORD MyEdi;
        DWORD MyEip;
        DWORD MyC;
        DWORD MyP;
        DWORD MyA;
        DWORD MyZ;
        DWORD MyS;
        DWORD MyT;
        DWORD MyD;
        DWORD MyO;
}MyVM={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
typedef struct MyVM *pMyEasyVM,MyEasyVM;
MyEasyVM VM;//初始化虚拟寄存器

除了这些以外，我还自定义了一个寄存器。。。
然后自己根据自定义的字节码写出一个小程序。
因为这字节码都是用数组存放的，所以call jmp jnz的偏移都用数组下标就可以了（为了方便起见）（call到API的话就不太适用了，你可以做记号来判断等等）
因为这只是一个模型，还有很多功能没有实现，谁让我技术太烂了。。以后我会补上的。
编译环境：XP下的VC++6.0
EasyVm.h 
//
/* 字节码可以自己定义，只要用到的函数中的代号在指令集里！   */
/* 也可以自己添加哦                                         */
//
#include <stdio.h>
#include <windows.h>

/*/// 指令集 */
/
#define EXor 0x77//xor
#define ERetn 0xCC//retn
#define ECmp 0x78//cmp
#define EJnz 0x79//jnz
#define EJmp 0x80//jmp
#define EMov 0xC4//mov
#define ECall 0xEE//call
#define ERetn 0xFE//retn
#define EAdd 0xFF//add
#define ENot 0xEC//not
//输入信息
#define vm_read 0xEA//自定义函数
//输出信息
#define vm_write_err 0xCE//自定义函数
#define vm_write_success 0xCF//自定义函数

///
/*/// 虚拟寄存器值 /*/
/
#define VMyEax 0xF1//eax
#define VMyEcx 0xF2//ecx
#define VMyEdx 0xF3//edx
#define VMyEbx 0xF4//ebx
#define VMyEsp 0xF5//esp
#define VMyEbp 0xF6//ebp
#define VMyEsi 0xF7//esi
#define VMyEdi 0xF8//edi
#define VMyEip 0xF9//eip
#define VMyAddr 0xFA
/
struct MyVM
{
        DWORD MyEax;
        DWORD MyEcx;
        DWORD MyEdx;
        DWORD MyEbx;
        DWORD MyEsp;
        DWORD MyEbp;
        DWORD MyEsi;
        DWORD MyEdi;
        DWORD MyEip;
        DWORD MyAddr;//自定义的地址寄存器
        DWORD MyC;
        DWORD MyP;
        DWORD MyA;
        DWORD MyZ;
        DWORD MyS;
        DWORD MyT;
        DWORD MyD;
        DWORD MyO;
}MyVM={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
typedef struct MyVM *pMyEasyVM,MyEasyVM;
MyEasyVM VM;//初始化虚拟寄存器
/* 字节码 */
unsigned char MyCode[]={EMov,VMyEbx,89,vm_read,ECmp,VMyAddr,VMyEbx,EJnz,/*8*/11,vm_write_success,ERetn,vm_write_err,ERetn};//代码
int MyRead;//写进去的信息
/* 有时为了方便调试，会用到这些函数 */
void pEax()
{
        printf("eax=%xH\n",VM.MyEax);
}
void pEcx()
{
        printf("ecx=%xH\n",VM.MyEcx);
}
void pEdx()
{
        printf("edx=%xH\n",VM.MyEdx);
}
void pEbx()
{
        printf("ebx=%xH\n",VM.MyEbx);
}
void pEsp()
{
        printf("esp=%xH\n",VM.MyEsp);
}
void pEbp()
{
        printf("ebp=%xH\n",VM.MyEbp);
}
void pEsi()
{
        printf("esi=%xH\n",VM.MyEsi);
}
void pEdi()
{
        printf("edi=%xH\n",VM.MyEdi);
}
void pEip()
{
        printf("eip(指令执行处)=%xH(%u)\n",VM.MyEip,VM.MyEip);
}

void RunCode()
{
        int i,k=1;
        BOOL Jnz=FALSE,Jmp=FALSE,Call=FALSE,Retn=FALSE;
Run:
        for(i=VM.MyEip;i<sizeof(MyCode);i++)
        {
                if(MyCode[i]==vm_write_success)
                {
                        VM.MyEax=printf("ok\n");//返回值
                        VM.MyEip+=2;//这里在数组中占用一个字节
                }
                if(MyCode[i]==vm_write_err)
                {
                        VM.MyEax=printf("error!\n");//返回值
                        VM.MyEip+=2;//这里在数组中占用一个字节
                }
                if(MyCode[i]==vm_read)
                {
                        //输入信息
                        VM.MyEax=scanf("%d",&VM.MyAddr);//返回值
                        VM.MyEip+=2;//这里在数组中占用一个字节
                }
                if(MyCode[i]==EXor)
                {
                        int j;
                        DWORD MyArgc,argc1;
                        MyArgc=MyCode[i+1];
                        argc1=MyCode[i+2];
                        VM.MyEdx=MyArgc;
                        VM.MyEbx=argc1;
                        VM.MyEdx=VM.MyEdx^VM.MyEbx;
                        printf("xor %u,%u = %u\n",MyArgc,argc1,VM.MyEdx);
                        VM.MyEip+=4;
                }
                if(MyCode[i]==EAdd)
                {
                        int j;
                        DWORD MyArgc,argc1;
                        MyArgc=MyCode[i+1];
                        argc1=MyCode[i+2];
                        VM.MyEdx=MyArgc;
                        VM.MyEbx=argc1;
                        VM.MyEdx=VM.MyEdx+VM.MyEbx;
                        printf("add %u,%u = %u\n",MyArgc,argc1,VM.MyEdx);
                        VM.MyEip+=4;
                }
                if(MyCode[i]==ENot)
                {
                        int j;
                        DWORD MyArgc;
                        MyArgc=MyCode[i+1];
                        VM.MyEdx=MyArgc;
                        VM.MyEdx=~VM.MyEdx;
                        printf("not %u = %u\n",MyArgc,VM.MyEdx);
                        VM.MyEip+=3;
                }
                if(MyCode[i]==EMov)
                {
                        DWORD r,r1;
                        r=MyCode[i+1];
                        r1=MyCode[i+2];
                        /* 将值拷贝到虚拟寄存器中，原数据被覆盖 */
                        if(r==VMyEax)
                                VM.MyEax=r1;
                        if(r==VMyEcx)
                                VM.MyEcx=r1;
                        if(r==VMyEdx)
                                VM.MyEdx=r1;
                        if(r==VMyEbx)
                                VM.MyEbx=r1;
                        if(r==VMyEsp)
                                VM.MyEsp=r1;
                        if(r==VMyEbp)
                                VM.MyEbp=r1;
                        if(r==VMyEsi)
                                VM.MyEsi=r1;
                        if(r==VMyEdi)
                                VM.MyEdi=r1;
                        VM.MyEip+=4;
                }
                if(MyCode[i]==ECmp)
                {
                        DWORD r3,r4,r5,r6;
                        r3=MyCode[i+1];
                        r4=MyCode[i+2];
                        if(r3==VMyEax)
                                r5=VM.MyEax;
                        else if(r3==VMyEcx)
                                r5=VM.MyEcx;
                        else if(r3==VMyEdx)
                                r5=VM.MyEdx;
                        else if(r3==VMyEbx)
                                r5=VM.MyEbx;
                        else if(r3==VMyEsp)
                                r5=VM.MyEsp;
                        else if(r3==VMyEbp)
                                r5=VM.MyEbp;
                        else if(r3==VMyEsi)
                                r5=VM.MyEsi;
                        else if(r3==VMyEdi)
                                r5=VM.MyEdi;
                        else if(r3==VMyAddr)
                                r5=VM.MyAddr;
                        else
                                r5=r3;
                        if(r4==VMyEax)
                                r6=VM.MyEax;
                        else if(r4==VMyEcx)
                                r6=VM.MyEcx;
                        else if(r4==VMyEdx)
                                r6=VM.MyEdx;
                        else if(r4==VMyEbx)
                                r6=VM.MyEbx;
                        else if(r4==VMyEsp)
                                r6=VM.MyEsp;
                        else if(r4==VMyEbp)
                                r6=VM.MyEbp;
                        else if(r4==VMyEsi)
                                r6=VM.MyEsi;
                        else if(r4==VMyEdi)
                                r6=VM.MyEdi;
                        else if(r4==VMyAddr)
                                r6=VM.MyAddr;
                        else
                                r6=r4;
                        if(r6==r5)
                                VM.MyZ=0;
                        else
                                VM.MyZ=1;
                        VM.MyEip+=4;//Eip的值加4
                }
                if(MyCode[i]==EJnz)
                {
                        if(VM.MyZ==1)//读取标志位
                        {
                                int JnzAddress;
                                JnzAddress=MyCode[i+1];
                                VM.MyEip=JnzAddress;//从虚拟寄存器中的EIP指向处开始执行
                                Jnz=TRUE;
                                break;
                        }
                        else
                                VM.MyEip+=3;
                }
                if(MyCode[i]==EJmp)
                {
                        //直接跳转
                        int JmpAddress;
                        JmpAddress=MyCode[i+1];
                        VM.MyEip=JmpAddress;//从虚拟寄存器中的EIP指向处开始执行
                        Jmp=TRUE;
                        break;        
                }
                if(MyCode[i]==ECall)
                {
                        int CallAddress;
                        CallAddress=MyCode[i+1];
                        VM.MyEsp=i+2;//call返回地址
                        VM.MyEip=CallAddress;
                        Call=TRUE;
                        break;
                }
                if(MyCode[i]==ERetn)
                {
                        VM.MyEip=VM.MyEsp;
                        Retn=TRUE;
                        break;
                }
        }
        if(Jnz)
        {
                Jnz=FALSE;
                goto Run;
        }
        if(Jmp)
        {
                Jmp=FALSE;
                goto Run;
        }
        if(Call)
        {
                Call=FALSE;
                goto Run;
        }
        if(Retn)
        {
                if(VM.MyEsp<=0)
                        return;
                Retn=FALSE;
                k+=1;
                goto Run;
        }
}

EV.c 

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "EasyVm.h"
#define pause system("pause")
int main(void)
{
        printf("Hello World\n");
        printf("Address:%xH\n",&MyCode);
        RunCode();
        pause;
        return 0;
}
这里的字节码是一个简单的CrackMe。注册成功的图片：

注册失败的图片：


虚拟机保护效果：
OD中查看：


如果在OD中查看字节码，并且不知道每个字节码的意思，不分析解释器的话，谁能看出这是什么意思呢？

因为这是字节码，机器不能识别，只有对应的解释器才能识别，一般的工具都是没有效果的！因为字节码是我们自己定义的。
动态调试：
也是一样，并不会被识别，因为处理器并不会理会这些字节码，理会这些字节码的只有我们的解释器！而且调试也是在调试解释器哦。其实我们还可以分析解释器，来分析字节码。不过解释器中的控制流会复杂很多，也能增加分析难度。
如果要爆破的话，把解释器中的jnz解释函数nop掉就行了，如果字节码有很多jnz的话。嘿嘿嘿嘿大笑 卵用~~~
刚刚我就nop掉了，结果破解成功了，不过我是依照OD搜索出来的EasyVm.h中的内容才破解出来的。
注意：如果写出这样的CM给别人破解的话，千万别原封不动的发出去哦~如果是我的话我就会给代码绕一大圈然后乱序。

_KaQqi
关注
专栏目录
Java 虚拟机内存模型
zhaohuodian的博客
08-25 1551
Java 虚拟机，简称 JVM(Java Virtual Machine)，是 Java 语言中最为核心的一个东西，Java 程序运行离不开它，因为它的存在，使得 Java 拥有“一次编译，多次运行”的特点。任何平台只要装有针对于该平台的 Java 虚拟机，字节码文件（.class）就可以在该平台上运行。JVM 是 Java 中最难以理解、而且非常重要的知识点，也常常用来衡量一个人 Java 基本功是否牢靠，更是在面试中被问及最多、最频繁的知识点之一。本文将从开始入手，一步步来了解它。
虚拟机：动手实现一个虚拟机
02-14
虚拟机 一起来动手实现一个虚拟机，自定义指令集，只需使用简单的c语言。这对弄懂程序运行的完全原理绝对有好处，还能体验一下手写指令的快感哟。 相关文章如下： 「听说你想写个虚拟机（x）」系列已全部完结，欢迎阅读〜 文章会同步发布到和公众号“微微笑的蜗牛”，欢迎关注。在公众号输入框回复“蜗牛”，可添加微信进行交流〜
用c语言写个电脑虚拟机
qq_39229627的博客
01-18 526
文件中读取指令，每个指令由一个操作码和一个操作数组成。目前支持的操作码有ADD、SUBTRACT和PRINT，分别对应加法、减法和输出操作。实际的虚拟机实现会更加复杂，涉及更多的指令、寄存器、内存管理、异常处理等内容。编写一个完整的虚拟机是一个相当复杂的任务，涉及到很多底层的知识，例如计算机架构、操作系统、内存管理、输入输出等。这里我给你一个简化的示例，展示如何使用C语言创建一个简单的虚拟机来执行一些基本的汇编指令。这个示例中，我们使用一个数组来表示内存，每个元素可以存储一个整数。
如何自己写一个基于栈,虚拟机的语言
nick131410的博客
01-20 1029
写一个基于堆栈的语言 想必大家都已经了解GOF的解释器模式，他的优点很明显-安全，因为语法行为是我们自己定义的，不直接接触底层，但缺点也很明显——效率低，内存开销大。 再来看下我们的C++，直接编译成机器码，机器码是一组密集的，线性的，底层的指令，效率飞快。但又有谁愿意直接编辑机器码呢。 那有没有兼得熊掌和鱼的方法呢，有——定义自己的虚拟机器码，然后再在需要的地方写一个小的模拟器。 我们将这个模拟...
编写虚拟机操作脚本
helloPucca的博客
04-20 1273
编写脚本/mnt/test.sh ，可以使用test.sh命令来实现  安装，启动，关闭，删除，重置虚拟机，以及对虚拟机进行快照功能。 使用vm_test.sh install   安装名为nihao的虚拟机 使用vm_test.sh remove 删除名为westos的虚拟机 使用vm_test.sh start /stop 名为server的虚拟机
自己动手写虚拟机
10-05
自己动手写虚拟机，java,java虚拟机，java核心技术
手写JAVA虚拟机（二）——实现java命令行
weixin_30505485的博客
04-25 148
　　查看手写JAVA虚拟机系列可以进我的博客园主页查看。 　　我们知道，我们编译.java并运行.class文件时，需要一些java命令，如最简单的helloworld程序。 　　 　　这里的程序最好不要加包名，因为加了包名的话编译和运行需要有所改动。 　　看这里的命令。javac为编译命令，我们知道java的特点是一次编译，到处运行。这里的编译指的就是javac，对于java程序即.ja...
自己动手写JVM——(1) 虚拟机的构造与运行
qq_44807796的博客
10-05 1047
自己动手写JVM 在class文件文件中会有Code AttributeInfo 其中包含了jvm字节码，通过解析这些字节码，翻译成对应的指令，再逐步执行这些我们已经实现好了的指令，就实现了一个有效的虚拟机
我也写了一个Java虚拟机
最新发布
Java团长的博客
05-07 25
Java圈，就没有有技术含量的课程吗。成天看到的都是架构师、架构师…都是Java层面的，想学点硬核的都没人教……你是不是被这些困扰着：Java的类与对象在JVM中是如何表示的？如何查看？Java代码在JVM中是如何运行的？JVM的内存模型与Linux进程内存空间之间是什么样的关系？Java的多线程与Linux多线程之间的关系？Java的互斥同步与Linux互斥同步之间的关系？如何打下基础彻底悟透J...
虚拟机内存模型
04-12
虚拟机内存模型是计算机科学中的一个重要概念，尤其是在Java和许多其他高级编程语言中。它描述了虚拟机如何管理和使用内存，以确保程序的正确运行。本文将深入探讨虚拟机内存模型的基本结构、功能以及相关工具的使用...
easyVM_v0.2
02-26
easyVM是一个简单的虚拟机。0.1版本只支持8086指令集和一些简单的I/O设备，只支持英文文本显示方式。0.2版本主要是在0.1版基础上加了一小部分32位指令（push eax等），使得easyVM可以运行MS-DOS 6.22自带的大部分程序。
Java内存模型中的虚拟机栈原理分析
08-25
虚拟机栈是Java虚拟机中的一个重要组件，用于存储Java方法执行的相关信息。理解虚拟机栈的工作原理对于Java程序的开发和优化具有重要的意义。 知识点： 1. 虚拟机栈是Java虚拟机中的一个内存区域。 2. 虚拟机栈是...
一篇文章总结Java虚拟机内存区域模型
08-25
每个方法在执行时都会创建一个栈帧，用于存储这些信息。Java虚拟机栈是线程私有的，生命周期与线程相同。 3. 本地方法栈（Native Method Stack） 本地方法栈和虚拟机栈所发挥的作用非常相似，都是为虚拟机执行的...
虚拟机隔离运行模型.docx
05-21
通过平衡安全隔离性、功能完整性、性能适应性和行为可监控性等多方面需求，SVEE为不可信软件的隔离执行提供了一个高效可靠的解决方案。未来的研究方向可能包括进一步优化性能、增强兼容性以及拓展应用场景等方面。 ...
C语言最佳实践！从0到1编写自己的虚拟机
【User Not Found】的博客
06-28 1150
原文：https://justinmeiners.github.io/lc3-vm/ 原作者：Justin Meiners and Ryan Pendleton 中英对照 机翻 Write your Own Virtual Machine By: Justin Meiners and Ryan Pendleton 作者: Justin Meiners 和 Ryan Pendleton View the final code and other resources in the GitHub repo. .
C语言写个简单的虚拟机
Ez_coder的博客
05-28 1505
伪代码: 寄存器用变量表示 内存用数组表示 定义宏定义为操作码功能 1.数据定义 2.打印功能 3.错误判断 1.数据定义 { 定义寄存器 定义计数器 定义指针寄存器(指向下一条将要执行的指令EIP) 定义操作码 定义操作数 } 2.打印函数 { 打印信息 } 3.错误判断 { 判断是否溢出 判断除数 } main函数 { do { do{ }whlie }whlie 输入 do{ SWITCH语句执行操作 }(操作码不等于43) } #define _CRT_SECURE_NO_WARNING
创建虚拟机
csdnwyn314的博客
08-10 324
1.虚机部署：所需软件下载： 首先下载软件：VMware 你可以选择虚机试centos/windows系统，下面演示centos系统的虚机： 下载centos , 并找到文件对应的路径。 2.我已VMware 12 版本为例 下载好VMware 之后，可以先搜索一个12版本的注册码。 例如：注册码： 5A02H-AU243-TZJ49-GTC7K-3C61N
从0到1构建计算机(7/12)--实现一个虚拟机
XA403
02-24 809
计算机工作的本质就是对内存中的数据进行操作，因此只需要具备两种能力即可：(1)对内存的读和写；(2)用对数据进行算数逻辑运算。此外，支持指令跳转能大大提高计算机的可编程能力。直观上看，Hack具备了以上三项能力，我们上一篇也举例了如何实现1+2+…+100。但Hack和我们常用的CPU具备几百条指令集的能力还相去甚远，例如支持四则运算，对栈的操作，指针寄存器的使用，支持函数调用，处理入参和回参等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值