Code Virtualizer基于代码虚拟化的功能强大的混淆系统-中文资源,最新版免费下载,在线文档,视频教程,正版购买-慧都网-慧都网

下载：307 收藏：44

查看价格免费下载

Code Virtualizer 商城购买 (产品编号：11365)

Code Virtualizer 是一个强大的代码搅乱系统。它可以帮助软件开发者保护他们软件内重要和敏感的代码区，防止他人使用逆向工程，而且它只消耗最小的系统资源。

标签：代码混淆

开发商： Oreans

当前版本： v3.2.0.0

产品类型：软件

产品功能：加密/解密

平台语言：英文

开源水平：不提供源码

本产品的分类与介绍仅供参考，具体以商家网站介绍为准，如有疑问请来电 023-68661681 咨询。

Code Virtualizer 是一个强大的代码搅乱系统。它可以帮助软件开发者保护他们软件内重要和敏感的代码区，防止他人使用逆向工程，而且它只消耗最小的系统资源。
Code Virtualizer 将你源代码（Intel x86 指令）转化成虚拟的指令，只有内部的虚拟机器可以明白这些指令。对于每一个所保护的程序，这些所产生的虚拟指令以及虚拟机器本身都是独特的，以防止他人对 Code Virtualizer 采用广泛的攻击。
Code Virtualizer 可以在任何 x32 或 x64 原生 PE 文档中（例如可执行文档(EXEs),system　services,DLLs,OCXs,ActiveX 控制档，荧幕保护程序以及装置驱动程序）保护你重要和敏感的代码区。

* 关于本产品的分类与介绍仅供参考，精准产品资料以官网介绍为准，如需购买请先行测试。

逆向工程的基本原理

当一个程序被创建时，编译器会将程序的源代码编译成多个含有机器语言代码的对象档案。然后，这些对象档案会被衔接在一起而产生最后的可执行文档。

图 1: 编译你的原代码

当一个软件破解者尝试破解一个编译过的程序时，他会使用反编译器具将机器语言代码反编译成另一种更容易让人明白的代码（例如汇编语言或者一种更高级的程序语言），然后对于这反编译成的语言进行研究。

图 2: 对你的程序作反编译

当一个软件破解者对于目标程序拥有很好的了解时，他可以更改这个编译过的程序来改变它的运行。例如 , 软件破解者可以在程序里绕过一组用来检验试用期限的例程，使它可以永久运作。更严重的是，软件破解者可以使程序看来已经经过注册那样地来运作。

代码虚拟化和逆向工程的比较

代码虚拟化主要是将一组二元码转化成另一种另一个机器才明白的二元码。换句话说，一个特定机器的指令将被转变成另一个机器的指令。下图展示的是一组 Intel x86 指令转变成另一个机器的指令（一个 32- 位的精简指令集计算机的指令）

图 3: Intel x86 指令转变成精简指令集计算机的指令

Code Virtualizer 可以产生多种拥有个别指令集的虚拟机器。换句话说，一组特定的 Intel x86 指令可以在个别的机器里被转变成各种不同的指令集，以防一个软件破解者从中辨别任何所产生的虚拟码。下图展示了一组 Intel x86 指令如何可以被转变成各种不同种类的虚拟机器所模拟的虚拟码。

图 4: x86 到多种虚拟 CPU 的转化

当一个软件破解者尝试对一组受到 Code Virtualizer 保护的代码进行反编译时，他无法找到任何本来的 x86 指令，而只会发现一个他或其它特别的反编译器完全陌生的、新的指令集。这将迫使软件破解者使用非常多的努力来研究每一行的代码的意思以及学习每一个受保护程序内的虚拟机器的运作原理。 Code Virtualizer 完完全全地对虚拟码的运行以及个别虚拟机器的学习进行了搅乱，以阻止任何人学习当中的虚拟码是如何运作的。

现实生活上的代码虚拟化

Code Virtualizer 可以被轻易地内嵌进你的 Win32 或 Win64 程序以及驱动程序里。你只需要在你的源代码当中选择你要使用 Code Virtualizer 保护的代码区。下面的例子展示你如何可以在 C 程序里保护一个特定的代码区。

#include <stdio.h>
#include "VirtualizerSDK.h"

  void main()
  {
      VIRTUALIZER_START      // the area to protect starts here

printf("Hello World");

VIRTUALIZER_END // end of area to protect
}

VIRTUALIZER_START/VIRTUALIZER_END 宏都只是多余的宏，它们不会对原来的程序的运行有任何的影响。只有当一个受保护的程序运行进入保护时段时， Code Virtualizer 可以辨认这些受保护的程序区，然后将它们转变成一个虚拟机器明白的虚拟代码。

下图展示了一个原来编译过的程序（在还没有受保护时）以及当它被 Code Virtualizer 保护时所经过的转变。

图 5: 原来的程序和受保护程序的比较

如图所示， Code Virtualizer 需要将所产生的虚拟机器内嵌进受保护程序的末端，以便在程序运行的时候可以对模拟运行这些虚拟代码。虚拟机器的大小可以相等于 10 Kb 到 30 Kb （大小取决于所选择的复杂程度），对于最后所产生的受保护程序的大小没有太大的影响。

