摘  要  包含有大部分或全部源码信息的软件发行版本的普及，比如易被反编译成源码的Java字节代码，增加了软件被恶意逆向工程攻击的可能。文章介绍了面向对象语言的类分裂混淆方法，同时也给出了混淆技术的定义、分类和评判标准。

    关键词  逆向工程；代码混淆；软件保护；类分裂 

 

1  引言

    计算机软件的安全一直是软件企业和相关研究领域的关注重点，当前存在的软件保护技术分别有硬件辅助保护、序列号保护、加密保护、服务器认证、防篡改以及代码混淆等。随着JAVA语言、逆向工程的迅速发展和普遍运用以及恶意主机对软件的逆向分析等突出安全问题的不断涌现，使得代码混淆，这一新的保护软件安全的技术正越来越受到人们的重视。

2  代码混淆的定义和分类

2.1  代码混淆定义

    给定一个程序P、策略T，经过混淆变换后得到程序P' (见图 1)。此过程称之为混淆变换，如果对程序进行一种功能保持的变换，变换后的程序拥有和原始程序相同的功能。更确切的说法应该包含以下两个条件：①如果P出错终止或终止失败，P'不一定终止。②P和P'在正常终止情况下，P'必须产生与P相同的输出。    所不同的是经过转换的P'相较P更难于被静态分析等逆向工程方法攻击，即使被反编译，生成的程序也难以被人阅读和理解。 图1  代码混淆

2.2  代码混淆分类

    根据混淆对象和对其进行操作的差别，可将代码混淆技术分为布局(layout)混淆、控制(control)混淆、数据(data)混淆、预防(preventive)混淆等几种。    (1)外形混淆。该类混淆主要包括对程序中的变量名、常量名、类名、方法名称等标识符作词法上的变换改名和删除程序中与执行无关的调试信息、注释、源码格式等。    (2)控制混淆。该类混淆的目的是使得攻击者对程序的控制流难以理解。主要包括打乱某段代码本身逻辑关系的聚集混淆(Aggregation Transformation)、把相关语句分散到程序不同位置并实现某项功能的次序混淆(Ordering Transformation)和隐藏真实执行路径的执行混淆(Computation Transformation)­­等。    (3)数据混淆。数据混淆的对象是程序中的数据域。它可细分为相关数据的储存(Storage)与编码(Encoding)方式的混淆、组合和拆分数据的聚集(Aggregation)混淆、位序重计的次序(Ordering)混淆等。    (4)预防混淆。与前述混淆类型针对恶意用户不同，预防混淆主要利用一些专用反编译器的设计缺陷，以使这些反编译器难以反向还原混淆之后的代码。例如，反编译器 mocha 对于 Return 后面的指令不进行反编译，Hosemocha 就是专门针对此缺陷，故意将代码放在 Return 语句后面，从而使反编译失效。

2.3  类分裂

    介绍完代码混淆的分类后，接下来我将就面向对象语言中的一种混淆技术：类分裂(class splitting)进行说明。首先对类分裂进行定义：类分裂是将一个初始(原)类用两个或两个以上的类来替换的混淆方法。对类分裂进行叙述前，我们规定以下相关使用术语的意义：        P：                  JAVA程序        Classes(P)：         P中一般类的集合        Interfaces(P)： P中接口类的集合        c_t：             Class或Interface中的任意类        Methods(c_t)：         c_t中的成员函数的集合        Field(c_t)：      c_t中的成员变量的集合    注：Methods(c_t)，Field(c_t)不包括从父类继承的成员函数和成员变量，而只包括：①当前定义类中新定义的成员函数和成员变量。②当前定义类所覆盖的其父类的成员函数。依赖(depends)关系的定义：    m，n Methods(c_t)，如果存在m调用n，则(m，n) ∈ depends    and m∈Methods(c_t)， f∈Field(c_t)，如果存在m使用了f，则(m，f) ∈ depends    为了便于用例的书写，特做说明，图2左列和右列的符号实际上表示同一类。

C	Ct
C1	Ct，1
Ct，1	Ct，2

图2    其次，由于类分裂的方法很多，为了叙述方便，我们假设将类c_t分裂成两个新类c_t，1和c_t，2，公式如下：     分裂函数u_split代表了这么一个分裂过程：原来的类的成员(成员函数或成员变量)被拆分到某个或是两个新类中。    分裂函数的选择必须考虑到成员函数之间或成员函数和成员变量之间的依赖关系，这是决定分裂函数是否有效的重要标准。下面的程序中，初始程序中的类C_t不能被分为混淆后的程序中两个毫无继承关系的新类，而应分裂为具有继承关系的类c_t，1和c_t，2。可以使用另一种表达方式描述：初始程序中类C_t的m2成员函数调用了m3成员函数，因此我们不能将m2作为c_t，1的成员函数，m3作为 c_t，2的成员函数，而c_t，1和c_t，2两者间无继承关系。而应将m2 作为子类c_t，2的成员函数，m3作为父类c_t，1的成员函数。且成员函数m3不需要修改，m3依旧调用m2。    如果出现这种情况：由于初始程序中的类设计本身存在缺陷，导致该类实际等同于多个类的组合。在此前提下，可以将初始类分裂为毫无继承关系的两个或两个以上新类。    将类分裂为具有继承关系的新类的方法产生了大量有效的分裂函数，这是因为这种分裂方法的约束条件非常简单且只具有惟一的限制：成员函数和成员函数所使用到的成员变量必须在同一类中定义，而这个类必须是定义成员函数的类。用公式表述如下：m∈Methods(c_t)：     if c_t，1∈ u_split(m)，then     n∈Methods(c_t))：depends(m，n)→c_t，1∈ u_split(n) and     f∈Fields(c_t))：depends(m，f) →c_t，1∈ u_split(f)    原则的体现如同下面所示类分裂混淆例子所示：成员函数m3调用了成员函数m4，因此将m3和m4定义为类c_t，1的成员函数。由于分裂函数u_split将m4函数分配给了类c_t，2，类c_t，1的成员函数m4其实只是一个虚假的程序段(函数)，它使恶意逆向工程人员以为调用的是c_t，1的成员函数m4。但实际情况是：程序运行期间c_t，1的成员函数m4将不会被调用，它将被c_t，2的m4成员函数所覆盖。同时，类c_t，1中构造函数用到的成员变量i，d都在类c_t，1定义，类c_t，2中构造函数用到的成员变量o则在类c_t，2定义。    接着，当新类产生后，必须要对原有的类型声明进行替换，主要包括：    ●成员函数的参数，成员变量和本地变量的类型声明由c_t变为c_t，1和c_t，2代替，程序中是C使用C1和C2代替。

　　[8]电大学习网.免费论文网[EB/OL]. /d/file/p/2024/0424/fontbr /> 

    ●原类构造函数的调用由c_t变为c_t，2，程序中用C2替代C，这是防止动态类型转换的一个简单替换。

 

初始程序                                                    混淆后的程序class C {                                                   class C1 {  private int i；                                             private int i；  private double d；                                     private double d；  protected Object o；                                 public C1() {  public C() {                                                      i=5；      i=5；                                                           d=1.0；      d=1.0；                                                 }      o=new Object()；                                  public C1(int iarg，double darg) {  }                                                                      i=iarg；  public C(int iarg，double darg) {                     d=darg；      i=iarg；                                                  }      d=darg；                                               public boolean m1() {      o=new Object()；           混淆变换                return i < 0；                                      }                                                   }  public boolean m1() {                               protected void m3(int iarg) {      return i < 0；                                                i=iarg；  }                                                                      m4(new Object())；  public void m2() {                                      }      d=3.0；                                                 public void m4(Object obj) {      m3(3)；                                                        o=obj.getClass()；  }                                                                }  protected void m3(int iarg) {                  }         i=iarg；                                               class C2 extends C1 {      m4(new Object())；                                protected Object o；  }                                                                 public C2() {  public void m4(Object obj) {                             super()；       o=obj；                                                         o=new Object()；  }                                                                }            }                                                                  public C(int iarg，double darg) {class D {                                                             super(iarg，darg)；  void n() {                                                          o=new Object()；     C c=new C()；                                         }    if (c.m1) {…}                                            public void m2() {    c.m2；                                                            d=3.0；    c.m4；                                                            m3(3)；  }                                                                }}                                                                  public void m4(Object obj) {                                                                          O=obj；                                                                   }                                                                }                                                                class D {                                                                     void n() {                                                                              C2 c=new C2()；                                                                              if (c.m1) {…}                                                                              c.m2；                                                                              c.m4；                                                                 }                                                              }    

 

3  代码混淆的评判指标

    程序混淆效果通常从强度(potency)、耐受性(resilience)、开销(cost)、隐蔽性(stealth)等 4个方面来评估：    (1)强度。指混淆变换后的程序相对原始的程序对恶意用户理解程序造成的困难程度或复杂度。    (2)耐受性。指混淆变换后的程序对使用自动去混淆工具进行攻击的抵抗度。其抵抗度大小与前述标准之一的强度的大小无直接联系，甚至可能出现某些强度很高的混淆变换对自动去混淆工具的抵抗能力却很差的情况。    (3)开销。指经过混淆变换后的程序在执行时由变换所带来的额外的执行时间和所需存储空间的开销。    (4)隐蔽性。耐受性好的混淆变换不容易被自动去混淆工具所去除，但却可能很容易被攻击者的人工分析识破。特别是，如果一种变换所引入的代码和原始程序有较大的差异性，就会轻易地被攻击者识破，因此应尽力使用与原代码相近的语法结构等来加强隐蔽性。

4  结语

    代码混淆的目的是防止对软件的逆向分析，从而有效保护软件知识产权。它通过改变程序本身，使其转换为极难理解和分析的新程序，最终让恶意攻击者在必须耗费其所不能承受的代价(时间或其它方面)面前，放弃对软件的分析来实现。但代码混淆技术作为一种新的软件保护方法，在理论基础、技术成熟度等方面依旧存在许多不足，这也将是代码混淆技术下一步要解决的问题。

参考文献

[1] C. Collberg，C. Thomborson，and D . Low. A Taxonomy of Obfuscating Transformations. Technical Report 148，July 1997[2] C. S. Collberg and C. Thomborson. Watermarking，Tamper-Proofing，and Obfuscation- Tools for Software Protection. IEEE Transaction on Software Engineering，28(8)：735-746，Aug，2002[3] H. Chang and M. Atallah. Protecting software code by guards. In Proceeding of the ACM Workshop on Security and Privacy in Digital Rights Managements，pages 160-175，Nov. 2001[4] C. Wang. A Security Architecture for Survivability Mechanisms. PhD thesis，University of Virginia，School of Engineering and Applied Science，October 2000[5] Mikhail Sosonkin，Gleb Naumovich and Nasir Memon. Obfuscation of design intent in object-oriented applications. Department of Computer and Information Science Polytechnic University 2003[6] 罗宏，蒋剑琴，曾庆凯．用于软件保护的代码混淆技术．计算机工程，第32卷第11期，2006.7[7] 宋亚奇．基于代码混淆的软件保护技术研究．硕士论文，西北工业大学，2005.6

　　[8]电大学习网.免费论文网[EB/OL]. /d/file/p/2024/0424/fontbr /> 

相关文章：

国家、市场与社会（下）从全球视野和批判角度审视中国传播04-26

国家、市场与社会（上）从全球视野和批判角度审视中国传播04-26

关于国家权力合法性04-26

刑法的意义与国家刑权力的调整——对人权两《公约》的04-26

和谐社会视域中的国家权力与社会权力04-26

审美权力假设与“国家美学”问题04-26

公民权利国家权力对立统一关系论纲04-26

人格魅力、权力制约与法治国家04-26

国家审计对权力的制约与监督探讨04-26

刑事政策的理论预设：国家、权力与公共政策04-26