虚拟机反检测代码
FT功能详解与检验测试
一、什么是FT功能Vmware fault tolerance（FT）功能创建一个虚拟机设置可以提供连续性能力。
FT建立在ESX/ESXi主机平台。
通过创建一个虚拟机一个完全相同的副本。
虚拟机的主要副本，处于活动状态，接受请求，服务信息，并运行程序。
次要副本，接收与主副本相同的输入。
次要副本完成的所有任务都依照主副本的变动。
主副本所有非决定性的活动都将被捕捉，发送到运行在其他host 上的次要副本，次要副本在一秒内将活动进行重演。
FT启动后，VM Tools从每个虚机中发送心跳到VMM，此心跳与HA的心跳类似。
VMM检查以确保主要和次要副本都在运行。
如果主副本所在的host丢失，VMM将不再发送心跳。
此时，次要副本立刻变为活动的，并成为主要副本，服务不会经历任何中断。
FT提供了比HA更高的商业连续性级别。
FT发生时，次要立刻被激活，所有关于虚机状态的信息都会被完整的保留。
存储在内存中的数据不需要被re-entered或reloaded。
而HA则要将任何丢失的虚拟机进行重启。
这会结束所有虚拟机进程和状态信息，程序和未保存的用户输入信息都会丢失。
二、VMware FT 容错的工作方式VMware 容错可通过创建和维护等同于主虚拟机并可在发生故障切换时替换主虚拟机的辅助虚拟机来为虚拟机提供连续可用性。
可以为大多数任务关键虚拟机启用容错。
并会创建一个重复虚拟机（称为辅助虚拟机），该虚拟机会以虚拟锁步方式随主虚拟机一起运行。
VMware vLockstep 可捕获主虚拟机上发生的输入和事件，并将这些输入和事件发送到正在另一主机上运行的辅助虚拟机。
使用此信息，辅助虚拟机的执行将等同于主虚拟机的执行。
因为辅助虚拟机与主虚拟机一起以虚拟锁步方式运行，所以它可以无中断地接管任何点处的执行，从而提供容错保护。
虚拟机和辅助虚拟机可持续交换检测信号。
这使得虚拟机对中的虚拟机能够监控彼此的状态以确保持续提供容错保护。
如果运行主虚拟机的主机发生故障，系统将会执行透明故障切换，此时会立即启用辅助虚拟机以替换主虚拟机，并将启动新的辅助虚拟机，同时在几秒钟内重新建立容错冗余。
基于VMware的反虚拟机环境检测技术研究
基于VMware的反虚拟机环境检测技术研究作者：朱永强汤雄来源：《软件导刊》2016年第07期摘要：VMware虚拟机因其良好的用户体验及便捷的功能，被广泛应用于云计算平台搭建、恶意代码分析等技术领域。
因此，部分恶意代码专门增加了VMware环境检测功能，以发现自身是否运行在VMware虚拟环境。
针对恶意代码在VMware环境下的虚拟环境检测技术，分析了VMware虚拟机环境的检测原理及优缺点，提出了一套VMware环境下的反虚拟环境检测方法，以欺骗恶意软件的VMware环境检测功能，提升基于VMware仿真的恶意代码分析准确性。
关键词关键词：VMware；虚拟机；虚拟机环境检测；虚拟机穿透DOIDOI：10.11907/rjdk.161300中图分类号：TP309文献标识码：A文章编号文章编号：16727800（2016）007017003基金项目基金项目：科技部科技型中小企业创新基金项目（10C26215122841）0引言虚拟化技术是指通过分割计算机硬件资源（如CPU、内存、辅存等），使得一台物理机上可以运行多个操作系统环境，从而提供更灵活高效的硬件资源分配技术。
该技术最早由IBM 在20世纪60年代初实现。
虚拟化技术发展到今天，出现了多种虚拟化平台，如XEN、KVM、VMware等。
其中，VMware由于良好的性能及便捷的功能支持得到了广泛应用。
由于带有快照还原功能以及物理隔离功能，虚拟化技术对恶意代码分析人员是非常有用的工具，可以在保护本机不受侵害的情况下，对恶意代码的实际行为进行有效的监控，并且可以通过快照功能讯速恢复系统，因此，此技术的博弈也随之展开[1]。
一些恶意代码编写人员在其恶意程序中加入虚拟环境检测功能，一旦程序发现自身处于虚拟环境中，则可能休眠或者改变行为策略，甚至破坏虚拟机环境[2]。
因此，在利用虚拟机进行恶意代码分析的同时，了解恶意代码的虚拟环境检测技术并对其检测功能进行防范，是信息安全工作人员重要工作之一。
虚拟机环境检测方法研究综述
虚拟机环境检测方法研究综述随着云计算、虚拟化技术的不断发展，越来越多的计算机系统和应用程序开始部署在虚拟机环境中。
虚拟机环境的出现为企业节省了大量资金，减少了系统维护和升级所需的时间和人力成本，但也引发了一些安全问题。
一些恶意软件和攻击者会利用虚拟机技术来逃避监测和检测，或者在虚拟机平台内进行攻击和侵入。
因此，对虚拟机环境的检测就成为了当下的一个热门研究领域。
本文将就虚拟机环境检测方法进行一些综述。
1. 操作系统检测虚拟机环境检测的第一步就是进行操作系统的检测。
这主要分为两种方法：（1）查看虚拟化所用的驱动程序等硬件信息和关键配置文件，例如VMware Tools和Hyper-V Integration Services。
（2）检测操作系统的特性，例如CPU的架构、安装的驱动程序和应用程序等。
2. 虚拟化检测虚拟化检测主要是检测虚拟化工具，这可以帮助我们确定一个系统是否在虚拟化环境下运行。
虚拟化检测的方法主要是通过检测指定的虚拟化工具如VMware、VirtualBox等是否已经安装并且运行。
3. 虚拟机监控检测虚拟机监控检测可以帮助我们检测虚拟机环境下虚拟机的状况。
检测包括检查虚拟机是否已安装、虚拟机网络连接状况、虚拟机硬件的配置信息，虚拟机内存使用信息等。
4. 虚拟机网络流量检测虚拟机网络流量检测主要是想要检查虚拟机与其他物理服务器和网络终端之间的流量，并从中找出异常的流量，以提醒安全人员开展进一步的调查。
5. 安全漏洞检测与物理服务器环境一样，虚拟机环境也存在着安全漏洞。
漏洞一旦被攻击者找到，将直接导致虚拟机环境的崩溃或被窃取虚拟机中的敏感数据。
因此，安全漏洞检测非常重要，可以帮助企业及时发现自身虚拟环境中的漏洞并及时修复。
总之，虚拟机环境检测需要采用多种方法综合达到效果。
这也说明了虚拟机环境检测是一个复杂而宏大的研究领域，需要依托高效的技术、精通企业的业务和组织的专业安全人员相互协作，才能更加准确地检测虚拟机环境中的各种异常。
IDS计算机病毒
20
高级反病毒的技术
更高的反病毒方法和产品不断涌现。在 这一节中我们将对其中最重要的两种进 行重点说明: 通用解密和数字免疫系统。
21
通用加密
通用加密 (GD) 技术使得反病毒软件能够 在保证足够快的扫描速度的同时，也能 够轻松地检测到最为复杂的病毒变种 。 回想一下当含有多态病毒的文件执行时, 病毒必须首先将自身解密以得到激活。 为了检测到这样的病毒结构可执行文件 应该通过GD扫描器运行。
目前的流行技术
虚拟机技术 计算机监控技术 数字免疫系统 压缩智能还原技术 启发式代码扫描技术 文件时事监控技术
13
启发式代码扫描技术
启发式指的“自我发现的能力”或“运 用某种方式或方法去判定事物的知识和 技能。”
一个运用此技术的病毒检测软件，实际 上就是以特定方式实现的动态跟踪器或 反编译器，通过对有关指令序列的反编 译逐步理解和确定其蕴藏的真正动机。
8
特征码扫描技术
分析出病毒的特征病毒码并集中存放于病 毒代码库文件中，在扫描时将扫描对象与 特征代码库比较，如有吻合则判断为染上 病毒。
查杀病毒滞后，并且庞大的特征码库会造 成查毒速度下降；
但是对加密、变形的新病毒无能为力。
9
反病毒的方法
第二代反病毒技术采用静态广谱特征扫 描技术，可以检测变形病毒，但是误报 率高，杀毒风险大。
2
对待计算机病毒应持有的态度
1. 客观承认计算机病毒的存在，但不要 惧怕病毒。
2. 树立计算机病毒意识，积极采取预防 （备份等）措施。
3. 掌握必要的计算机病毒知识和病毒防 治技术，对用户至关重要。
try catch 原理
try catch 原理try catch是一种异常处理机制，它可以捕捉代码运行时抛出的异常并进行处理。
在Java中，异常可以是由程序员手动抛出的，比如输入错误，空指针引用等等。
同时还有一些异常是由Java虚拟机抛出的，比如在程序运行时遇到了不合法的操作，或者内存用尽等等。
try catch语句包含两个部分，try和catch。
在try块中的代码是被检测的异常代码，当其中的代码抛出了异常，程序就会跳转到catch块。
在catch块中，程序员可以对该异常进行处理或者记录日志，然后程序会继续运行try/catch之后的代码。
如果catch块中没有捕捉到异常，那么异常就会一直传递到上一层调用的catch块直到有异常被捕获或者是在程序结束之前继续传递到最外层的try/catch块。
try catch的机制有如下特点：1. 异常处理能力。
通过try catch机制，我们可以知道程序发生了什么异常并对其进行处理，提高程序的可靠性。
2. 可读性。
try catch机制让代码变得更易于阅读，尤其是在复杂的代码块中。
使用try catch机制减少了代码深度的嵌套。
3. 提高程序的逻辑性。
通过try catch机制，开发人员可以将异常处理作为程序执行的一个逻辑分支，使得程序更加完善。
4. 减少程序的错误。
当程序出现异常时，除了可以中止程序，也可以通过try catch机制处理异常，避免让整个程序崩溃。
try catch机制的缺点：1. 有些人认为try catch机制会让代码变得臃肿，但实际上并没有。
相反，try catch机制可以使得代码更加简洁。
2. 程序员很容易不去处理异常，或者是不处理正确，导致更多的问题。
因此，程序员应该重视异常处理，让程序更加健壮。
因此，try catch机制是Java中非常重要的一部分，开发人员应该掌握它的机制和使用方法。
在开发过程中，需要合理地使用try catch机制，以便让程序执行更加稳定和健壮。
恶意代码技术和检测方法
恶意代码及其检测技术1.恶意代码概述1.1定义恶意代码也可以称为Malware，目前已经有许多定义。
例如Ed Skoudis将Malware定义为运行在计算机上，使系统按照攻击者的意愿执行任务的一组指令。
微软“计算机病毒防护指南”中奖术语“恶意软件”用作一个集合名词，指代故意在计算机系统上执行恶意任务的病毒、蠕虫和特洛伊木马。
随着网络和计算机技术的快速发展，恶意代码的传播速度也已超出人们想象，特别是人们可以直接从网站获得恶意代码源码或通过网络交流代码。
很多编程爱好者把自己编写的恶意代码放在网上公开讨论，发布自己的研究成果，直接推动了恶意代码编写技术发展。
所以目前网络上流行的恶意代码及其变种层出不穷，攻击特点多样化。
1.2类型按照恶意代码的运行特点，可以将其分为两类：需要宿主的程序和独立运行的程序。
前者实际上是程序片段，他们不能脱离某些特定的应用程序或系统环境而独立存在；而独立程序是完整的程序，操作系统能够调度和运行他们；按照恶意代码的传播特点，还可以把恶意程序分成不能自我复制和能够自我复制的两类。
不能自我复制的是程序片段，当调用主程序完成特定功能时，就会激活它们；能够自我复制的可能是程序片段（如病毒），也可能是一个独立的程序（如蠕虫）。
2.分析与检测的方法恶意代码与其检测是一个猫捉老鼠的游戏，单从检测的角度来说。
反恶意代码的脚步总是落后于恶意代码的发展，是被动的.目前基于主机的恶意代码检测方法主要有反恶意代码软件、完整性校验法以及手动检测，基于网络的检测方法主要有基于神经网络”、基于模糊识别“等方法，本文主要讨论基于主机的检测。
2.1 恶意代码分析方法2.1.1 静态分析方法是指在不执行二进制程序的条件下进行分析，如反汇编分析，源代码分析，二进制统计分析，反编译等，属于逆向工程分析方法。
（1）静态反汇编分析，是指分析人员借助调试器来对而已代码样本进行反汇编出来的程序清单上根据汇编指令码和提示信息着手分析。
ebpf虚拟机工作原理
ebpf虚拟机工作原理ebpf虚拟机是一种基于Linux内核的虚拟机技术，它的全称是Extended Berkeley Packet Filter。
ebpf虚拟机的工作原理是通过在内核中插入一段精简的代码，实现对内核进行动态扩展和定制化。
本文将详细介绍ebpf虚拟机的工作原理和应用场景。
一、ebpf虚拟机的基本原理ebpf虚拟机的核心是一种特殊的指令集，它可以在内核中执行。
这些指令集被称为ebpf指令集，它是一种安全的、可扩展的、高性能的虚拟机指令集。
ebpf指令集通过一种特殊的编程语言来描述，这种语言被称为ebpf语言。
在运行时，ebpf虚拟机将ebpf程序加载到内核中，并通过特定的hook点来执行ebpf程序。
ebpf程序可以访问内核中的数据结构，比如网络数据包、系统调用等，并对其进行处理和过滤。
ebpf程序可以通过一系列的指令来完成这些操作，比如读取数据、修改数据、判断条件等。
ebpf虚拟机的设计目标是高性能和安全性。
它通过一系列的优化手段来提高执行效率，比如JIT编译、Just-In-Time优化等。
同时，ebpf虚拟机还提供了一套严格的安全机制，确保ebpf程序不能对内核造成破坏。
二、ebpf虚拟机的应用场景ebpf虚拟机在Linux内核中被广泛应用于各种场景，下面列举了几个常见的应用场景。
1. 网络分析和监控：ebpf虚拟机可以通过在网络协议栈中插入ebpf程序，实现对网络数据包的实时分析和监控。
通过ebpf程序可以提取出关键信息，比如源IP地址、目标IP地址、协议类型等，从而实现对网络流量的统计和分析。
2. 安全防护：ebpf虚拟机可以通过在系统调用中插入ebpf程序，实现对系统调用的监控和过滤。
通过ebpf程序可以检测和过滤恶意的系统调用，从而提高系统的安全性。
此外，ebpf虚拟机还可以与安全工具集成，实现更强大的安全防护功能。
3. 性能优化：ebpf虚拟机可以通过在关键路径上插入ebpf程序，实现对系统性能的监控和优化。
虚拟机软件的漏洞和虚拟机执行环境的检测与反检测漏洞预警-电脑资料
虚拟机软件的漏洞和虚拟机执行环境的检测与反检测漏洞预警-电脑资料1、最近发生的关于虚拟机软件的漏洞VM产品的漏洞有一些特殊性，涉及到几个操作环境，比如有主操作系统、客操作系统，还有一个比较特殊的是它的虚拟机管理器里面也可能有漏洞，。
我列出了大概五种可以产生漏洞的地方。
首先是VMM本身可能有漏洞，我列出了三个。
其中有一个是比较新的，是在x64系统模拟上VMM存在漏洞，这使Guest OS可以提升本地权限。
当然在Guest OS里面也可能有漏洞,一个比较典型的案例就是CVE-2007-5671,这个就是利用在客操作系统里面安装的一个驱动程序HGFS.sys,这个HGFS使主操作系统和客操作系统可以共享文件和目录。
它里面存在一个漏洞，这个漏洞是驱动上是非常常见的，对IO ctl提供的参数没有进行足够的验证，导致从用户态能够读写任意的内存地址。
这也是本地提权非常典型的一个案例。
现在我个人觉得，像这种利用驱动IO ctl来提权的情况发生的比较多。
原因是因为有很多IO ctl fuzz工具的产生,可以向一个驱动设备任意地发送IO ctl，并且变换它的参数。
如果发现机器蓝屏了，你就会觉得有可能这是可以利用的漏洞，它比较好找，发生的原因也比较简单,一般都是用户态传进来的参数，内核态可能直接拿参数里面的一个地址进行读写，而没有验证参数的合法性。
比较好分析漏洞的成因，所以数量就比较多。
当然在HOST OS里也存在比较多的漏洞，我列出了两个是我自己发现并上报给VMware的,是在Host OS中进行本地提权的两个漏洞。
如果一会儿还有时间，我会讲一下。
另外一个比较有趣的，也是比较独特的类型，是从客操作系统向主操作系统的逃逸。
比如说在Windows里执行Linux代码，可以从Linux VM里面渗透出来,在Windows主操作系统环境里面执行代码，这就叫做VM逃逸。
最近比较常见的就是我列出的三个，一个HGFS 堆溢出,一个是HGFS共享目录遍历漏洞,还有一个是通过RPC的调用。
9恶意代码检测与防范
15
恶意代码防治
恶意代码防范，是指通过建立合理的病毒防范体系和 制度，及时发现计算机病毒侵入，并采取有效的手 段阻止计算机病毒的传播和破坏，从计算机中清除 病毒代码，恢复受影响的计算机系统和数据。
可分为引导型、文件型、混合型病毒 如CIH病毒，宏病毒等
6
计算机病毒传染传播
病毒的两种存在状态
静态：仅存在于文件中 激活：驻留内存，可以感染其他文件或磁盘
仅感染本机的文件 随感染文件的传播而传播 传播方式
– 软盘、移动硬盘、U盘、光盘等，特别是盗版光 盘
– 文件共享、电子邮件、网页浏览、文件下载
9
木马
木马是一种程序，它能提供一些有用的或者令人 感兴趣的功能，但是还具有用户不知道的其它功 能。 木马不具有传染性，不能自我复制，通常不被当 成病毒 典型木马如冰河、灰鸽子、Bo2K等
10
特洛伊木马的分类
–远程访问型 –密码发送型 –键盘记录型 –破坏型 –FTP型 –DoS攻击型 –代理型
木马
防范体系 – 管理体系 – 技术体系
防治策略 – 主动预防为主、被动处理为辅 – 预防、检测、清除相结合
16
一般预防措施
• 及时备份重要数据和系统数据 • 关注漏洞公告，及时更新系统或安装补丁程序 • 新购置的机器、磁盘、软件使用前进行病毒检测 • 不要下载或使用来历不明的软件 • 外用的磁盘尽量要写保护，外来的磁盘要检毒 • 安装具有实时防病毒功能的防病毒软件，并及时
网络安全技术中的恶意代码检测与分析
网络安全技术中的恶意代码检测与分析1.引言随着互联网的不断发展，网络安全问题越来越引起人们的关注。
恶意代码（Malware）是一种能够损害计算机系统的程序，常见的恶意代码有病毒、蠕虫、木马、广告软件和僵尸网络等。
这些恶意代码不仅会破坏计算机系统，还会泄露个人隐私和商业机密等重要信息。
因此，在网络安全技术中，恶意代码检测和分析是非常重要的一个方面。
2.恶意代码分类在进行恶意代码检测和分析之前，必须先了解恶意代码的类型。
根据恶意代码的特性和目的，可以将恶意代码分为以下几类：2.1 病毒病毒是恶意代码中最为常见的一种，它会通过在合法程序中插入代码来感染其他程序，在用户不知情的情况下进行自我复制和传播。
病毒具有隐蔽性和破坏性，能够在计算机系统中扩散，并在病毒感染的计算机上执行一定的恶意行为，比如删除文件和窃取用户信息等。
2.2 蠕虫蠕虫是一种自我复制的计算机程序，它可以自主传播到计算机网络中的其他计算机，具有很高的感染力和传染速度。
和病毒不同，蠕虫可以完全自主运行而不需要依附于其他程序。
2.3 木马木马是一个伪装成合法程序的恶意代码，常常伪装成一些有用的软件来诱骗用户下载和安装。
一旦安装，木马就能够实现远程控制和命令执行等功能，攻击者可以通过木马窃取用户信息、攻击其他计算机系统等。
2.4 广告软件广告软件是一种通过弹窗、网页等形式来展示广告或者强制用户进行某些操作的程序。
广告软件也常常被称为“流氓软件”，因为它们经常会在用户不知情的情况下安装，占用带宽和资源，影响用户体验。
2.5 僵尸网络僵尸网络是由大量被感染的计算机组成的网络，攻击者可以通过这个网络来发起各种攻击。
一旦计算机感染了恶意软件，攻击者就可以远程控制它来实现各种目的，如发起DDoS攻击、窃取用户信息和进行网络钓鱼等。
3.恶意代码检测技术面对不同类型的恶意代码，必须采用不同的检测技术来进行检测。
下面介绍几种常见的恶意代码检测技术。
3.1 签名检测签名检测是一种常见的恶意代码检测技术，它是通过对已经发现的恶意代码进行分析和特征提取来建立恶意代码库，然后对系统中的二进制文件进行扫描匹配，从而检测出是否感染了恶意代码。
黑莓错误代码大全
在BLACKBERRY黑莓手持设备上java虚拟机可能出现的错误代码和详细信息101 Previous startup failed当jvm启动过程中，前一个启动的项目失败了，设备已经被重置。
这个错误表明jvm在启动时找到“启动进行中”这个标志位已经设置了，当前屏幕信息为：有意停止“系统继续重置”这个死循环，来纠正系统当前不正确的启动操作102 Invalid code in filesystem在文件系统中发现无效的代码。
手持设备的系统检查.cod文件的变动时，在一些.cod文件中检测到这个问题。
他肯可能是表明生成过程中发生了错误，即在cod文件中存在一个有问题的签名。
如果一些用户操作设备导致这个问题的发生，文件系统的代码被破坏，复位的周期将是连续循环的。
唯一的恢复方法是擦去设备并且恢复一个新的系统。
103 Cannot find starting address找不到启动的地址，用于启动系统的引导cod文件找不到。
这个错误表明一个用于引导系统的cod文件没有安装到设备上，或者格式不正确。
104 Uncaught: <Java-type-name>非预期：《java模块名》jvm诊断出一个非预期的java代码异常错误抛出，程序可以继续执行，或者手持设备可以用桌面管理器连是USB线安装一个程序调试器来查看这些错误信息。
事件日志里应该包含了异常错误的信息105 Example, DbRecSize举例，DbRecSize文件系统API已经为一种特定的操作返回一种错误状态码，他可能表明在jvm上存在一个无效的或者错误的文件系统106 Graphics system error图形系统错误，在设备的图形系统里一个错误发生并被检测到107 operator new() called在jvm里，操作new()回调一个c++类，该函数代码没有被正确的从VMRamObject对象来继承，新操作符需要被正确的继承。
pl0源代码
源代码pl0c.h/* 关键字个数 */#define norw 13/* 名字表容量 */#define txmax 100/* 所有的add1用于定义数组 */#define txmaxadd1 101/* number的最大位数 */#define nmax 14/* 符号的最大长度 */#define al 10/* 地址上界 */#define amax 2047/* 最大允许过程嵌套声明层数 */#define levmax 3/* 最多的虚拟机代码数 */#define cxmax 200#define cxmaxadd1 201/* 当函数中会发生fatal error时，返回-1告知调用它的函数，最终退出程序 */#define getsymdo if(-1==getsym())return -1#define getchdo if(-1==getch())return -1#define testdo(a,b,c) if(-1==test(a,b,c))return -1#define gendo(a,b,c) if(-1==gen(a,b,c))return -1#define expressiondo(a,b,c) if(-1==expression(a,b,c))return -1#define factordo(a,b,c) if(-1==factor(a,b,c))return -1#define termdo(a,b,c) if(-1==term(a,b,c))return -1#define conditiondo(a,b,c) if(-1==condition(a,b,c))return -1#define statementdo(a,b,c) if(-1==statement(a,b,c))return -1#define constdeclarationdo(a,b,c) if(-1==constdeclaration(a,b,c))return -1#define vardeclarationdo(a,b,c) if(-1==vardeclaration(a,b,c))return -1typedef enum {false,true} bool;/* 符号 */enum symbol{nul,ident,number,plus,minus,times,slash,oddsym,eql,neq,lss,leq,gtr,geq,lparen,rparen,comma, semicolon,period,becomes,beginsym,endsym,ifsym,thensym,whilesym,writesym,readsym,dosym,calls ym,constsym,varsym,procsym};#define symnum 32/* 名字表中的类型 */enum object {constant,variable,procedur};/* 虚拟机代码 */enum fct {lit,opr,lod,sto,cal,inte,jmp,jpc};#define fctnum 8/* 虚拟机代码结构 */struct instruction{enum fct f; /* 虚拟机代码指令 */int l; /* 引用层与声明层的层次差 */int a; /* 根据f的不同而不同 */};FILE* fas; /* 输出名字表 */FILE* fa; /* 输出虚拟机代码 */FILE* fa1; /* 输出源文件及其各行对应的首地址 */FILE* fa2; /* 输出结果 */bool listswitch; /* 显示虚拟机代码与否 */bool tableswitch; /* 显示名字表与否 */char ch; /* 获取字符的缓冲区，getch 使用 */enum symbol sym; /* 当前的符号 */char id[al]; /* 当前ident */int num; /* 当前number */int cc,ll,kk; /* getch使用的计数器，cc表示当前字符(ch)的位置 */ int cx; /* 虚拟机代码指针 */char line[81]; /* 读取行缓冲区 */char a[al]; /* 临时符号 */struct instruction code[cxmaxadd1]; /* 存放虚拟机代码的数组 */ char word[norw][al]; /* 保留字 */enum symbol wsym[norw]; /* 保留字对应的符号值 */enum symbol ssym[256]; /* 单字符的符号值 */char mnemonic[fctnum][5]; /* 虚拟机代码指令名称 */bool declbegsys[symnum]; /* 表示声明开始的符号集合 */bool statbegsys[symnum]; /* 表示语句开始的符号集合 */bool facbegsys[symnum]; /* 表示因子开始的符号集合 *//* 名字表结构 */struct tablestruct{char name[al]; /* 名字 */enum object kind; /* 类型：const,var or procedure */int val; /* 数值，仅const使用 */int level; /* 所处层，仅const不使用 */int adr; /* 地址，仅const不使用 */int size; /* 需要分配的数据区空间，仅procedure使用 */ };struct tablestruct table[txmaxadd1]; /* 名字表 */FILE* fin;FILE* fout;char fname[al];int err; /* 错误计数器 */void error(int n);int getsym();int getch();void init();int gen(enum fct x,int y,int z);int test(bool* s1,bool* s2,int n);int inset(int e,bool* s);int addset(bool* sr,bool* s1,bool* s2,int n);int subset(bool* sr,bool* s1,bool* s2,int n);int mulset(bool* sr,bool* s1,bool* s2,int n);int block(int lev,int tx,bool* fsys);void interpret();int factor(bool* fsys,int* ptx,int lev);int term(bool* fsys,int* ptx,int lev);int condition(bool* fsys,int* ptx,int lev);int expression(bool* fsys,int* ptx,int lev);int statement(bool* fsys,int* ptx,int lev);void listcode(int cx0);int vardeclaration(int* ptx,int lev,int* pdx);int constdeclaration(int* ptx,int lev,int* pdx);int postion(char* idt,int tx);void enter(enum object k,int* ptx,int lev,int* pdx);int base(int l,int* s,int b);pl0c.c/*Windows 下c语言PL/0编译程序在Visual C++ 6.0和Visual 上运行通过使用方法：运行后输入PL/0源程序文件名回答是否输出虚拟机代码回答是否输出名字表fa.tmp输出虚拟机代码fa1.tmp输出源文件及其各行对应的首地址fa2.tmp输出结果fas.tmp输出名字表*/#include <stdio.h>#include "pl0c.h"#include "string.h"/* 解释执行时使用的栈 */#define stacksize 500int main(){bool nxtlev[symnum];init(); /* 初始化 */fas=fopen("fas.tmp","w");fa1=fopen("fa1.tmp","w");printf("Input file? ");fprintf(fa1,"Input file? ");scanf("%s",fname); /* 输入文件名 */fin=fopen(fname,"r");if(fin){fprintf(fa1,"%s\n",fname);printf("List object code?(Y/N)"); /* 是否输出虚拟机代码 */scanf("%s",fname);listswitch=(fname[0]=='y'||fname[0]=='Y');printf("List symbol table?(Y/N)"); /* 是否输出名字表 */scanf("%s",fname);tableswitch=(fname[0]=='y'||fname[0]=='Y');err=0;cc=cx=ll=0;ch=' ';kk=al-1;if(-1!=getsym()){fa=fopen("fa.tmp","w");fa2=fopen("fa2.tmp","w");addset(nxtlev,declbegsys,statbegsys,symnum);nxtlev[period]=true;if(-1==block(0,0,nxtlev)) /* 调用编译程序 */{fclose(fa);fclose(fa1);fclose(fin);printf("\n");return 0;}fclose(fa);fclose(fa1);if(sym!=period)error(9);if(err==0)interpret(); /* 调用解释执行程序 */else{printf("Errors in pl/0 program");}}fclose(fin);}else{printf("Can't open file!\n");fprintf(fa1,"Can't open file!\n");fclose(fa1);}fclose(fas);printf("\n");return 0;}/* 在适当的位置显示错误 */void error(int n){char space[81];memset(space,32,81);space[cc-1]=0; /* 出错时当前符号已经读完，所以cc-1 */printf("****%s!%d\n",space,n);fprintf(fa1,"****%s!%d\n",space,n);err++;}/* 词法分析，获取一个符号 */int getsym(){int i,j,k;while(ch==' '||ch==10||ch==9) /* 忽略空格、换行和TAB */{getchdo;}if(ch>='a'&&ch<='z'){ /* 名字或保留字以a..z开头 */k=0;do{if(k<al){a[k]=ch;k++;}getchdo;}while(ch>='a'&&ch<='z'||ch>='0'&&ch<='9');a[k]=0;strcpy(id,a);i=0;j=norw-1;do/* 搜索当前符号是否为保留字 */{k=(i+j)/2;if(strcmp(id,word[k])<=0)j=k-1;if(strcmp(id,word[k])>=0)i=k+1;}while(i<=j);if(i-1>j)sym=wsym[k]; else sym=ident; /* 搜索失败则，是名字或数字 */ }else{if(ch>='0'&&ch<='9'){ /* 检测是否为数字：以0..9开头 */k=0;num=0;sym=number;do{num=10*num+ch-'0';k++;getchdo;}while(ch>='0'&&ch<='9'); /* 获取数字的值 */k--;if(k>nmax)error(30);}else{if(ch==':') /* 检测赋值符号 */{getchdo;if(ch=='='){sym=becomes;getchdo;}else{sym=nul; /* 不能识别的符号 */}}else{if(ch=='<') /* 检测小于或小于等于符号 */{getchdo;if(ch=='='){sym=leq;getchdo;}else{sym=lss;}}else{if(ch=='>') /* 检测大于或大于等于符号 */{getchdo;if(ch=='='){sym=geq;getchdo;}else{sym=gtr;}}else{sym=ssym[ch]; /* 当符号不满足上述条件时，全部按照单字符符号处理 */getchdo;}}}}}return 0;}/* 生成虚拟机代码 */int gen(enum fct x, /* f */int y, /* l */int z /* a */){if(cx>cxmax){printf("Program too long"); /* 程序过长 */return -1;}code[cx].f=x;code[cx].l=y;code[cx].a=z;cx++;return 0;}/* 在某一部分（如一条语句，一个表达式）将要结束时时我们希望下一个符号属于某集合（该部分的后跟符号），test负责这项监测，并且负责当监测不通过时的补救措施，程序在需要检测时指定当前需要的符号集合和补救用的集合（如之前未完成部分的后跟符号），以及检测不通过时的错误号 */int test(bool* s1, /* 我们需要的符号 */bool* s2, /* 如果不是我们需要的，则需要一个补救用的集合 */int n) /* 错误号 */{if(!inset(sym,s1)){error(n);/* 当检测不通过时，不停获取符号，直到它属于需要的集合或补救的集合 */while((!inset(sym,s1))&&(!inset(sym,s2))){getsymdo;}}return 0;}/* 编译程序主体 */int block(int lev, /* 当前分程序所在层 */int tx, /* 名字表当前尾指针 */bool* fsys /* 当前模块后跟符号集合 */){int i;int dx; /* 名字分配到的相对地址 */int tx0; /* 保留初始tx */int cx0; /* 保留初始cx */bool nxtlev[symnum]; /* 在下级函数的参数中，符号集合均为值参，但由于使用数租实现，传递进来的是指针，为防止下级函数改变上级函数的集合，开辟新的空间传递给下级函数，之后所有的nxtlev都是这样 */dx=3;tx0=tx; /* 记录本层名字的初始位置 */table[tx].adr=cx;gendo(jmp,0,0);if(lev>levmax)error(32);do{if(sym==constsym) /* 收到常量声明符号，开始处理常量声明 */{getsymdo;do{constdeclarationdo(&tx,lev,&dx); /* dx的值会被constdeclaration改变，使用指针 */while(sym==comma){getsymdo;constdeclarationdo(&tx,lev,&dx);}if(sym==semicolon){getsymdo;}else error(5);}while(sym==ident);}if(sym==varsym) /* 收到变量声明符号，开始处理变量声明 */{getsymdo;do{vardeclarationdo(&tx,lev,&dx);while(sym==comma){getsymdo;vardeclarationdo(&tx,lev,&dx);}if(sym==semicolon){getsymdo;}else error(5);}while(sym==ident);}while(sym==procsym) /* 收到过程声明符号，开始处理过程声明 */{getsymdo;if(sym==ident){enter(procedur,&tx,lev,&dx); /* 记录过程名字 */getsymdo;}else error(4); /* procedure后应为标识符 */if(sym==semicolon){getsymdo;}else error(5); /* 漏掉了分号 */memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[semicolon]=true;if(-1==block(lev+1,tx,nxtlev))return -1; /* 递归调用 */if(sym==semicolon){getsymdo;memcpy(nxtlev,statbegsys,sizeof(bool)*symnum);nxtlev[ident]=true;nxtlev[procsym]=true;testdo(nxtlev,fsys,6);}else error(5); /* 漏掉了分号 */}memcpy(nxtlev,statbegsys,sizeof(bool)*symnum);nxtlev[ident]=true;testdo(nxtlev,declbegsys,7);}while(inset(sym,declbegsys)); /* 直到没有声明符号 */code[table[tx0].adr].a=cx; /* 开始生成当前过程代码 */table[tx0].adr=cx; /* 当前过程代码地址 */table[tx0].size=dx; /* 声明部分中每增加一条声明都会给dx增加1，声明部分已经结束，dx就是当前过程数据的size */cx0=cx;gendo(inte,0,dx); /* 生成分配内存代码 */if(tableswitch) /* 输出名字表 */{printf("TABLE:\n");if(tx0+1>tx)printf(" NULL\n");for(i=tx0+1;i<=tx;i++){switch(table[i].kind){case constant:printf(" %d const %s ",i,table[i].name);printf("val=%d\n",table[i].val);fprintf(fas," %d const %s ",i,table[i].name);fprintf(fas,"val=%d\n",table[i].val);break;case variable:printf(" %d var %s ",i,table[i].name);printf("lev=%d addr=%d\n",table[i].level,table[i].adr);fprintf(fas," %d var %s ",i,table[i].name);fprintf(fas,"lev=%d addr=%d\n",table[i].level,table[i].adr);break;case procedur:printf(" %d proc %s ",i,table[i].name);printf("lev=%d addr=%dsize=%d\n",table[i].level,table[i].adr,table[i].size);fprintf(fas," %d proc %s ",i,table[i].name);fprintf(fas,"lev=%d addr=%dsize=%d\n",table[i].level,table[i].adr,table[i].size);break;}}printf("\n");}/* 语句后跟符号为分号或end */memcpy(nxtlev,fsys,sizeof(bool)*symnum); /* 每个后跟符号集和都包含上层后跟符号集和，以便补救 */nxtlev[semicolon]=true;nxtlev[endsym]=true;statementdo(nxtlev,&tx,lev);gendo(opr,0,0); /* 每个过程出口都要使用的释放数据段指令 */memset(nxtlev,0,sizeof(bool)*symnum); /*分程序没有补救集合 */testdo(fsys,nxtlev,8); /* 检测后跟符号正确性 */listcode(cx0); /* 输出代码 */return 0;}/* 解释程序 */void interpret(){int p,b,t; /* 指令指针，指令基址，栈顶指针 */struct instruction i; /* 存放当前指令 */int s[stacksize]; /* 栈 */printf("start pl0\n");t=0;b=0;p=0;s[0]=s[1]=s[2]=0;do{i=code[p]; /* 读当前指令 */p++;switch(i.f){case lit: /* 将a的值取到栈顶 */s[t]=i.a;t++;break;case opr: /* 数学、逻辑运算 */switch(i.a){case 0:t=b;p=s[t+2];b=s[t+1];break;case 1:s[t-1]=-s[t-1];break;case 2:t--;s[t-1]=s[t-1]+s[t];break;case 3:t--;s[t-1]=s[t-1]-s[t];break;case 4:t--;s[t-1]=s[t-1]*s[t];break;case 5:t--;s[t-1]=s[t-1]/s[t];break;case 6:s[t-1]=s[t-1]%2;break;case 8:t--;s[t-1]=s[t-1]==s[t];break;case 9:t--;s[t-1]=s[t-1]!=s[t];break;case 10:t--;s[t-1]=s[t-1]<s[t];break;case 11:t--;s[t-1]=s[t-1]>=s[t];break;case 12:t--;s[t-1]=s[t-1]>s[t];break;case 13:t--;s[t-1]=s[t-1]<=s[t];break;case 14:printf("%d",s[t-1]);fprintf(fa2,"%d",s[t-1]);t--;break;case 15:printf("\n");fprintf(fa2,"\n");break;case 16:printf("?");fprintf(fa2,"?");scanf("%d",&(s[t]));fprintf(fa2,"%d\n",s[t]);t++;break;}break;case lod: /* 取相对当前过程的数据基地址为a的内存的值到栈顶 */ s[t]=s[base(i.l,s,b)+i.a];t++;break;case sto: /* 栈顶的值存到相对当前过程的数据基地址为a的内存 */ t--;s[base(i.l,s,b)+i.a]=s[t];break;case cal: /* 调用子过程 */s[t]=base(i.l,s,b); /* 将父过程基地址入栈 */s[t+1]=b; /* 将本过程基地址入栈，此两项用于base函数 */s[t+2]=p; /* 将当前指令指针入栈 */b=t; /* 改变基地址指针值为新过程的基地址 */p=i.a; /* 跳转 */break;case inte: /* 分配内存 */t+=i.a;break;case jmp: /* 直接跳转 */p=i.a;break;case jpc: /* 条件跳转 */t--;if(s[t]==0)p=i.a;break;}}while(p!=0);fclose(fa2);}/* 初始化 */void init(){int i;/* 设置单字符符号 */for(i=0;i<=255;i++)ssym[i]=nul;ssym['+']=plus;ssym['-']=minus;ssym['*']=times;ssym['/']=slash;ssym['(']=lparen;ssym[')']=rparen;ssym['=']=eql;ssym[',']=comma;ssym['.']=period;ssym['#']=neq;ssym[';']=semicolon;/* 设置保留字名字 */strcpy(&(word[0][0]),"begin");strcpy(&(word[1][0]),"call");strcpy(&(word[2][0]),"const"); strcpy(&(word[3][0]),"do");strcpy(&(word[4][0]),"end");strcpy(&(word[5][0]),"if");strcpy(&(word[6][0]),"odd");strcpy(&(word[7][0]),"procedure"); strcpy(&(word[8][0]),"read"); strcpy(&(word[9][0]),"then"); strcpy(&(word[10][0]),"var"); strcpy(&(word[11][0]),"while"); strcpy(&(word[12][0]),"write");/* 设置保留字符号 */wsym[0]=beginsym;wsym[1]=callsym;wsym[2]=constsym;wsym[3]=dosym;wsym[4]=endsym;wsym[5]=ifsym;wsym[6]=oddsym;wsym[7]=procsym;wsym[8]=readsym;wsym[9]=thensym;wsym[10]=varsym;wsym[11]=whilesym;wsym[12]=writesym;/* 设置指令名称 */strcpy(&(mnemonic[lit][0]),"lit"); strcpy(&(mnemonic[opr][0]),"opr"); strcpy(&(mnemonic[lod][0]),"lod"); strcpy(&(mnemonic[sto][0]),"sto"); strcpy(&(mnemonic[cal][0]),"cal"); strcpy(&(mnemonic[inte][0]),"int"); strcpy(&(mnemonic[jmp][0]),"jmp"); strcpy(&(mnemonic[jpc][0]),"jpc");/* 设置符号集 */for(i=0;i<symnum;i++){declbegsys[i]=false;statbegsys[i]=false;facbegsys[i]=false;}/* 设置声明开始符号集 */declbegsys[constsym]=true;declbegsys[varsym]=true;declbegsys[procsym]=true;/* 设置语句开始符号集 */statbegsys[beginsym]=true;statbegsys[callsym]=true;statbegsys[ifsym]=true;statbegsys[whilesym]=true;/* 设置因子开始符号集 */facbegsys[ident]=true;facbegsys[number]=true;facbegsys[lparen]=true;}/* 用数组实现集合的集合运算 */int inset(int e,bool* s){return s[e];}int addset(bool* sr,bool* s1,bool* s2,int n) {int i;for(i=0;i<n;i++){sr[i]=s1[i]||s2[i];}return 0;}int subset(bool* sr,bool* s1,bool* s2,int n) {int i;for(i=0;i<n;i++){sr[i]=s1[i]&&(!s2[i]);}return 0;}int mulset(bool* sr,bool* s1,bool* s2,int n){int i;for(i=0;i<n;i++){sr[i]=s1[i]&&s2[i];}return 0;}/* 供getsym取一个字符，每次读一行，存入line缓冲区，line被getsym取空时再读一行*/ int getch(){if(cc==ll){if(feof(fin)){printf("program incomplete");return -1;}ll=0;cc=0;printf("%d ",cx);fprintf(fa1,"%d ",cx);ch=' ';while(ch!=10){fscanf(fin,"%c",&ch);printf("%c",ch);fprintf(fa1,"%c",ch);line[ll]=ch;ll++;}printf("\n");fprintf(fa1,"\n");}ch=line[cc];cc++;return 0;}/* 生成一项名字表 */void enter(enum object k, /* 名字种类const,var or procedure */int* ptx, /* 名字表尾指针的指针，为了可以改变名字表尾指针的值，以后所有的ptx 都是这样 */int lev, /* 名字所在的层次,，以后所有的lev都是这样 */int* pdx /* dx为当前应分配的变量的相对地址，分配后要增加1，所以使用指针，以后所有的pdx都是这样 */){(*ptx)++;strcpy(table[(*ptx)].name,id); /* 全局变量id中已存有当前名字的名字 */table[(*ptx)].kind=k;switch(k){case constant: /* 常量名字 */if(num>amax){error(31); /* 数值越界 */num=0;}table[(*ptx)].val=num;break;case variable: /* 变量名字 */table[(*ptx)].level=lev;table[(*ptx)].adr=(*pdx);(*pdx)++;break;case procedur: /* 过程名字*/table[(*ptx)].level=lev;break;}}/* 查找名字的位置 *//* 找到则返回在名字表中的位置，否则返回0 */int postion(char* idt, /* 要查找的名字 */int tx /* 当前名字表尾指针 */){int i;strcpy(table[0].name,idt);i=tx;while(strcmp(table[i].name,idt)!=0)i--;return i;}/* 常量声明处理 */int constdeclaration(int* ptx,int lev,int* pdx){if(sym==ident){getsymdo;if(sym==eql||sym==becomes){if(sym==becomes)error(1); /* 把=写成了:= */getsymdo;if(sym==number){enter(constant,ptx,lev,pdx);getsymdo;}else error(2); /* 常量说明=后应是数字 */ }else error(3); /* 常量说明标识后应是= */ }else error(4); /* const后应是标识 */return 0;}/* 变量声明处理 */int vardeclaration(int* ptx,int lev,int* pdx){if(sym==ident){enter(variable,ptx,lev,pdx); /* 填写名字表 */getsymdo;}else error(4); /* var后应是标识 */return 0;}/* 输出代码 */void listcode(int cx0){int i;if(listswitch){for(i=cx0;i<cx;i++){printf("%d %s %d %d\n",i,mnemonic[code[i].f],code[i].l,code[i].a);fprintf(fa,"%d %s %d %d\n",i,mnemonic[code[i].f],code[i].l,code[i].a);}}}/* 语句处理 */int statement(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */{int i,cx1,cx2;bool nxtlev[symnum]; /* 意义见block函数 */if(sym==ident) /* 准备按照赋值语句处理 */{i=postion(id,*ptx);if(i==0)error(11); /* 变量未找到 */else{if(table[i].kind!=variable){error(12); /* 赋值语句格式错误 */i=0;}}getsymdo;if(sym==becomes){getsymdo;}else error(13); /* 检测赋值符号 */memcpy(nxtlev,fsys,sizeof(bool)*symnum);expressiondo(nxtlev,ptx,lev); /* 处理赋值符号右侧表达式 */if(i!=0){gendo(sto,lev-table[i].level,table[i].adr); /* expression将执行一系列指令，但最终结果将会保存在栈顶，执行sto命令完成赋值 */}}else{if(sym==readsym) /* 准备按照read语句处理 */{getsymdo;if(sym!=lparen)error(34); /* 格式错误，应是左括号 */else{do{getsymdo;if(sym==ident)i=postion(id,*ptx); /* 查找要读的变量 */else i=0;if(i==0)error(35); /* read()中应是声明过的变量名 */else{gendo(opr,0,16); /* 生成输入指令，读取值到栈顶 */gendo(sto,lev-table[i].level,table[i].adr); /* 储存到变量 */}getsymdo;}while(sym==comma); /* 一条read语句可读多个变量 */}if(sym!=rparen){error(33); /* 格式错误，应是右括号 */while(!inset(sym,fsys)) /* 出错补救，直到收到上层函数的后跟符号 */getsymdo;}else{getsymdo;}}else{if(sym==writesym) /* 准备按照write语句处理，与read类似 */{getsymdo;if(sym==lparen){do{getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[rparen]=true;nxtlev[comma]=true; /* write的后跟符号为) or , */expressiondo(nxtlev,ptx,lev); /* 调用表达式处理，此处与read不同，read为给变量赋值 */.gendo(opr,0,14); /* 生成输出指令，输出栈顶的值 */}while(sym==comma);if(sym!=rparen)error(33); /* write()中应为完整表达式 */else{getsymdo;}}gendo(opr,0,15); /* 输出换行 */}else{if(sym==callsym) /* 准备按照call语句处理 */{getsymdo;if(sym!=ident)error(14); /* call后应为标识符 */else{i=postion(id,*ptx);if(i==0)error(11); /* 过程未找到 */else{if(table[i].kind==procedur){gendo(cal,lev-table[i].level,table[i].adr); /* 生成call指令 */}else error(15); /* call后标识符应为过程 */}getsymdo;}}else{if(sym==ifsym) /* 准备按照if语句处理 */{getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[thensym]=true;nxtlev[dosym]=true; /* 后跟符号为then或do */conditiondo(nxtlev,ptx,lev); /* 调用条件处理（逻辑运算）函数 */if(sym==thensym){getsymdo;}else error(16); /* 缺少then */cx1=cx; /* 保存当前指令地址 */gendo(jpc,0,0); /* 生成条件跳转指令，跳转地址未知，暂时写0 */statementdo(fsys,ptx,lev); /* 处理then后的语句 */code[cx1].a=cx; /* 经statement处理后，cx为then后语句执行完的位置，它正是前面未定的跳转地址 */}else{if(sym==beginsym) /* 准备按照复合语句处理 */{getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[semicolon]=true;nxtlev[endsym]=true; /* 后跟符号为分号或end *//* 循环调用语句处理函数，直到下一个符号不是语句开始符号或收到end */statementdo(nxtlev,ptx,lev);while(inset(sym,statbegsys)||sym==semicolon){if(sym==semicolon){getsymdo;}else error(10); /* 缺少； */statementdo(nxtlev,ptx,lev);}if(sym==endsym){getsymdo;}else error(17); /* 缺少end或； */}else{if(sym==whilesym) /* 准备按照while语句处理 */{cx1=cx; /* 保存判断条件操作的位置 */getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[dosym]=true; /* 后跟符号为do */conditiondo(nxtlev,ptx,lev); /* 调用条件处理 */cx2=cx; /* 保存循环体的结束的下一个位置 */gendo(jpc,0,0); /* 生成条件跳转，但跳出循环的地址未知*/if(sym==dosym){getsymdo;}else error(18); /* 缺少do */statementdo(fsys,ptx,lev); /* 循环体 */gendo(jmp,0,cx1); /* 回头重新判断条件 */code[cx2].a=cx; /* 反填跳出循环的地址，与if类似 */}memset(nxtlev,0,sizeof(bool)*symnum); /* 语句结束无补救集合*/testdo(fsys,nxtlev,19); /* 检测语句结束的正确性 */}}}}}}return 0;}/* 表达式处理 */int expression(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */{enum symbol addop; /* 用于保存正负号 */bool nxtlev[symnum];if(sym==plus||sym==minus) /* 开头的正负号，此时当前表达式被看作一个正的或负的项 */ {addop=sym; /* 保存开头的正负号 */getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev); /* 处理项 */if(addop==minus)gendo(opr,0,1); /* 如果开头为负号生成取负指令 */ }else/* 此时表达式被看作项的加减 */{memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev); /* 处理项 */}while(sym==plus||sym==minus){addop=sym;getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev); /* 处理项 */if(addop==plus){gendo(opr,0,2); /* 生成加法指令 */}else gendo(opr,0,3); /* 生成减法指令 */}return 0;}/* 条件处理 */int condition(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ {enum symbol relop;bool nxtlev[symnum];if(sym==oddsym) /* 准备按照odd运算处理 */{getsymdo;expressiondo(fsys,ptx,lev);gendo(opr,0,6); /* 生成odd指令 */}else{/* 逻辑表达式处理 */memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[eql]=true;nxtlev[neq]=true;nxtlev[lss]=true;nxtlev[leq]=true;nxtlev[gtr]=true;nxtlev[geq]=true;expressiondo(nxtlev,ptx,lev);if(sym!=eql&&sym!=neq&&sym!=lss&&sym!=leq&&sym!=gtr&&sym!=geq)error(20);else{relop=sym;getsymdo;expressiondo(fsys,ptx,lev);switch(relop){case eql:gendo(opr,0,8);break;case neq:gendo(opr,0,9);break;case lss:gendo(opr,0,10);break;case geq:gendo(opr,0,11);break;case gtr:gendo(opr,0,12);break;case leq:gendo(opr,0,13);break;}}}return 0;}/* 项处理 */int term(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */ {enum symbol mulop; /* 用于保存乘除法符号 */bool nxtlev[symnum];memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[times]=true;nxtlev[slash]=true;factordo(nxtlev,ptx,lev); /* 处理因子 */while(sym==times||sym==slash){mulop=sym;getsymdo;factordo(nxtlev,ptx,lev);if(mulop==times){gendo(opr,0,4); /* 生成乘法指令 */}else{gendo(opr,0,5); /* 生成除法指令 */}}return 0;}/* 因子处理 */int factor(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */{int i;bool nxtlev[symnum];testdo(facbegsys,fsys,24); /* 检测因子的开始符号 */while(inset(sym,facbegsys)) /* 循环直到不是因子开始符号 */{if(sym==ident) /* 因子为常量或变量 */{i=postion(id,*ptx); /* 查找名字 */if(i==0)error(11); /* 名字未声明 */else{switch(table[i].kind){case constant: /* 名字为常量 */gendo(lit,0,table[i].val); /* 直接把常量的值入栈 */break;case variable: /* 名字为变量 */gendo(lod,lev-table[i].level,table[i].adr); /* 找到变量地址并将其值入栈 */break;case procedur: /* 名字为过程 */error(21); /* 不能为过程 */break;}}getsymdo;}else{if(sym==number) /* 因子为数 */{if(num>amax){error(31);num=0;}gendo(lit,0,num);getsymdo;}else{if(sym==lparen) /* 因子为表达式 */{getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[rparen]=true;expressiondo(nxtlev,ptx,lev);if(sym==rparen){getsymdo;}else error(22); /* 缺少右括号 */}test(fsys,facbegsys,23); /* 因子后有非法符号 */ }}}return 0;}/* 通过过程基址求上l层过程的基址 */int base(int l,int* s,int b){int b1;b1=b;while(l>0){b1=s[b1];l--;}return b1;}。
基于机器学习算法的恶意代码检测方法研究
基于机器学习算法的恶意代码检测方法研究一、引言随着互联网的快速发展，计算机病毒、木马、蠕虫等恶意代码也越来越多地威胁着计算机系统的安全。
恶意代码可以窃取用户的个人信息和财务信息，并破坏重要的计算机系统。
因此，研究恶意代码检测方法对于保障计算机网络安全具有重要的意义。
二、恶意代码检测概述恶意代码检测是一种防范恶意软件的技术，其目的在于识别恶意软件并提供保护策略，以协助组织提高其计算机安全。
恶意代码检测可以分为静态分析和动态分析两种方法。
静态分析是在不执行代码的情况下分析其源代码，基于特征提取等静态特性分析技术检测恶意代码。
静态分析方法主要包括特征提取、规则匹配、人工智能等技术。
在特征提取中，研究人员通过提取恶意代码的重要特征，如API调用序列、控制流图等来进行检测。
规则匹配中，研究人员制定一定的规则，比如模式匹配和语法分析，以此来判断是否为恶意代码。
人工智能技术中，研究人员采用机器学习的方法来训练模型以检测恶意代码。
与静态分析研究视角不同，动态分析是在执行恶意代码时分析其行为，随后基于行为特征检测恶意代码。
动态分析方法主要包括行为分析和虚拟机监控等技术。
在行为分析中，研究人员分析恶意代码执行时的系统行为，以此来判定是否为恶意代码。
虚拟机监控中，研究人员使用虚拟运行环境来实现对受感染的系统行为的监视。
三、基于机器学习算法的恶意代码检测方法研究人工智能技术在恶意代码检测的静态分析方法中起到重要的作用，尤其是机器学习算法，因其无需人为界定规则或分类因素，可以自动从样本中学习和分析特征。
其中，深度学习算法是近年来最受欢迎的机器学习算法之一，其利用神经网络对数据进行特征提取和预测，已经在恶意代码检测领域中得到广泛应用。
1. 深度学习算法卷积神经网络（CNN）是一种常用的深度学习算法，可用于恶意代码检测。
CNN是一个多层处理过程，它从原始数据中学习本征特征，并使用特征图进行数据分类。
研究表明，CNN算法对于静态分析提取的程序文件特征表现优异。
Java异常处理之异常处理机制一：try-catch-finally
Java异常处理之异常处理机制⼀：try-catch-finally⼀、Java 异常处理 编写程序时，要在出现可能出现错误的时候加上检测的代码，如判断分母为0，数据为空，过多的 if-else分⽀导致程序代码加长，臃肿，可读性差，因此采⽤异常处理机制。
Java采⽤的异常处理机制，是将异常处理的程序代码集中在⼀起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。
⼆、异常处理：抓抛模型 1、抛出 Java 程序的执⾏过程中出现异常，会⽣成⼀个异常类对象，该异常对象将被提交给 Java 运⾏时系统，这个过程称为抛出（throw）异常。
⼀旦抛出对象以后，其后的代码就不再执⾏。
2、捕获、“抓” 可以理解为异常的处理⽅式：① try-catch-finally; ② throws; 3、异常对象的⽣成 （1）由虚拟机⾃动⽣成：程序运⾏过程中，虚拟机检测到程序发⽣了问题，如果在当前代码中没有找到相应的处理程序，就会在后台⾃动创建⼀个对应异常类的实例对象并抛出——⾃动抛出； （2）由开发⼈员⼿动创建：Exception exception = new ClassCastException；——创建好的异常对象不抛出对程序没有任何影响，和创建⼀个普通对象⼀样； 4、处理异常过程 （1）当程序运⾏到某⼀句时，发⽣了异常，那么程序会先停下来； （2）程序会在这句代码处，查看原因，⽣成⼀个合理“异常对象”，然后“抛”出； （3）JVM 会检测这句代码的外围，是否有 try...catch 结构，可以“捕获”它； （4）如果可以捕获，那么程序在处理完异常后，继续下⾯的运⾏，不会崩溃； （5）如果不能捕获，那么会把这个异常继续抛给“上级”，如果“上级”能处理，那么程序从“上级"处理完的代码后⾯继续运⾏； （6）如果上级也不能处理，那么继续往上抛，⼀直到达JVM，那么就“崩溃”； ①如果⼀个⽅法内抛出异常，该异常对象会被抛给调⽤者⽅法中处理。
虚拟机去虚拟化及检测技术攻防
虚拟机去虚拟化及检测技术攻防在当今信息安全领域，特别是恶意软件分析中，经常需要利用到虚拟机技术，以提高病毒分析过程的安全性以及硬件资源的节约性，因此它在恶意软件领域中是应用越来越来广泛。
这里我们所谓的虚拟机（Virtual Machine）是指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。
通过虚拟机软件（比如VMware，Virtual PC ,VirtualBox），你可以在一台物理计算机上模拟出一台或多台虚拟的计算机，这些虚拟机完全就像真正的计算机那样进行工作，例如你可以安装操作系统、安装应用程序、访问网络资源等等。
攻击者为了提高恶意程序的隐蔽性以及破坏真实主机的成功率，他们都在恶意程序中加入检测虚拟机的代码，以判断程序所处的运行环境。
当发现程序处于虚拟机（特别是蜜罐系统）中时，它就会改变操作行为或者中断执行，以此提高反病毒人员分析恶意软件行为的难度。
本文主要针对基于Intel CPU的虚拟环境VMware中的Windows XP SP3系统进行检测分析，并列举出当前常见的几种虚拟机检测方法。
方法一：通过执行特权指令来检测虚拟机Vmware为真主机与虚拟机之间提供了相互沟通的通讯机制，它使用“IN”指令来读取特定端口的数据以进行两机通讯，但由于IN指令属于特权指令，在处于保护模式下的真机上执行此指令时，除非权限允许，否则将会触发类型为“EXCEPTION_PRIV_INSTRUCTION”的异常，而在虚拟机中并不会发生异常，在指定功能号0A（获取VMware版本）的情况下，它会在EBX中返回其版本号“VMXH”；而当功能号为0x14时，可用于获取 VMware内存大小，当大于0时则说明处于虚拟机中。
VMDetect正是利用前一种方法来检测VMware的存在，其检测代码分析如下：代码:bool IsInsideVMWare(){ bool rc = true; __try { __asm { push edx push ecx push ebx mov eax, 'VMXh' mov ebx, 0 // 将 ebx设置为非幻数’VMXH’的其它值mov ecx, 10 // 指定功能号，用于获取VMWare版本，当它为0x14时用于获取VMware内存大小mov edx, 'VX' // 端口号in eax, dx // 从端口dx读取 VMware版本到eax//若上面指定功能号为0x14时，可通过判断eax中的值是否大于0，若是则说明处于虚拟机中cmp ebx, 'VMXh' // 判断ebx中是否包含VMware版本’VMXh’，若是则在虚拟机中setz [rc] // 设置返回值pop ebx pop ecx po p edx } } __except(EXCEPTION_EXECUTE_HANDLER) // 如果未处于VMware中，则触发此异常{ rc = false; } return rc;}测试结果：图1如图1所示，VMDetect成功检测出VMWare的存在。
虚拟机检测与反检测技术研究
＼Ｓｃｓｉ＼Ｓｃｓｉ Ｐｏｒｔ０＼Ｓｃｓｉ Ｂｕｓ ０＼Ｔａｒｇｅｔ
Ｕｎｉｔ ｌｄ ０＼Ｉｄｅｎｔｉｆｉｅｒ
ＨＫＥＹ—ＬＯＣＡＬ＿ＭＡＣＨＩＮＥ＼ＨＡＲＤⅥ伊岫＼ＤＥⅥＣＥＭＡＰ
＼Ｓｃｓｉ＼Ｓｃｓｉ ＰｏｒｔＩ＼Ｓｃｓｉ Ｂｕｓ ０＼Ｔａｒｇｅｔ Ｉｄ ０、Ｌｏｇｉｃａｉ Ｕｎｉｔ Ｉｄ ０＼Ｉｄｅｎｔｉｆｉｅｒ ＨＫＥＹ＿ＬＯＣＡＬ＿ＭＡＣＨＩＮＥ＼ＳＹＳＴＥＭ＼ＣｏｎｔｍｌＳｅｔ００ｌ＼Ｃｏ
如果大于则说明该代码运行在寄宿主机上，如果小于则声称 。红色药丸”在宿主主机上运行。红色药丸可以检测各样的
虚拟环境，包括ＶｉｓｕａｌＰＣ和ＶＭｗａｒｃ，而且可以在各式的操
作系统下运行，包括ｗｉｎｘｐ，ｗｉｎ２０００、ｌｉｎｕｘ。不过在一些ｌｉｎｕｘ 操作系统中，由于一些安全机制阻止从ｒｉｎ宙到ｒｉｎ９０层的调 用，这样就会导致红色药丸产生段错误，无法正常进行检测。
进行研究，然后针对当前一些恶意代码使用的虚拟检测技术 进行反检测研究。
ｌ 虚拟机技术
资源的节约性，因此虚拟机技术在恶意软件领域中是应用越 来越广泛。因此，攻击者为了让自己的代码运行在真实的系 统中而不是虚拟机中，其就必须有检测虚拟机的机制。另外，
本文所指的虚拟机（Ｖｉｒｔｕａｌ Ｍａｃｈｉｎｅ）是指通过软件模拟 的具有完整硬件系统功能的、运行在一个完全隔离环境中的完 整计算机系统。通过虚拟机环境【Ｍ咖ａｌＭａｃｈ硫ＥｎｖｉｒｏｎＩｎｌｅｎｔ）， 比如ｖＭｗａｒｅ、Ｖｉｒｔｕａｌ ＰＣ、Ｘｅｎ、ＢＯＣＨＳ以及用户模式下的 Ｌｉｎｕｘ，你可以在一台宿主计算机上模拟出一台或多台虚拟的
（（ｖｏｉｄ（＋）Ｏ）＆ｒｐｉｌｌ）Ｏ； 后ＩＤＴ地址保存在数组ｍ中
／／执行ＳＩＤＴ指令，并将读取
ｐｒｉｎｔｆ（”ｉｄｔ ｂａ．ｓｅ：％弟ｘｍ”，＋（（ｕｎｓｉｇｎｅｄ＋）＆ｍ【２】））； ／／由于前２字节为ＩＤＴ大小，因此从ｍ【２】开始即为 ＩＤＴ地址