结论

Code Virtualizer 是一个可以用来防止别人窥视你重要且敏感的程序的强大技术 , 例如你用来检验所输入的注册序号是否正确的例程。此外， Code Virtualizer 稍微改比变受保护程序里的 PE 标头，这意味着你可以在 Code Virtualizer 上置入一个压缩器或另一个软件保护层。

如果你是一个驱动程序的开发者，而且为了找不到一个保护驱动程序的解决方案而烦恼， Code Virtualizer 提供你一种相同于保护你程序和 DLL 的技术来保护你的驱动程序（ 32- 位或者 64- 位）。

今天就尝试 Code Virtualizer ，开始为你的 32- 位 /64- 位程序以及驱动程序里置入软件保护业里最新的技术吧！

以下是 Code Virtualizer® 的主要特点：

使用多个虚拟机器进行搅乱
对每个受保护程序进行独特的保护
保护任何的 x32 和 x64 程序以及驱动程序
先进的变异引擎
代码重组来保护 DLLs 和驱动程序
在独特的虚拟机器里模拟任何 Intel x86 代码
每个受保护程序里都有独特的虚拟码
完全兼容于任何的压缩器 / 软件保护层
由指令列加载的保护

Basics about Reverse Engineering

When an application is being created, the Compiler will compile the application source code into several object files made of machine language code. Afterward, the object files are linked together to create the final executable.

Figure 1: Compilation of your source code

When an attacker tries to crack a compiled application, he will use a decompiler tool which will decompile the machine language code into a more comprehensive code (like assembly code or a higher programming language), doing his research over the decompiled code.

Figure 2: Decompilation of your application

When the attacker has a good knowledge of the target application, he can modify the compiled application to alter its behavior. For example, the attacker could bypass the routine that checks for the trial period in an application and make it run forever, or, even worse, cause the application to behave as if it was registered.

Code Virtualization against Reverse Engineering

Code virtualization consists of the transformation of binary code from a specific machine into a different binary code that is understood by another machine. That is, the instruction set from a specific machine is converted into a new instruction set which is understood by a different machine. The following picture represents the transformation from a block of Intel x86 instructions into a new instruction set for another machine (specifically a RISC 32-bit CPU):

Figure 3: Transformation from x86 to RISC 32-bit CPU

Code Virtualizer can generate multiple types of virtual machines with a different instruction set for each one. This means that a specific block of Intel x86 instructions can be converted into different instruction set for each machine, preventing an attacker from recognizing any generated virtual opcode after the transformation from x86 instructions. The following picture represents how a block of Intel x86 instructions is converted into different kinds of virtual opcodes, which could be emulated by different virtual machines.

Figure 4: Transformation from x86 to multiple Imaginary CPUs

When an attacker tries to decompile a block of code that was protected by Code Virtualizer, he will not find the original x86 instructions. Instead, he will find a completely new instruction set which is not recognized by him or any other special decompiler. This will force the attacker to go through the extremely hard work of identifying how each opcode is executed and how the specific virtual machine works for each protected application. Code Virtualizer totally obfuscates the execution of the virtual opcodes and the study of each unique virtual machine in order to prevent someone from studying how the virtual opcodes are executed.

Code Virtualization in RealLife

Code Virtualizer can be embedded inside your Win32 and Win64 applications and device drivers with ease. You just need to select which areas in your source code are going to be protected by Code Virtualizer. The following example shows how you can protect a block of code in a C application.

#include <stdio.h>
#include "VirtualizerSDK.h"

void main()
{
VIRTUALIZER_START   ; // the area to protect starts here

;  printf("Hello World");

VIRTUALIZER_END // end of area to protect
}

The VIRTUALIZER_START/VIRTUALIZER_END macros are dummy macros which do not interfere with the execution of the original application. It's only in protection-time when Code Virtualizer will recognize those areas of code and will covert them into unique virtual opcodes, which are then emulated by a virtual machine when the protected application is running.

The following picture represents the image of an original compiled application (before being protected) and how it's transformed when it's protected by Code Virtualizer:

Figure 5: Original Application versus Protected Application

As the image shows, Code Virtualizer needs to embed the generated virtual machine at the end of the protected application in order to emulate the virtual opcodes when they are going to be executed. The size of the virtual machine can vary from 10 Kb to 30 Kb (depending on the complexity level selected), making no impact in the final size of the protected application.

Final Words

Code Virtualizer is a powerful technology that can prevent someone from inspecting your sensitive code, such as your routines that validate an entered serial key for registering your application. Also, Code Virtualizer slightly modifies the PE header of the protected application, meaning you could put a compressor or other software protector on top of Code Virtualizer with no problems.

If you are a device driver developer and felt neglected when there was no solution to protect your device drivers, Code Virtualizer offers you the same technology to do so (for either 32-bit and 64-bit drivers) in the same way as your applications and DLLs.

Try Code Virtualizer today and start inserting the latest software protection into your Win32/Win64 applications and device drivers!
These are the key features of Code Virtualizer®: